// cg1100.cpp
// Stampa piano dei conti

#include <mask.h>
#include <printapp.h>
// #include <scanner.h>
#include <relation.h>
#include <tabutil.h>
#include <utility.h>
#include <sort.h>
#include <mailbox.h>
#include <execp.h>

#include <lffiles.h>
#include <pconti.h>
#include "cg1.h"
#include "cg1100.h"

const char * TAB_ANABIL = "%IVD";
const char * TAB_IVD = "%IVD";

const int CODTABLEN = 15;

enum stampe {
  completa=1,
  con_IV_direttiva=2,
  senza_IV_direttiva=3,
  con_ana_bil=4,
  senza_ana_bil=5
  };

class CG1100_application : public TPrintapp
{
  TTable        _tab;           // tabella codici IV direttiva
  TTable        _tab_anabil ;   // tabella codici analisi di bilancio
  TRectype*     _rec;
  TSort*        _sort;
  TRelation*    _rel;
  TMask*        _msk;
  stampe        _tipo_stampa;
  bool          _salto_pag;
  int           _pcont_reclen;
  int           _cur_c1, _cur_c2, _cur_c3, _cur_c4;

public:

  virtual void user_destroy() ;
  virtual void user_create() ;                        

  virtual void set_page (int,int);
  virtual bool preprocess_print (int,int);
  virtual bool preprocess_page (int,int);
  virtual print_action postprocess_page (int,int);

  virtual bool set_print(int);

  void intesta (stampe);

  bool elabora_riga();  // decide se fare salto pagina o no
  void scegli_cur();
  void set_completa ();
  void set_con_IV ();
  void set_senza_IV ();
  void set_con_ana ();
  void set_senza_ana ();

  const char * decodifica_codanabil (const char * );
  //  const char * decodifica_IV_sez (const char * );
  const char * decodifica_IV_dir (const char * sezivd,
                                  const char * lettivd = "",
                                  const char * numrivd = "",
                                  int numivd = 0);
  void process_link(int id, const char* txt);

  CG1100_application() : _tab (TAB_IVD), _tab_anabil (TAB_ANABIL) {}
};

void CG1100_application::process_link(int id, const char* txt)
{
  TString ss = "1|"; ss << txt;
  TMessage fs(cmd2name("cg0","0"), MSG_LN, ss);
  TMailbox m;
  m.send(fs);              
  TExternal_app cg0("cg -0");
  if (cg0.run()) beep();
}

print_action CG1100_application::postprocess_page(int file,int counter)
{
  switch (_tipo_stampa)
  {
  case completa:
  case senza_IV_direttiva:
  case senza_ana_bil:
    break;
  case con_IV_direttiva:
  case con_ana_bil:
  {
    const char * buf;
    if ( (buf = _sort->retrieve()) != NULL)
    {
      (*_rec) = buf;
      return REPEAT_PAGE; 
    }
    break;
  }
  default:
    break;

  }
  return NEXT_PAGE;
}

void CG1100_application::set_page(int file,int counter)
{
  switch (_tipo_stampa) 
  {
  case completa:
    set_completa();
    break;
  case con_IV_direttiva:
  case con_ana_bil:
    break;
  case senza_IV_direttiva:
    set_senza_IV();
    break;
  case senza_ana_bil:
    set_senza_ana ();
    break;
  default:
    break;
  }
}

