#include <applicat.h>
#include <automask.h>
#include <browfile.h>
#include <filetext.h>
#include <prefix.h>
#include <progind.h>
#include <tabutil.h>
#include <utility.h>
#include <viswin.h>

#include "ibm36.h"

#include <comuni.h>
#include <cfven.h>
#include <clifo.h>

#define CENTO  100.0
#define CMILA  100000.0

///////////////////////////////////////////////////////////
// TMask36 Maschera principale di selezione
///////////////////////////////////////////////////////////

class TMask36 : public TAutomask
{
protected:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);

public:
  TMask36() : TAutomask("ibm36100") { }
  virtual ~TMask36() { }
};

bool TMask36::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  return TRUE;
}

///////////////////////////////////////////////////////////
// TBankitalia 
///////////////////////////////////////////////////////////

class TBankitalia : public TObject
{
  TAssoc_array _bank;

public:
  const TString* codban2abicab(const char* codban);
  void update();

  TBankitalia() { }
  virtual ~TBankitalia() { }
};

void TBankitalia::update()
{
  TTable ban("%BAN");
  const TRectype& curban = ban.curr();

  _bank.destroy();
  for (int err = ban.first(); err == NOERR; err = ban.next())
  {
    TString16 codban = curban.get("S9");
    if (codban.not_empty())
    {
      const TString& abicab = curban.get("CODTAB");
      _bank.add(codban, abicab);
    }
  }
}

const TString* TBankitalia::codban2abicab(const char* cod)
{
  if (_bank.items() == 0)
    update();
  const TString* abicab = (const TString*)_bank.objptr(cod);
  return abicab;
}

///////////////////////////////////////////////////////////
// TTrasfer36 Applicazione di importazione dati da 36
///////////////////////////////////////////////////////////

class TTrasfer36 : public TSkeleton_application  
{
  TBankitalia _bankitalia;

protected:
  virtual void main_loop();
  virtual const char* extra_modules() const { return "*"; }  // Non e' un modulo normale

public:
  const TString& cap2com(const TString& cap, const TString& name) const;
  void split_indir(const TString& indir, TString& via, TString& civ) const;
  void mettilavirgola(TFile_text& file, TRecord_text& curr, const char* field, int len, int comma);
  void permille(TFile_text& file, TRecord_text& curr, const char* field);
  void machedata(TFile_text& file, TRecord_text& curr, const char* field);
  void import_tables(const TFilename& name, TBrowsefile_field& bf);
  void import_clifo(const TFilename& name, TBrowsefile_field& bf);
  void import_anaart(const TFilename& name, TBrowsefile_field& bf);
};

const TString& TTrasfer36::cap2com(const TString& cap, const TString& name) const
{
  if (cap.not_empty())
  {
    TString16 str(cap); str.right_just(5, '0');
    if (str[2] == '1')
      str.overwrite("00", 3);

    TRelation rel(LF_COMUNI);
    TRectype filter(LF_COMUNI); filter.put(COM_CAPCOM, cap);
    TCursor comuni(&rel, "", 3, &filter, &filter);
    const TRecnotype total = comuni.items();
    if (total > 0)
    {
      comuni = 0;
      if (total > 1)
      {
        TRecnotype bestpos = 0L;
        int bestlen = 0;
        comuni.freeze(TRUE);
        for (; comuni.pos() < total; ++comuni)
        {
          const TString& dencom = comuni.curr().get(COM_DENCOM);
          for (int l = 0; toupper(dencom[l]) == toupper(name[l]); l++);
          if (l > bestlen)
          {
            bestlen = l;
            bestpos = comuni.pos();
          }
        }
        comuni = bestpos;
      }
      return comuni.curr().get(COM_COM);
    }
  }
  return EMPTY_STRING;
}

void TTrasfer36::split_indir(const TString& indir, TString& via, TString& civ) const
{
  const int comma = indir.rfind(',');
  if (comma > 0)
  {
    via = indir.left(comma);
    civ = indir.mid(comma+1);
  }
  else
  {
    bool has_digit = FALSE;
    for (int i = indir.len()-1; i > 0; i--)
    {
      if (has_digit)
      {
        if (indir[i] == ' ')
          break;
      }
      else
      {
        if (isdigit(indir[i]))
          has_digit = TRUE;
      }
    }
    if (i > 0 && has_digit)
    {
      via = indir.left(i);
      civ = indir.mid(i+1);
    }
  }

  if (via.empty())
  {
    via = indir;
    civ.cut(0);
  }

  via.cut(35);
  civ.cut(10);
}

