#include <xvt.h>

#include "calib01.h"
#include "calib02.h"

#include "movana.h"
#include "rmovana.h"
#include "saldana.h"

///////////////////////////////////////////////////////////
// TAnal_report
///////////////////////////////////////////////////////////

bool TAnal_report::get_usr_val(const TString& name, TVariant& var) const
{
  // CODCONTO:1, CODCMS:3, FASCMS:2, ecc...
  const int namelen = name.len();
  if (namelen >= 6 && name[namelen-2] == ':') 
  {
    int logicnum = 0;
    if (name.starts_with("CODCONTO:"))
      logicnum = LF_PCONANA; else
    if (name.starts_with("CODCMS:"))
      logicnum = LF_COMMESSE; else
    if (name.starts_with("CODCOSTO:"))
      logicnum = LF_CDC; else
    if (name.starts_with("FASCMS:"))
      logicnum = LF_FASI;
    if (logicnum > 0)
    {
      const TMultilevel_code_info& mci = ca_multilevel_code_info(logicnum);
      const int level = name[namelen-1]-'1';
      if (level < mci.levels())
      {
        TString16 fldname = name; fldname.cut(namelen-2);
        TFieldref field = mci.fieldref(level);
        field.set_name(fldname);
        field.set_from(0);
        fldname.cut(0) << field;  // Trasformo il TFieldref in stringa!
        get_record_field(fldname, var);
      }
      else
        var.set_null();
      return true;
    }
  }
  return TReport::get_usr_val(name, var);
}

size_t TAnal_report::get_usr_words(TString_array& words) const
{
  TReport::get_usr_words(words);
  
  const char* const name[] = 
  { 
    "CA_FORMAT_COSTO", 
    "CA_FORMAT_COMMESSA", 
    "CA_FORMAT_FASE", 
    "CA_FORMAT_CONTO", 
    "CA_FORMAT_CMSCDC", 
    NULL
  };

  ((TAnal_report*)this)->_first_msg = words.items(); // Calcola il primo numero disponibile
  size_t i; 
  for (i = 0; name[i] != NULL; i++)
    words.add(name[i]);
  
  return words.items();
}

void TAnal_report::msg_format(int logicnum, TVariant_stack& stack)
{
  const TString& str_in = curr_field()->get().as_string();
  if (str_in.not_empty())
  {
    TString80 separator = " ";
    if (stack.items() > 0)
      separator = stack.pop().as_string();
    if (separator.not_empty())
    {
      const TMultilevel_code_info& mci = ca_multilevel_code_info(logicnum);
      TString str_out;
      for (int i = 0; i < mci.levels(); i++)
      {
        const TFieldref& fld = mci.fieldref(i);
        const TString& str = str_in.sub(fld.from(), fld.to());
        if (str.not_empty())
        {
          if (i > 0) str_out << separator;
          str_out << str;
        }
        else
          break;
      }
      curr_field()->set(str_out);
    }
  }
}

void TAnal_report::msg_format_costo   (TVariant_stack& stack)
{ msg_format(LF_CDC, stack); }

void TAnal_report::msg_format_commessa(TVariant_stack& stack)
{ msg_format(LF_COMMESSE, stack); }

void TAnal_report::msg_format_fase    (TVariant_stack& stack)
{ msg_format(LF_FASI, stack); }

void TAnal_report::msg_format_conto   (TVariant_stack& stack)
{ msg_format(LF_PCONANA, stack); }

void TAnal_report::msg_format_commessa_costo(TVariant_stack& stack)
{
  const TMultilevel_code_info& main_info = ca_multilevel_code_info(LF_FASI);
	msg_format(main_info.parent(), stack);
}

bool TAnal_report::execute_usr_word(unsigned int opcode, TVariant_stack& stack)
{
  if (opcode < _first_msg)
    return TReport::execute_usr_word(opcode, stack);
  opcode -= _first_msg;
  switch (opcode)
  {
  case 0 : msg_format_costo(stack);          break;
  case 1 : msg_format_commessa(stack);       break;
  case 2 : msg_format_fase(stack);           break;
  case 3 : msg_format_conto(stack);          break;
  case 4 : msg_format_commessa_costo(stack); break;
  default: break;
  }
  return true;
}