//////////////////////////////////////////////////////////////
// Crea sort se necessario e seleziona il cursore opportuno
//////////////////////////////////////////////////////////////
void CG1100_application::scegli_cur()
{
  TString c1;

  switch (_tipo_stampa) 
  {
  case completa:
    select_cursor (_cur_c1);
    break;
  case con_IV_direttiva:
  {
    TRecfield sezivd  (*_rec, PCN_SEZIVD);
    TRecfield lettivd (*_rec, PCN_LETTIVD);
    TRecfield numrivd (*_rec, PCN_NUMRIVD);
    TRecfield numivd  (*_rec, PCN_NUMIVD);
    
    _sort->addsortkey (sezivd);
    _sort->addsortkey (lettivd);
    _sort->addsortkey (numrivd);
    _sort->addsortkey (numivd);
    
    _sort->init();

    select_cursor (_cur_c1);

    TCursor * cursor = current_cursor();

    long last =  cursor->items();

    for ( *cursor = 0; cursor->pos() < last; ++(*cursor) )
    {
      c1 = cursor->curr(LF_PCON).get(PCN_SEZIVD);
      if ( c1.trim().not_empty() )
        _sort->sort (cursor->curr(LF_PCON).string());
    }
    
    _sort->endsort();
    
    select_cursor (_cur_c2);

    break;
  }

  case senza_IV_direttiva:
    select_cursor (_cur_c3);
    break;

  case con_ana_bil:
  {
    TRecfield codcbl  (*_rec, PCN_CODCBL);

    _sort->addsortkey (codcbl);
    _sort->init();

    select_cursor (_cur_c1);
    TCursor * cursor = current_cursor();

    long last =  cursor->items();

    for ( *cursor = 0; cursor->pos() < last; ++(*cursor) )
    {
      c1 = cursor->curr(LF_PCON).get(PCN_CODCBL);
      if ( c1.trim().not_empty() )
        _sort->sort (cursor->curr(LF_PCON).string());
    }
    
    _sort->endsort();
    select_cursor (_cur_c2);
    break;
  }
  case senza_ana_bil:
    select_cursor (_cur_c4);
    break;
  default:
    break;
  }
}

bool CG1100_application::preprocess_print (int file,int counter)
{
  const char * buf;

  reset_print();
  set_auto_ff (FALSE);

  switch (_tipo_stampa)
  {
  case con_IV_direttiva:
  case con_ana_bil:
    if ((buf = _sort->retrieve()) != NULL)
    {
      (*_rec) = buf;
      return TRUE;
    }
    else
      return FALSE;
  default:
    break;
  }
  return TRUE;
}

void CG1100_application::set_con_IV()
{
  // campi della classe
  TString c1, c2, c3;
  int c4;
  TString descr_IV_sez, descr_IV_dir;

  // campi della classe di segno opposto
  TString o1, o2,o3;
  int     o4;

  // Descrizioni
  TString d1;

  // gruppo, conto e sottoconto
  int g,c,s;

  c1 = _rec->get(PCN_SEZIVD);
  c2 = _rec->get(PCN_LETTIVD);
  c3 = _rec->get(PCN_NUMRIVD);
  c4 = _rec->get_int(PCN_NUMIVD);

  descr_IV_sez = decodifica_IV_dir (c1);
  descr_IV_dir = decodifica_IV_dir (c1, c2, c3, c4);

  o1 = _rec->get (PCN_SEZIVDOPP);
  o2 = _rec->get (PCN_LETTIVDOPP);
  o3 = _rec->get (PCN_NUMRIVDOPP);
  o4 = _rec->get_int  (PCN_NUMIVDOPP);

  g = _rec->get_int (PCN_GRUPPO);
  c = _rec->get_int (PCN_CONTO);
  s = _rec->get_int (PCN_SOTTOCONTO);

  d1 = _rec->get (PCN_DESCR);

  reset_row (1);
  reset_row (2);

  set_row (1, "@1g%50s", (const char *) descr_IV_sez);

  set_row (2, "@1g%3s", (const char *) c2);
  set_row (2, "@5g%8s", (const char *) c3);
  set_row (2, "@14g%2d", c4);

  set_row (2, "@18g%40s", (const char *) descr_IV_dir);

  set_row (2, "@60g$[r]%03d$[n].", (const char *) g);
  set_row (2, "@64g$[r]%03d$[n].", (const char *) c);
  set_row (2, "@68g$[r]%06d$[n]", (const char *) s);

  set_row (2, "@78g%2d", (const char *) c4);

}