void TTrasfer36::import_tables(const TFilename& name, TBrowsefile_field& bf)
{
  TString msg;
  msg = "Importazione tabelle vendite";

  TProgind pi(::fsize(name), msg, TRUE, TRUE);
  long valid = 0;

  msg.insert("@b", 0);
  msg << " dal file " << name;
  bf.add_line(msg);
  bf.add_line("");

  TFile_text file(name, "ibm36tab.ini");
  
  TTable ban("%BAN");
  
  TRecord_text curr;
  while (file.read(curr) == NOERR)
  {
    pi.setstatus(file.read_file()->tellg());
    if (pi.iscancelled())
      break;
    
    const TString& type = curr.type();
    if (type == "A26")
    {
      const TString& ann = file.get_field(curr, "ANNULLATO");
      if (ann != "A")
      {
        msg = "Importazione tabelle vendite - Record validi: ";
        msg << ++valid;
        pi.set_text(msg);

        TString16 cod = file.get_field(curr, "CODICE");
        TString16 abi = file.get_field(curr, "ABI");
        TString16 cab = file.get_field(curr, "CAB");
        if (abi.empty() || cab.empty())
        {
          if (abi.empty()) 
            abi = "99999";
          if (cab.empty()) 
          { 
            const TString* abicab = _bankitalia.codban2abicab(cod);
            if (abicab != NULL)
            {
              abi = abicab->left(5);
              cab = abicab->mid(5);
            }
            else
            {
              ban.last();
              const TString16 abicab = ban.get("CODTAB");
              if (abicab.left(5) == "99999")
              {
                long numcab = atol(abicab.mid(5)) + 1;
                cab.format("%05ld", numcab);
              }
              else
                cab = "00001";
            }
          }
        }
        abi.right_just(5, '0');
        cab.right_just(5, '0');

        TString16 codtab = abi;
        ban.put("CODTAB", codtab);
        if (ban.read() != NOERR)
        {
          msg = "- Creazione dell'istituto fittizio ";
          msg << abi;
          bf.add_line(msg);

          ban.put("CODTAB", codtab);
          ban.put("S0", "Banca per trasferimenti IBM36");
          ban.write();
        }

        codtab << cab;
        ban.put("CODTAB", codtab);
        if (ban.read() == NOERR)
        {
          ban.put("S9", cod);
          ban.rewrite();
        }
        else
        {
          msg = "! La banca ";
          msg << cod << " non dispone di un codice ABI/CAB valido";
          bf.add_line(msg);
          msg = "- Verra' creata la banca fittizia ";
          msg << abi << ' ' << cab;
          bf.add_line(msg);

          ban.put("CODTAB", codtab);
          ban.put("S0", file.get_field(curr, "RAGSOC"));
          ban.put("S9", cod);

          const TString& cap = file.get_field(curr, "CAP");
          ban.put("S3", cap);

          const TString& loc = file.get_field(curr, "LOCALITA");
          ban.put("S1", loc);

          const TString& com = cap2com(cap, loc);
          ban.put("S5", com);

          const TString& ind = file.get_field(curr, "INDIRIZZO");
          TString via, civ;
          split_indir(ind, via, civ);
          ban.put("S2", via);
          ban.put("S7", civ);    

          ban.write();
        }
      }
    }
  }

  _bankitalia.update();

  msg = "Record importati: ";
  msg << valid;
  bf.add_line(msg);
  bf.add_line("");
}

void TTrasfer36::mettilavirgola(TFile_text& file, TRecord_text& curr, const char* field, int len, int comma)
{
  TString80 num = file.get_field(curr, field);
  if (!real::is_null(num))
  {
    num.right_just(len, '0');
    num.insert(".", len - comma);
    file.add_field(curr, field, num);
  }
}

void TTrasfer36::permille(TFile_text& file, TRecord_text& curr, const char* field)
{
  TString80 num = file.get_field(curr, field);
  if (!real::is_null(num))
  {
    num << "000";
    file.add_field(curr, field, num);
  }
}

void TTrasfer36::machedata(TFile_text& file, TRecord_text& curr, const char* field)
{
  TString80 num = file.get_field(curr, field);
  if (!real::is_null(num))
  {
    switch (num.len())
    {
    case 6:
      {
        num.insert("19", 0);
        const TDate data(atol(num));
        file.add_field(curr, field, data.string());
      }
      break;
    case 7:    
      {
        const int secolo = num[0] - '0';
        long ansidata = atol(num.mid(1));
        ansidata += (19 + secolo) * 1000000L;
        const TDate data(ansidata);
        file.add_field(curr, field, data.string());
      }
      break;
    case 8:
      num.insert("-", 4);
      num.insert("-", 2);
      file.add_field(curr, field, num);
      break;
    default:
      break;
    }
  }
}