///////////////////////////////////////////////////////////
// TAnal_balance
///////////////////////////////////////////////////////////

class TAnal_balance : public TObject
{
public:
  TImporto saldo_fine_anno(const char* conto, const char* costo, 
                           const char* commessa, const char* fase, 
                           int annofin, word tipo) const;
  bool saldo_movimenti(const char* conto, const char* costo, 
                       const char* commessa, const char* fase, 
                       const TDate& dal, const TDate& al, word tipo,
                       TImporto& ini, TImporto& dare, TImporto& avere) const;
  bool saldi(const char* conto, const char* costo, 
             const char* commessa, const char* fase,
             const TDate& dal, const TDate& al, word tipo, 
             TImporto& ini, TImporto& dare, TImporto& avere) const;
};

TImporto TAnal_balance::saldo_fine_anno(const char* conto, const char* costo, 
                                        const char* commessa, const char* fase, 
                                        int anno, word tipo) const
{
  TImporto saldo;

  if (anno > 0)
  {
    TString query, select;

    if (costo && *costo)
      select << "(CODCOSTO=='" << costo << "')";
    if (commessa && *commessa)
    {
      if (select.not_empty()) select << "&&";
      select << "(CODCMS=='" << commessa << "')";
    }
    if (fase && *fase)
    {
      if (select.not_empty()) select << "&&";
      select << "(FASCMS=='" << fase << "')";
    }
  
    query << "USE SALDANA";
    if (select.not_empty())
      query << "SELECT " << select;
    query << "\nFROM CONTO=" << conto << '\n';
    query << "\nTO CONTO=" << conto << " ANNO=" << anno << '\n';

    TISAM_recordset saldini(query);

    for (int i = 0; i < saldini.items(); i++)
    {
      if (tipo & 1)
      {
        const char sez = saldini.get(SALDANA_SEZIONE).as_string()[0];
        const real imp = saldini.get(SALDANA_SALDO).as_real();
        saldo += TImporto(sez, imp);
      }
      if (tipo & 2)
      {
        const char sez = saldini.get(SALDANA_SEZIONEP).as_string()[0];
        const real imp = saldini.get(SALDANA_SALDOP).as_real();
        saldo += TImporto(sez, imp);
      }
      if (tipo & 4)
      {
        const char sez = saldini.get(SALDANA_SEZIONEV).as_string()[0];
        const real imp = saldini.get(SALDANA_SALDOV).as_real();
        saldo += TImporto(sez, imp);
      }
    }
    saldo.normalize();
  }

  return saldo;
}

