/*******************************************
* Look the parameters in the CAEN Mail_box *
*                                          *
*******************************************/

#include <stdio.h>
#include <errno.h>
#include <strings.h>
#include <modes.h>
#include <ctype.h>
#include <module.h>
#include "a200.h"     /* definitions relative to the CAEN system */
#include "a200.hmn"
#include "../lib/mylib1.h"
#include "../dbase/hv_dbase.h"

#define NMAX 45
#define NOK 40
#define SECONDS
#define MINUTES  * 60
#define FINE     1001

SY227_MBOX *sy227_mod;
int sem_227mod_id;
SY127_MBOX *sy127_mod;
int sem_127mod_id;
char *caller;
char *all_chambers="0";

sighand(signal)
register int signal;
{
   printf(" %s :  signal %d received \n", *caller, signal);
   if ( signal >= 2 && signal <= 3){  /* ^C or ^E ?    */
      A200_end();
      sem_unl_del(sem_127mod_id, "sy127mod", caller);
      munlink(sy127_mod);
      sem_unl(sem_227mod_id, "sy227mod", caller);
      munlink(sy227_mod);
      exit(0);
   }
}


main(argc, argv)
int argc;
char *argv[];
{

   hv_mod_struct *mid;
   char old_chamber[6];
   char chamber_code[6];
   int dummy[10];
   char hv_line0_store[80];
   char hv_line1_store[80];
   char hv_line2_store[80];
   char hv_line3_store[80];
   char hv_line4_store[80];
   char hv_line5_store[80];
   char hv_line6_store[80];
   char hv_line7_store[80];
   char hv_line8_store[80];
   char hv_line9_store[80];
   char dis_line0_store[80];
   char dis_line1_store[80];
   char dis_line2_store[80];
   char dis_line3_store[80];
   char dis_line4_store[80];
   char dis_line5_store[80];
   char dis_line6_store[80];
   char dis_line7_store[80];
   char dis_line8_store[80];
   char dis_line9_store[80];
   char *hv_line[10], *dis_line[10];
   int inline;

   char *mod_name0 = "hv_config0";
   char *mod_name1 = "hv_config1";
   char *mod_name2 = "hv_config2";
   char *mod_name, *hv_config[3]; 
   int dis, sl;
   int cpu_nr, tcp_ip_nr;
   int ch1, ch2, first_print;

   int nwrite, nerror, par_val;
   short ndata, data[45], prot_word;
   short i, ir, j, k, chan, value, code;
   int n_good, n_bad;
   float imean, vmean;
   short imax, d_vmon[32], d_imon[32], d_status[32];
   short hv_ch, on_off, hv_in;
   int sy127_mod_vim_tim[6];
   int sy127_mod_sta_tim[6];
   int sy227_mod_vim_tim[6];
   int sy227_mod_sta_tim[6];
   int sy127_mod_sit_tim[6];
   int sy127_mod_nvim;
   int sy127_mod_nvim_err;
   int sy127_mod_nsta;
   int sy127_mod_nsta_err;
   int sy227_mod_nvim;
   int sy227_mod_nvim_err;
   int sy227_mod_nsta;
   int sy227_mod_nsta_err;
   short status_hv_ch;
   short v0_hv_ch;
   short v1_hv_ch;
   short vmon_hv_ch;
   short i1_hv_ch;
   short i0_hv_ch;
   short imon_hv_ch;
   int v1_active; 
   int i1_active; 
   int giorno, mese, anno, ora, minuti, secondi;
   int only_update = 0;
   int V_A = 0;
   int hv_line_nr, dis_line_nr, il;

   dis_line[0] = &dis_line0_store[0];
   dis_line[1] = &dis_line1_store[0];
   dis_line[2] = &dis_line2_store[0];
   dis_line[3] = &dis_line3_store[0];
   dis_line[4] = &dis_line4_store[0];
   dis_line[5] = &dis_line5_store[0];
   dis_line[6] = &dis_line6_store[0];
   dis_line[7] = &dis_line7_store[0];
   dis_line[8] = &dis_line8_store[0];
   dis_line[9] = &dis_line9_store[0];
   hv_line[0] = &hv_line0_store[0];
   hv_line[1] = &hv_line1_store[0];
   hv_line[2] = &hv_line2_store[0];
   hv_line[3] = &hv_line3_store[0];
   hv_line[4] = &hv_line4_store[0];
   hv_line[5] = &hv_line5_store[0];
   hv_line[6] = &hv_line6_store[0];
   hv_line[7] = &hv_line7_store[0];
   hv_line[8] = &hv_line8_store[0];
   hv_line[9] = &hv_line9_store[0];

   for ( i =  0; i < 10; i++){
      *hv_line[i] = '\0';
      *dis_line[i] = '\0';
   }
   
   strcpy(old_chamber, "??");

   intercept(sighand);

   if (argc >= 2 && strlen(argv[1]) <= 5)
      if (*argv[1] == '-' && (*(argv[1] + 1) == 'u' || *(argv[1] + 1) == 'U')){
         only_update = 1;
         strcpy(chamber_code, all_chambers);
      }
      else {
         strcpy(chamber_code, argv[1]);
      }
   else
      strcpy(chamber_code, all_chambers);

   if((sy127_mod = (SY127_MBOX *)modlink("sy127mod", 0)) == (SY127_MBOX *) -1)
      exit(_errmsg(errno,"hv_status: err. link data module\n"));

   sem_127mod_id = sem_link_cr("SY127mod", argv[0]);

   if((sy227_mod = (SY227_MBOX *)modlink("sy227mod", 0)) == (SY227_MBOX *) -1)
      exit(_errmsg(errno,"hv_status: err. link data module\n"));

   sem_227mod_id = sem_link_cr("SY227mod", argv[0]);

   get_config(&tcp_ip_nr, &cpu_nr, hv_config);
   mod_name = hv_config[cpu_nr];

   if ((mid = (hv_mod_struct *)modlink(mod_name, 0))
   == (hv_mod_struct *)-1)
      if ((mid = (hv_mod_struct *)modload(mod_name, 0))
      == (hv_mod_struct *)-1)
         exit(_errmsg(errno, "%s: error linking module %s\n", argv[0], 
         mod_name));

   sem_wait(sem_127mod_id, argv[0]);
   sem_wait(sem_227mod_id, argv[0]);

   for ( i = 0; i < 6; i++){
         sy127_mod_vim_tim[i] = sy127_mod->vim_tim[i];
         sy127_mod_sta_tim[i] = sy127_mod->sta_tim[i];
         sy227_mod_vim_tim[i] = sy227_mod->vim_tim[i];
         sy227_mod_sta_tim[i] = sy227_mod->sta_tim[i];
         sy127_mod_sit_tim[i] = sy127_mod->sit_tim[i];
   }
   sy127_mod_nvim = sy127_mod->nvim;
   sy127_mod_nvim_err = sy127_mod->nvim_err;
   sy127_mod_nsta = sy127_mod->nsta;
   sy127_mod_nsta_err = sy127_mod->nsta_err;
   sy227_mod_nvim = sy227_mod->nvim;
   sy227_mod_nvim_err = sy227_mod->nvim_err;
   sy227_mod_nsta = sy227_mod->nsta;
   sy227_mod_nsta_err = sy227_mod->nsta_err;

   sem_free(sem_127mod_id, argv[0]);
   sem_free(sem_227mod_id, argv[0]);

   data_ora( &anno, &mese, &giorno, &ora, &minuti, &secondi);
   printf("Present time:                %2d-%2d-%4d %2d:%2d:%2d\n",
            giorno, mese, anno, ora, minuti, secondi);

   printf("last update : SY127 V/I mon  %2d-%2d-%4d %2d:%2d:%2d",
         sy127_mod_vim_tim[2],
         sy127_mod_vim_tim[1],
         sy127_mod_vim_tim[0],
         sy127_mod_vim_tim[3],
         sy127_mod_vim_tim[4],
         sy127_mod_vim_tim[5]);
   printf("  nread %7d, err %4d\n",
          sy127_mod_nvim,
          sy127_mod_nvim_err);
   printf("              SY127 STATUS   %2d-%2d-%4d %2d:%2d:%2d",
         sy127_mod_sta_tim[2],
         sy127_mod_sta_tim[1],
         sy127_mod_sta_tim[0],
         sy127_mod_sta_tim[3],
         sy127_mod_sta_tim[4],
         sy127_mod_sta_tim[5]);
   printf("  nread %7d, err %4d\n",
          sy127_mod_nsta,
          sy127_mod_nsta_err);
   printf("              SY227 I mon    %2d-%2d-%4d %2d:%2d:%2d",
         sy227_mod_vim_tim[2],
         sy227_mod_vim_tim[1],
         sy227_mod_vim_tim[0],
         sy227_mod_vim_tim[3],
         sy227_mod_vim_tim[4],
         sy227_mod_vim_tim[5]);
   printf("  nread %7d, err %4d\n",
          sy227_mod_nvim,
          sy227_mod_nvim_err);
   printf("              SY227 STATUS   %2d-%2d-%4d %2d:%2d:%2d",
         sy227_mod_sta_tim[2],
         sy227_mod_sta_tim[1],
         sy227_mod_sta_tim[0],
         sy227_mod_sta_tim[3],
         sy227_mod_sta_tim[4],
         sy227_mod_sta_tim[5]);
   printf("  nread %7d, err %4d\n",
          sy227_mod_nsta,
          sy227_mod_nsta_err);
   printf("              tubi_sitter    %2d-%2d-%4d %2d:%2d:%2d\n",
         sy127_mod_sit_tim[2],
         sy127_mod_sit_tim[1],
         sy127_mod_sit_tim[0],
         sy127_mod_sit_tim[3],
         sy127_mod_sit_tim[4],
         sy127_mod_sit_tim[5]);


   if (only_update){
     printf("\n\n");
     for(dis = 0; dis < mid->n_crates; dis++)
       for(sl = 0; sl < 4; sl++)
         /* successivamente si potrebbe chiedere soltanto una camera */
         if(strcmp(chamber_code, mid->distr[dis].slot[sl].chamber) == 0
         || strcmp(chamber_code, mid->distr[dis].slot[sl].cable_name)
         == 0 || ( strcmp("0", chamber_code) == 0  &&
         mid->distr[dis].slot[sl].hv_ch_Ref >= 0 ) ) {
           if (mid->distr[dis].slot[sl].d_used_ch){
              if(strcmp(old_chamber, mid->distr[dis].slot[sl].chamber) ){
              if (mid->distr[dis].slot[sl].bad) 
                 printf("Chamber %s (crate %d slot %d): *BAD*: call expert!\n",
                        mid->distr[dis].slot[sl].cable_name, dis+1, sl);
              }
           }
         } 
      sem_unl_del(sem_127mod_id, "SY127mod", caller);
      sem_unl_del(sem_227mod_id, "SY127mod", caller);
      munlink(sy127_mod);
      munlink(sy227_mod);
      munlink(mid);
      exit(0);
   }

   sem_wait(sem_127mod_id, argv[0]);
   prot_word = sy127_mod->hv_par[1].prot_word;
   sem_free(sem_127mod_id, argv[0]);

   v1_active = prot_word V1_ACTIVE;
   i1_active = prot_word I1_ACTIVE;

   printf("\n\n        P O W E R   S U P P L Y     ");      
   printf("          |      ");
   printf(" D I S T R I B U T O R S \n");
   printf("                                              |\n");
   if (v1_active){
      printf("          V1 ACTIVE : normal status           |\n"); 
   }   
   else {
      printf("          V0 ACTIVE : ***  injection ***      |\n"); 
   }
   if (i1_active){
      printf("          I1 ACTIVE                           |\n"); 
      printf("                                              |\n");
   }   
   else {
      printf("          I0 ACTIVE        ********           |\n"); 
      printf("                                              |\n");
   }
   if (v1_active && i1_active)
      printf("Ctrl  CH     Sw.  V1   Vmon   I1  Imon   Stat |");
   else if (v1_active && !i1_active)
      printf("Ctrl  CH     Sw.  V1   Vmon   I0  Imon   Stat |");
   else if (!v1_active && i1_active)
      printf("Ctrl  CH     Sw.  V0   Vmon   I1  Imon   Stat |");
   else if (!v1_active && !i1_active)
      printf("Ctrl  CH     Sw.  V0   Vmon   I0  Imon   Stat |");
   printf(" sl  Sw.  Vmon  <imon> Imax  Gd/Bd \n");    
   printf("                  (V)  (V)   (uA)  (uA)       |");
   printf("           (V)   (nA)  (nA)   Ch's \n");    
   printf("                                              |\n");
   for(dis = 0; dis < mid->n_crates; dis++)
    for(sl = 0; sl < 4; sl++)
       /* successivamente si potrebbe chiedere soltanto una camera */
       if(strcmp(chamber_code, mid->distr[dis].slot[sl].chamber) == 0
       || strcmp(chamber_code, mid->distr[dis].slot[sl].cable_name)
       == 0 || ( strcmp("0", chamber_code) == 0  &&
       mid->distr[dis].slot[sl].hv_ch_Ref >= 0 ) ) {
          if (mid->distr[dis].slot[sl].d_used_ch){
             if(strcmp(old_chamber, mid->distr[dis].slot[sl].chamber) ){
               for ( i = 0; i < 4; i++ ){
                 /* questi due controlli sono stati messi 
                    perche' in caso di una sola slot la seconda 
                    riga invece di essere di lunghezza nulla era lunga 3 
                    e conteneva " | ". Un simile controllo e' stato
                    fatto su hv_line perche' "non si sa mai" 
                                                  24/4/94      */
                 if( strlen(hv_line[i]) < 10 )
                             *hv_line[i] = '\0';  
                 if( strlen(dis_line[i]) < 10 )
                    *dis_line[i] = '\0';  
                 if (strlen(hv_line[i]) )
                    printf("%s", hv_line[i]);
                 else if ( strlen(dis_line[i]))
                    printf("                                             ");
                 if (strlen(dis_line[i]) )
                    printf("%s", dis_line[i]);
                 else if (strlen(hv_line[i]) )
                    printf(" |\n");
               }
                strcpy(old_chamber, mid->distr[dis].slot[sl].chamber);
                hv_line_nr = -1;
                dis_line_nr = -1;
                for ( i =  0; i < 10; i++){
                  *hv_line[i] = '\0';
                  *dis_line[i] = '\0';
                }
             }
           /* attenzione al disallineamento */
             if (dis_line_nr == -1) {
               hv_line_nr++;
               if ( !mid->distr[dis].slot[sl].cond )
                 sprintf(hv_line[hv_line_nr], "     ");
               else if ( mid->distr[dis].slot[sl].cond IS_SITTERING )
                 sprintf(hv_line[hv_line_nr],"Sitt "); 
               else if ( mid->distr[dis].slot[sl].cond IS_CONDITIONING )
                 sprintf(hv_line[hv_line_nr],"Cond ");  /* per il momento */
               else
                 sprintf(hv_line[hv_line_nr],"  ?  ");  /* per il momento */
               inline = strlen("     "); 
               if ( hv_line_nr == 0 ){
                 sprintf(hv_line[hv_line_nr] + inline," %s A  ", 
                         mid->distr[dis].slot[sl].chamber);
                 inline += 7;
               }

               for ( il = 0; il < 2; il++ ){
                 if ( il == 1){ 
                    hv_line_nr++;
                    sprintf(hv_line[hv_line_nr],"         Ref"); 
                    inline = 12;
                 }
                 if ( il == 0 ) 
                   hv_ch = mid->distr[dis].slot[sl].hv_ch_A;
                 else
                   hv_ch = mid->distr[dis].slot[sl].hv_ch_Ref;

                 sem_wait(sem_127mod_id, argv[0]);
                 status_hv_ch = sy127_mod->hv_par[1].status[hv_ch];
                 v0_hv_ch = sy127_mod->hv_par[1].v0[hv_ch];
                 v1_hv_ch = sy127_mod->hv_par[1].v1[hv_ch];
                 vmon_hv_ch = sy127_mod->hv_par[1].vmon[hv_ch];
                 i0_hv_ch = sy127_mod->hv_par[1].i0[hv_ch];
                 i1_hv_ch = sy127_mod->hv_par[1].i1[hv_ch];
                 imon_hv_ch = sy127_mod->hv_par[1].imon[hv_ch];
                 sem_free(sem_127mod_id, argv[0]);  

                 if (status_hv_ch IS_ON )
                   sprintf(hv_line[hv_line_nr] + inline, " ON  ");
                 else if (status_hv_ch IS_OFF )
                   sprintf(hv_line[hv_line_nr] + inline, " OFF ");
                 else 
                   sprintf(hv_line[hv_line_nr] + inline, "  ?? ");
                 inline += 5;
                 if (v1_active)
                   sprintf(hv_line[hv_line_nr] + inline, "%4d ", v1_hv_ch);
                 else
                   sprintf(hv_line[hv_line_nr] + inline, "%4d ", v0_hv_ch);
                 inline += 5;
                 sprintf(hv_line[hv_line_nr] + inline, "%4d   ", vmon_hv_ch);
                 inline += 7;
                 if (i1_active)
                   sprintf(hv_line[hv_line_nr] + inline, "%4d ", i1_hv_ch);
                 else
                   sprintf(hv_line[hv_line_nr] + inline, "%4d ", i0_hv_ch);
                 inline += 5;
                 sprintf(hv_line[hv_line_nr] + inline, "%4d ", imon_hv_ch);
                 inline += 5;
                 if ((status_hv_ch & 0xfa ) == 0 )
                   sprintf(hv_line[hv_line_nr] + inline, "  OK  ");
                 else
                   sprintf(hv_line[hv_line_nr] + inline, "  !!  ");

   /* more lines , in case of bad 'NOT ok' */
                 if(strcmp(mid->distr[dis].slot[sl].chamber, "01")){
                   if ( status_hv_ch IS_OVERC ){
                     hv_line_nr++;
                     sprintf(hv_line[hv_line_nr],
                     "                                        OVC  ");
                   }
                   if ( status_hv_ch IS_OVERV ){
                     hv_line_nr++;
                     sprintf(hv_line[hv_line_nr],
                     "                                        OVV  ");
                   }
                   if ( status_hv_ch IS_UNDERV ){
                     hv_line_nr++;
                     sprintf(hv_line[hv_line_nr],
                     "                                        UDV  ");
                   }
                   if ( status_hv_ch IS_TRIP ){
                     hv_line_nr++;
                     sprintf(hv_line[hv_line_nr],
                     "                                        TRIP ");
                   }
                   if ( status_hv_ch IS_RAMPU ){
                     hv_line_nr++;
                     sprintf(hv_line[hv_line_nr],
                     "                                        R-UP ");
                   }
                   if ( status_hv_ch IS_RAMPD ){
                     hv_line_nr++;
                     sprintf(hv_line[hv_line_nr],
                     "                                        R-DWN");
                   }
                 }
                 else {
                   if ( status_hv_ch IS_OVERC ){
                     hv_line_nr++;
                     sprintf(hv_line[hv_line_nr],
                     "                                        OVC");
                   }
                   if ( status_hv_ch IS_OVERV ){
                     hv_line_nr++;
                     sprintf(hv_line[hv_line_nr],
                     "                                        OVV");
                   }
                   if ( status_hv_ch IS_UNDERV ){
                     hv_line_nr++;
                     sprintf(hv_line[hv_line_nr],
                     "                                        UDV");
                   }
                   if ( status_hv_ch IS_TRIP ){
                     hv_line_nr++;
                     sprintf(hv_line[hv_line_nr],
                     "                                        TRIP");
                   }
                   if ( status_hv_ch IS_RAMPU ){
                     hv_line_nr++;
                     sprintf(hv_line[hv_line_nr],
                     "                                        R-UP");
                   }
                   if ( status_hv_ch IS_RAMPD ){
                     hv_line_nr++;
                     sprintf(hv_line[hv_line_nr],
                     "                                        R-DWN");
                   }
                 }
               }
             }
             /* distributors */
             dis_line_nr++;
             if(strcmp(mid->distr[dis].slot[sl].chamber, "01")){
                sprintf(dis_line[dis_line_nr],
                        " | %s", mid->distr[dis].slot[sl].cable_name + 3);
                inline = 4;
                sem_wait(sem_227mod_id, argv[0]);
                on_off = sy227_mod->sl_par[dis][sl].onoff;
                hv_in = sy227_mod->sl_par[dis][sl].hvin;
                for ( i = 0; i < 32; i++){
                    d_vmon[i] = sy227_mod->sl_par[dis][sl].vmon[i];
                    d_imon[i] = sy227_mod->sl_par[dis][sl].imon[i];
                    d_status[i] = sy227_mod->sl_par[dis][sl].status[i];
                }
                sem_free(sem_227mod_id, argv[0]);

                if (mid->distr[dis].slot[sl].bad) 
                  sprintf(dis_line[dis_line_nr] + inline,  " *BAD* ");
                else if (on_off D_SWITCH_IS_ON && on_off D_RELAY_IS_ON)
                  sprintf(dis_line[dis_line_nr] + inline,  "  ON   ");
                else if ( !(on_off D_SWITCH_IS_ON)) 
                   sprintf(dis_line[dis_line_nr] + inline, " S-OFF ");
                else if ( !(on_off D_RELAY_IS_ON)) 
                   sprintf(dis_line[dis_line_nr] + inline, " R-OFF ");
                else 
                   sprintf(dis_line[dis_line_nr] + inline, "  ???  ");
                inline += 7;

                n_bad = 0;
                n_good = 0;
                imax = -1;
                imean = 0.;
                vmean = 0.;
                for (i = 0; i < 32; i++){
                    if (mid->distr[dis].slot[sl].d_used_ch & ( 1 << i ) ) {
                       if ( ! (d_status[i] D_IS_OK ) )
                          n_bad++; 
                       else {
                          imean += (float) d_imon[i];
                          vmean += (float) d_vmon[i];
                          n_good++; 
                       }
                       if ( d_imon[i] > imax )
                          imax = d_imon[i];
                    }
                }
                if ( n_good > 0 ){
                   imean = imean / (float)(n_good);
                   vmean = vmean / (float)(n_good);
                }
                else {
                   imean = -1.;
                   vmean = -1.;
                }

                sprintf(dis_line[dis_line_nr] + inline, "%4.0f ", vmean);
                inline += 5;
                sprintf(dis_line[dis_line_nr] + inline, "  %4.0f ", imean);
                inline += 7;
                sprintf(dis_line[dis_line_nr] + inline, "%4d ", imax);
                inline += 5;
                sprintf(dis_line[dis_line_nr] + inline, 
                       "  %2d/%2d\n", n_good, n_bad);                
             }
             else {
                sprintf(dis_line[dis_line_nr], "\n");
             }
          }
       }
       for ( i = 0; i < 10; i++ ){
         if (strlen(hv_line[i]) )
            printf("%s", hv_line[i]);
         else if ( strlen(dis_line[i]))
            printf("                                             ");
         if (strlen(dis_line[i]) )
            printf("%s", dis_line[i]);
         else if (strlen(hv_line[i]) )
            printf(" |\n");
       }

   sem_unl_del(sem_127mod_id, "SY127mod", caller);
   sem_unl_del(sem_227mod_id, "SY127mod", caller);
   munlink(sy127_mod);
   munlink(sy227_mod);
   munlink(mid);
   exit(0);
}