void CG1100_application::set_senza_IV()
{
  int lnum = LF_PCON;

  reset_row (1);

  set_row (1, "@1g$[r]@pn$[n]", FLD(lnum,PCN_GRUPPO, "@@@.") );
  set_row (1, "@5g$[r]@pn$[n]", FLD(lnum,PCN_CONTO, "@@@.") );
  set_row (1, "@9g$[r]@pn$[n]", FLD(lnum, PCN_SOTTOCONTO, "@@@@@@") );
  
  set_row (1, "@16g@50s", FLD(lnum,PCN_DESCR) );

  set_row (1, "@69g@1s", FLD(lnum, PCN_SEZIVD) );
  set_row (1, "@71g@1s", FLD(lnum, PCN_LETTIVD) );
  set_row (1, "@73g@8s", FLD(lnum, PCN_NUMRIVD) );
  set_row (1, "@82g@pn", FLD(lnum, PCN_NUMIVD, "@@") );

  set_row (1, "@87g@pn", FLD(lnum, PCN_INDBIL, "##") );
  set_row (1, "@92g@1s", FLD(lnum, PCN_TMCF) );
  set_row (1, "@99g@f", FLD(lnum, PCN_STSOTTBIL) );
  set_row (1, "@107g@f", FLD(lnum, PCN_COMPENS) );
  set_row (1, "@114g@1n", FLD(lnum, PCN_TIPOSPRIC) );
  set_row (1, "@120g@1s", FLD(lnum, PCN_SEZSALDI) );
  //      set_row (1, "@118g@f", FLD(lnum, PCN_STSOTTAB));
}

void CG1100_application::set_con_ana()
{
  TString CodTabAnabil, DescrCodTabAnabil(30);
  // Descrizioni
  TString d1;
  const char * d;

  // gruppo, conto e sottoconto
  int g,c;
  long s;
  char tmcf;
  int TipoSpric, IndBil;

  reset_row (1);

  g = _rec->get_int (PCN_GRUPPO);
  c = _rec->get_int (PCN_CONTO);
  s = _rec->get_long (PCN_SOTTOCONTO);
  tmcf      = _rec->get(PCN_TMCF)[0];
  TipoSpric = _rec->get_int(PCN_TIPOSPRIC);
  IndBil    = _rec->get_int(PCN_INDBIL);

  d1 = _rec->get (PCN_DESCR);
  TParagraph_string desc_conto(d1,25);

  CodTabAnabil = _rec->get(PCN_CODCBL);
  set_row (1, "%-10s", (const char *)CodTabAnabil);

  set_row (1, "@15g%-10s", (const char *)DescrCodTabAnabil);

  set_row (1, "@61g$[r]%03d$[n].",  g );
  set_row (1, "$[r]%03d$[n].",      c );
  set_row (1, "$[r]%06ld$[n]",      s );

  int r=1;
  while ((d = desc_conto.get()) != NULL)
  {
    if (r>1) reset_row(r);
    set_row (r, "@78g%25s", d);
    r++;
  }
}

void CG1100_application::set_senza_ana()
{
  int lnum = LF_PCON;

  reset_row (1);

  set_row (1, "@1g$[r]@pn$[n]", FLD(lnum,PCN_GRUPPO, "@@@.") );
  set_row (1, "@5$[r]g@pn$[n]", FLD(lnum,PCN_CONTO, "@@@.") );
  set_row (1, "@9$[r]g@pn$[n]", FLD(lnum, PCN_SOTTOCONTO, "@@@@@@") );
  
  set_row (1, "@16g@50s", FLD(lnum,PCN_DESCR) );

  set_row (1, "@69g@1s", FLD(lnum, PCN_SEZIVD) );
  set_row (1, "@71g@1s", FLD(lnum, PCN_LETTIVD) );
  set_row (1, "@73g@8s", FLD(lnum, PCN_NUMRIVD) );
  set_row (1, "@82g@pn", FLD(lnum, PCN_NUMIVD, "@@") );

  set_row (1, "@87g@pn", FLD(lnum, PCN_INDBIL, "##") );
  set_row (1, "@92g@1s", FLD(lnum, PCN_TMCF) );
  set_row (1, "@99g@f", FLD(lnum, PCN_STSOTTBIL) );
  set_row (1, "@107g@f", FLD(lnum, PCN_COMPENS) );
  set_row (1, "@114g@1n", FLD(lnum, PCN_TIPOSPRIC) );
  set_row (1, "@120g@1s", FLD(lnum, PCN_SEZSALDI) );
}