bool TAnal_balance::saldo_movimenti(const char* conto, const char* costo, 
                                    const char* commessa, const char* fase, 
                                    const TDate& dal, const TDate& al, word tipo,
                                    TImporto& ini, TImporto& dare, TImporto& avere) const
{
  TDate dataini;
  if (dal.ok())
  {
    TEsercizi_contabili esc;
    const int annoprec = esc.date2prevesc(dal);
    if (annoprec > 0)
      dataini = esc[annoprec].fine()+1L;
  }

  TString query;
  query << "USE RMOVANA KEY 2\n";
  if (dataini.ok())
    query << "&&(ANSI(107.DATACOMP)>=" << dataini.date2ansi() << ")";
  if (al.ok())
    query << "&&(ANSI(107.DATACOMP)<=" << al.date2ansi() << ")";
  if (costo && *costo)
    query << "&&(CODCOSTO==\"" << costo << "\")";
  if (commessa && *commessa)
    query << "&&(CODCMS==\"" << commessa << "\")";
  if (fase && *fase)
    query << "&&(CODFASE==\"" << fase << "\")";
  query << "\nJOIN MOVANA INTO NUMREG==NUMREG\n";

  query << "FROM CODCONTO=" << conto;
  if (dataini.ok())
    query << " DATAREG=" << TDate(dataini-90L).string();
  query << "\n";

  query << "TO CODCONTO=" << conto;
  if (al.ok())
    query << " DATAREG=" << al.string();
  query << "\n";
  
  TISAM_recordset rmovana(query);

  bool movimentato = false;
  for (int i = 0; i < rmovana.items(); i++)
  {
    rmovana.move_to(i);

    const char tipomov = rmovana.get("107.TIPOMOV").as_string()[0];
    int ntipomov = 0;
    if (tipomov == 'P')
      ntipomov = 2; else
    if (tipomov == 'V')
      ntipomov = 4; 
    else
      ntipomov = 1; 
    if ((ntipomov & tipo) == 0)
      continue;

    const TDate data = rmovana.get("107.DATACOMP").as_date();
    const TImporto imp(rmovana.get(RMOVANA_SEZIONE).as_string()[0], 
                       rmovana.get(RMOVANA_IMPORTO).as_real());
    if (data >= dal)
    {
      if (imp.sezione() == 'D')
        dare += imp;
      else
        avere += imp;
      movimentato = true;
    }
    else
    {
      ini += imp;
    }
  }
  ini.normalize();

  return movimentato;
}

bool TAnal_balance::saldi(const char* conto, const char* costo, 
                          const char* commessa, const char* fase,
                          const TDate& dal, const TDate& al, word tipo, 
                          TImporto& ini, TImporto& dare, TImporto& avere) const
{
  TEsercizi_contabili esc;
  const int annoprec = esc.date2prevesc(dal);
  ini = saldo_fine_anno(conto, costo, commessa, fase, annoprec, tipo);
  const bool mov = saldo_movimenti(conto, costo, commessa, fase, dal, al, tipo, 
                                   ini, dare, avere);
  return mov;
}

////////////////////////////////////////////////////////
// TSaldi_cache
////////////////////////////////////////////////////////

class TSaldi_cache : private TCache
{
protected:
  virtual TObject* key2obj(const char* key);

public:
  const TSaldanal& saldo(const char* conto, const char* costo, 
                         const char* commessa, const char* fase, 
                         const TDate& dal, const TDate& al, word tipi = 0x1);
  TSaldi_cache() : TCache(3883) { }
};

TObject* TSaldi_cache::key2obj(const char* key)
{
  TSaldanal* s = new TSaldanal;

  TToken_string tok(key);
  TString80 conto = tok.get(); conto.trim();
  TString80 costo = tok.get(); costo.trim();
  TString80 commessa = tok.get(); commessa.trim();
  TString80 fase = tok.get(); fase.trim();
  const TDate dal = tok.get();
  const TDate al = tok.get();
  const char tipo = tok.get_char();

  TAnal_balance bal;
  s->_movimentato = bal.saldi(conto, costo, commessa, fase, dal, al, tipo,
                              s->_ini, s->_dare, s->_avere);
  s->_fin = s->_ini; s->_fin += s->_dare; s->_fin += s->_avere;
  s->_fin.normalize();
  
  return s;
}

const TSaldanal& TSaldi_cache::saldo(const char* conto, const char* costo, 
                                     const char* commessa, const char* fase, 
                                     const TDate& dal, const TDate& al, word tipi)
{
  TToken_string key;
  key.add(conto, 0);
  key.add(costo, 1);
  key.add(commessa, 2);
  key.add(fase, 3);
  key.add(dal, 4);
  key.add(al, 5);
  key.add(tipi, 6);
  return *(const TSaldanal*)objptr(key);
}

const TSaldanal& ca_saldo(const char* conto, const char* costo, 
                          const char* commessa, const char* fase, 
                          const TDate& dal, const TDate& al, word tipi)
{
  static TSaldi_cache* cache = NULL;
  if (cache == NULL)
    cache = new TSaldi_cache;
  return cache->saldo(conto, costo, commessa, fase, dal, al, tipi);
}