void TTrasfer36::import_clifo(const TFilename& name, TBrowsefile_field& bf)
{
  TAssoc_array missing_firm;
  TString msg;
  long valid = 0;
  
  msg = "Importazione Clienti/Fornitori";
  TProgind pi(::fsize(name), msg, TRUE, TRUE);
  TFile_text file(name, "ibm36cf.ini");

  msg.insert("@b", 0);
  bf.add_line(msg);
  bf.add_line("");

  TRelation rel(LF_CLIFO); rel.add(LF_CFVEN, "TIPOCF=TIPOCF|CODCF=CODCF");
  
  TRecord_text curr;
  while (file.read(curr) == NOERR)
  {
    pi.setstatus(file.read_file()->tellg());
    if (pi.iscancelled())
      break;

    const int tipo_record = curr.type()[0] - '0';
    if (tipo_record >= 1 && tipo_record <= 6)
    {
      const char stato_record = file.get_field(curr, "ANNULLATO")[0];
      if (stato_record == 'A')
        continue;

      const long ditta = atol(file.get_field(curr, "DITTA"));
      if (prefix().get_codditta() != ditta)
      {
        if (prefix().exist(ditta))
          prefix().set_codditta(ditta);
        else
        {
          msg.format("%ld", ditta);
          if (missing_firm.objptr(msg) == NULL)
          {
            missing_firm.add(msg, msg);
            msg.insert("Non esiste la ditta ", 0);
            msg << ": Effettuare il trasferimento della contabilita'";
            bf.add_line(msg);
          }
          continue;
        }
      }

      const char* tipocf = (tipo_record & 0x1) ? "C" : "F";
      const long codcf  = atol(file.get_field(curr, "CODCF"));
      TString16 extcf; 
      extcf << (*tipocf == 'C' ? "cliente" : "fornitore") << ' ' << codcf;

      TLocalisamfile& clifo = rel.lfile();
      clifo.put(CLI_TIPOCF, tipocf);
      clifo.put(CLI_CODCF, codcf);
      int err = clifo.read();
      if (err == NOERR)
      {
        file.add_field(curr, "TIPOCF", tipocf);
      }

      switch(tipo_record)
      {
      case  1:
      case  2:
        if (err != NOERR)
        {
          msg = "! Non esiste il ";
          msg << extcf;
          bf.add_line(msg);
          msg = "- Inserimento di ";
          msg << file.get_field(curr, "COGNOME") << file.get_field(curr, "NOME");
          bf.add_line(msg);

          rel.write_enable(LF_CFVEN, FALSE);
          const int err = file.autosave(rel, curr);
          if (err != NOERR)
          {
            msg = "! Errore di scrittura sul file LF_CLIFO: ";
            msg << err;
            bf.add_line(msg);
          }
        }
        break;
      case  3:
        if (err == NOERR)
        {
          TString cod = file.get_field(curr, "CODICE BANCA D'APPOGGIO");
          if (!cod.blank())
          {
            const TString* abicab = _bankitalia.codban2abicab(cod);
            if (abicab)
            {
              rel.curr().put(CLI_CODABI, abicab->left(5));
              rel.curr().put(CLI_CODCAB, abicab->mid(5));
            }
            else
            {
              msg = "Ipossibile determinare l'ABI/CAB della banca d'appoggio ";
              msg << cod << " del " << extcf;
              bf.add_line(msg);
            }
          }
         
          cod = file.get_field(curr, "CODICE BANCA PRESENTAZIONE EFFETTI");
          if (!cod.blank())
          {
            const TString* abicab = _bankitalia.codban2abicab(cod);
            if (abicab)
            {
              rel.curr(LF_CFVEN).put(CFV_CODABIPR, abicab->left(5));
              rel.curr(LF_CFVEN).put(CFV_CODCABPR, abicab->mid(5));
            }
            else
            {
              msg = "Ipossibile determinare l'ABI/CAB della banca di presentazione ";
              msg << cod << " del " << extcf;
              bf.add_line(msg);
            }
          }

          mettilavirgola(file, curr, "PROVVIGIONE AGENTE", 5, 2);
          permille(file, curr, "IMPORTO MINIMO EFFETTI");
          machedata(file, curr, "DATA INIZIO RID");
          machedata(file, curr, "DATA REVOCA RID");

          rel.write_enable(LF_CFVEN);
          const int err = file.autosave(rel, curr);
          if (err != NOERR)
          {
            msg = "! Errore di scrittura sul file LF_CFVEN: ";
            msg << err;
            bf.add_line(msg);
          }
          else
            valid++;
        }
        break;
      case 5:
        if (err != NOERR)
        {
          machedata(file, curr, "DATA INVIO ULTIMO ESTRATTO CONTO");
          machedata(file, curr, "DATA INVIO ULTIMO SOLLECITO");
          permille(file, curr, "FIDO");

          rel.write_enable(LF_CFVEN);
          const int err = file.autosave(rel, curr);
          if (err != NOERR)
          {
            msg = "! Errore di scrittura sul file LF_CFVEN: ";
            msg << err;
            bf.add_line(msg);
          }
          else
            valid++;
        }
        break;
      default: break;// Ignored
      }
    }
  }

  msg = "Record importati: ";
  msg << valid;
  bf.add_line(msg);
  bf.add_line("");
}