void CG1100_application::set_completa()
{
  int lnum = LF_PCON;

  reset_row (1);

  set_row (1, "@1g$[r]@pn$[n]", FLD(lnum,PCN_GRUPPO, "@@@.") );
  set_row (1, "@5g$[r]@pn$[n]", FLD(lnum,PCN_CONTO, "@@@.") );
  set_row (1, "@9g$[r]@pn", FLD(lnum, PCN_SOTTOCONTO, "@@@@@@") );
  
  set_row (1, "@16g@50s", FLD(lnum,PCN_DESCR) );

  set_row (1, "@69g@1s", FLD(lnum, PCN_SEZIVD) );
  set_row (1, "@71g@1s", FLD(lnum, PCN_LETTIVD) );
  set_row (1, "@73g@8s", FLD(lnum, PCN_NUMRIVD) );
  set_row (1, "@82g@pn", FLD(lnum, PCN_NUMIVD, "@@") );

  set_row (1, "@87g@pn", FLD(lnum, PCN_INDBIL, "##") );
  set_row (1, "@92g@1s", FLD(lnum, PCN_TMCF) );
  set_row (1, "@99g@f", FLD(lnum, PCN_STSOTTBIL) );
  set_row (1, "@107g@f", FLD(lnum, PCN_COMPENS) );
  set_row (1, "@114g@1n", FLD(lnum, PCN_TIPOSPRIC) );
  set_row (1, "@120g@1s", FLD(lnum, PCN_SEZSALDI) );
}

bool CG1100_application::elabora_riga()
{
  static int old_gruppo = 0;
  int new_gruppo = 0, new_conto = 0;
  long new_sottoc = 0l;
  TRectype& curr_rec = *_rec;

  switch (_tipo_stampa)
  {
  case completa:
  case senza_ana_bil:
  case senza_IV_direttiva:
    curr_rec = current_cursor()->curr(LF_PCON); break;
  case con_ana_bil:
  case con_IV_direttiva:
    curr_rec = *_rec; break;
  default:
    break;
  }

  new_gruppo = curr_rec.get_int(PCN_GRUPPO);
  new_conto  = curr_rec.get_int(PCN_CONTO);
  new_sottoc = curr_rec.get_long(PCN_SOTTOCONTO);
  if (new_gruppo != 0 && new_conto != 0)
  {
    // se e' un sottoconto stampo sotttab in 127
    if (new_sottoc != 0)
    {
      set_row (1, "@127g@f", FLD(LF_PCON, PCN_STSOTTAB));
      set_row (1, "@124g  ");
    }
    else
      // se e' un conto stampo sotttab in 124
    {
      set_row (1, "@124g@f", FLD(LF_PCON, PCN_STSOTTAB));
      set_row (1, "@127g  ");
    }
  }
  // Gestione salto pagina

  if (_salto_pag && new_gruppo != old_gruppo)
  {
    const bool salta = old_gruppo > 0;
    old_gruppo = new_gruppo;
    return salta;
  }
  return FALSE;
}

bool CG1100_application::preprocess_page(int file,int counter)
{
  if (elabora_riga())
    printer().formfeed();

  if (_tipo_stampa == con_IV_direttiva) set_con_IV();
  if (_tipo_stampa == con_ana_bil) set_con_ana();
  return TRUE;
}

bool CG1100_application::set_print(int)
{
  KEY   tasto;

  tasto = _msk->run();

  if (tasto == K_ENTER)
  {
    _tipo_stampa = (stampe)atoi(_msk->get (F_SCELTA_STAMPA));
    _salto_pag = (bool) (_msk->get (F_SALTO_PAGINA) == "X");

    intesta (_tipo_stampa);
    scegli_cur();
    enable_link("Collegamento Piano dei conti : ", 'r');
    return TRUE;
  }
  return FALSE;
}