void TTrasfer36::import_anaart(const TFilename& name, TBrowsefile_field& bf)
{
  TString msg, des, codart, um;
  real r;
  msg = "Importazione Anagrafica articoli";
  TProgind pi(::fsize(name), msg, TRUE, TRUE);
  TFile_text file(name, "ibm36art.ini");
  long valid = 0;

  msg.insert("@b", 0);
  bf.add_line(msg);
  bf.add_line("");
  TRelation rel(LF_ANAMAG); 
  rel.add(LF_UMART,"CODART=CODART");
  
  TRecord_text curr;
  while (file.read(curr) == NOERR)
  {
    pi.setstatus(file.read_file()->tellg());
    if (pi.iscancelled())
      break;

    const int tipo_record = curr.type()[0] - '0';
    if (tipo_record == 0)
    {
      const char stato_record = file.get_field(curr, "ANNULLATO")[0];
      if (stato_record == 'A')
        continue;

      des = file.get_field(curr, "DESCRIZIONE ARTICOLO");
      des << " ";
      des << file.get_field(curr, "ESTENSIONE DESCRIZIONE");
      des.strip_d_spaces();
      file.add_field(curr, "DESCRIZIONE ARTICOLO", des);
      
      r = real(file.get_field(curr, "COSTO STANDARD")) / CENTO;
      file.add_field(curr, "COSTO STANDARD", r.string());

      r = real(file.get_field(curr, "TARA")) / CENTO;
      file.add_field(curr, "TARA", r.string());
      
      r = real(file.get_field(curr, "PESO")) / CENTO;
      file.add_field(curr, "PESO", r.string());
      
      r = real(file.get_field(curr, "PERCENTUALE PROVVIGIONE")) / CENTO;
      file.add_field(curr, "PERCENTUALE PROVVIGIONE", r.string());

      r = real(file.get_field(curr, "PERCENTUALE SCONTO")) / CENTO;
      file.add_field(curr, "PERCENTUALE SCONTO", r.string());

      int err = file.autosave(rel, curr);
      if (err != NOERR)
      {
        msg = "! Errore di scrittura sul file LF_ANAMAG: ";
        msg << err;
        bf.add_line(msg);
      }
      else 
        valid++;
      codart = file.get_field(curr, "CODICE PRIMARIO");
      TLocalisamfile& umart = rel.lfile(LF_UMART);
      
      for (int nriga = 1; nriga <=3; nriga++)
      {
        umart.put("CODART",codart);
        umart.put("NRIGA",nriga);
        if (nriga == 1)
        {
          umart.put("FC", "1.00");
          um = file.get_field(curr,"UNITA DI MISURA");
          r = real(file.get_field(curr,"PREZZO VENDITA")) / CENTO;
          umart.put("PREZZO", r);
        }
        else
          if (nriga == 2)
          {
            r = real(file.get_field(curr, "COEFFICIENTE CONVERSIONE 2")) / CMILA;
            umart.put("FC", r);
            um = file.get_field(curr,"SECONDA UNITA DI MISURA");
          }
          else
          {
            r = real(file.get_field(curr, "COEFFICIENTE CONVERSIONE 3")) / CMILA;
            umart.put("FC", r);
            um = file.get_field(curr,"TERZA UNITA DI MISURA");
          }
        umart.put("UM", um);
        if (umart.write() != NOERR)
          err = umart.rewrite();
        if (err != NOERR)
        {
          msg.format("! Errore di scrittura sul file LF_UMART, articolo %s, UM %s: %d", (const char*) codart, (const char*) um, err);
          bf.add_line(msg);
        }
      }
    }
  }
  
  // Messaggio finale di elaborazione
  msg = "Record importati: ";
  msg << valid;
  bf.add_line(msg);
  bf.add_line("");
}

void TTrasfer36::main_loop()
{
  TMask36 m;
  TBrowsefile_field& bf = (TBrowsefile_field&)m.field(201);

  TViswin& vw = bf.vis_win();
  vw.show_rulers(FALSE);

  while (m.run() == K_ENTER)
  {
    vw.destroy_lines();
    TFilename name;

    name = m.get(101);
    if (name.not_empty())
      import_tables(name, bf);

    name = m.get(102);
    if (name.not_empty())
      import_clifo(name, bf);

    name = m.get(103);
    if (name.not_empty())
      import_anaart(name, bf);

    vw.goto_top();
  }
}

int ibm36100(int argc, char* argv[])
{
  TTrasfer36 a;
  a.run(argc, argv, "Trasferimento IBM36");
  return 0;
}