void CG1100_application::intesta (stampe tipo)
{
  int soh = 1;       // riga d'inizio dell'intestazione
  TString sep(132);

  reset_header ();

  sep << "Ditta : " << get_firm();
  sep.left_just(132);

  set_header (soh++, (const char*) sep);

  sep = "Studio : ";
  sep << "Data : @<  Pag. @#";
  sep.right_just(132 - (10 + 4));
  sep.overwrite ("PIANO DEI CONTI");

  set_header (soh++, (const char*)sep);

  sep.fill('_');
  set_header (soh++, (const char *) sep);

  switch (tipo)
  {
  case completa:
    set_header (soh++, "Conto @67gSez. Classe@85gTipo@96gDettaglio@112gSpesa        @123gDet.bil.");
    set_header (soh++, "Sottoconto @16gDescrizione@68gIV  dir. @85gConto   @91gC/F   @96gBilancio   @106gComp.    @112gRicavo @119gSez @123gSot.con.");
    break;

  case con_IV_direttiva:

    set_header (soh++, "@60gCodici Piano@111gSez. e Classe");
    set_header (soh++, "Classe@18gDescrizione@60gdei Conti @78gDescrizione@110g di segno opposto");

    break;

  case senza_IV_direttiva:
    set_header (soh++, "Conto@85gTipo@96gDettaglio@112gSpesa        @123gDet.bil.");
    set_header (soh++, "Sottoconto @16gDescrizione@85gConto   @91gC/F   @96gBilancio   @106gComp.    @112gRicavo @119gSez @123gSot.con.");
    break;

  case con_ana_bil:

    set_header (soh++, "Codice @61gCodici Piano@113gDett.alleg.Bilancio");
    set_header (soh++, "Tabella@16gDescrizione@60gdei Conti @78gDescrizione @113gSot.con. * Moviment.");

    break;

  case senza_ana_bil:
    set_header (soh++, "Conto @67gSez. Classe@85gTipo@96gDettaglio@112gSpesa        @123gDet.bil.");
    set_header (soh++, "Sottoconto @16gDescrizione@68gIV  dir. @85gConto   @91gC/F   @96gBilancio   @106gComp.    @112gRicavo @119gSez @123gSot.con.");
    break;

  default:
    break;
  }

  set_header (soh++,(const char*)sep);
  sep = "";
  set_header (soh, (const char *) sep);

}

const char * CG1100_application::decodifica_IV_dir (const char * sezivd, const char * lettivd, const char * numrivd, int numivd)
{
  TString dep (CODTABLEN);

  _tab.curr().zero();
  if (numrivd != 0)
    dep.format("%1s%1s%8s%02d", sezivd, lettivd, numrivd, numivd);
  else
    dep.format("%1s%1s%8s", sezivd, lettivd, numrivd);

  _tab.curr().put("CODTAB", (const char*)dep);
  _tab.read();
  if (_tab.bad()) _tab.curr().zero();
  return _tab.curr().get ("S0");
}

const char * CG1100_application::decodifica_codanabil (const char * codpcab)
{
  //  TString dep (CODTABLEN);
  // non sara' un tabella ma un file
  _tab_anabil.curr().zero();

  _tab_anabil.curr().put("CODTAB", (const char*) codpcab);
  _tab_anabil.read();
  if (_tab_anabil.bad()) _tab_anabil.curr().zero();
  return _tab_anabil.curr().get ("S0");
}

//const char * CG1100_application::decodifica_IV_sez (const char * sezivd)
//{
//  TString dep (CODTABLEN);
//  TString dep2(CODTABLEN);

//  _tab.zero();
//  dep << format ("%1s", sezivd);
//  _tab.put("CODTAB", dep);
//  _tab.read();
//  dep2 = _tab.get("CODTAB");
// if (dep != dep2)
//    _tab.zero();
//  return _tab.get ("S0");
//}

void CG1100_application::user_create()
{
  _rel = new TRelation (LF_PCON);
  _msk = new TMask ("cg1100a") ;

  TCursor *cursor = new TCursor (_rel);

  _cur_c1 = add_cursor (cursor);

  _rec = new TRectype (cursor->curr());

  _pcont_reclen = _rec->len();
  _sort = new TSort(_pcont_reclen);

  _cur_c2 = add_cursor (NULL);

  _cur_c3 = add_cursor (new TCursor (_rel,"SEZIVD=\"\"", 1));
  _cur_c4 = add_cursor (new TCursor (_rel,"CODCBL=\"\"", 1));

  add_file(LF_PCON);

  _tipo_stampa = completa;
  _salto_pag   = FALSE;

}

void CG1100_application::user_destroy()
{
  delete  _msk;
  delete _rel;
  delete _rec;
  delete _sort;
}

int cg1100(int argc, char* argv[])
{
  CG1100_application a;
  a.run(argc, argv, "Stampa Piano dei Conti");
  return 0;
}