#include "f90.h"
#include "applicat.h"
#include "automask.h"
#include "f90200a.h"
#include "tsdb.h"
#include "../fp/fplib.h"
#include "f901tab.h"
#include "f90100.h"

TString escape(const char* str);

///////////////////////////////////////////////////////////////
// TF9_categorie_doc_msk
///////////////////////////////////////////////////////////////

class TF9_categorie_doc_msk : public TAutomask
{
  std::unique_ptr<TArray_sheet> _annessi_sheet;
  TRecord_categorie             _categorie_doc;

  bool on_field_event(TOperable_field& o, TField_event e, long jolly) override;
  bool on_key(KEY key) override;

  void check_spell() const;
  void fill_annessi(const TString& catdoc);
  void fill_annessi(const TString_array& annessi);
  void load_table() const;
  void salva_tabella() const;

public:
  TF9_categorie_doc_msk() : TAutomask("f90200a") { load_table(); }
};

bool TF9_categorie_doc_msk::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  switch(o.dlg())
  {
  case DLG_OK:
    if (e == fe_button)
      salva_tabella();
    break;
  case B_DELETE:
    if (e == fe_button)
    {
      TSheet_field& sf = sfield(S_CLASSDOC);
      sf.hide();
      FOR_EACH_SHEET_ROW(sf, nr, row)
      {
        if (row->starts_with("X"))
        {
          sf.destroy(nr);
          --nr;
        }
      }
      sf.show();
    }
    break;
    case DLG_USER:
      if (e == fe_button)
      {
        TSheet_field& sf = sfield(S_CLASSDOC);
        const TString catdoc_padre(sf.row(sf.selected()).get(1));
        const TString tipoann = sf.row(sf.selected()).get(cid2index(F_OPERCEE));
        if (!tipoann.empty())
        {
          warning_box("Impossibile visualizzare gli annessi di una categoria annesso.");
          break;
        }
        fill_annessi(catdoc_padre);
        int key;
        while ((key = _annessi_sheet->run()) != K_ESC)
        {
          if (key == K_INS)
          {
            TArray_sheet* catd = _categorie_doc.get_sheet_catdocs().get();
            if (catd->run() == K_ENTER)
            {
              _categorie_doc.add_annesso(catdoc_padre, catd->row(catd->selected()).get(0));
              fill_annessi(catdoc_padre);
            }
          }
          else if (key == K_DEL)
          {
            const int r = _annessi_sheet->selected();
            if (yesno_box("Eliminare l'annesso N. %d?", r + 1))
            {
              _categorie_doc.del_annesso(catdoc_padre, _annessi_sheet->row(r).get(0));
              fill_annessi(catdoc_padre);
            }
          }
        }
      }
    default: break;
  }

  return true;
}

bool TF9_categorie_doc_msk::on_key(KEY key)
{
  if (key == K_DEL)
  {
    TSheet_field& sf = sfield(S_CLASSDOC);
    sf.hide();
    int row = sf.selected();
    TString_array& arr = sf.rows_array();
    arr.destroy(row, true);
    sf.force_update();
    sf.show();
  }
  return TAutomask::on_key(key);
}

void TF9_categorie_doc_msk::check_spell() const
{
  TSheet_field& sf = sfield(S_CLASSDOC);
  FOR_EACH_SHEET_ROW(sf, nr, row)
  {
    TString start;
    TString catdoc = start = row->get(F_CATDOC - 101);
    catdoc.trim();
    catdoc.upper();
    std::string ss = (const char*)catdoc;
    for (size_t i = 0; i < ss.size(); ++i)
    {
      if (!(ss[i] >= 'A' && ss[i] <= 'Z' || ss[i] >= '0' && ss[i] <= '9' || ss[i] == '_'))
        ss.erase(i--, 1);
    }
    catdoc = ss.c_str();
    row->add(catdoc, 1);
    if (catdoc != start)
      sf.force_update();
  }
}

void TF9_categorie_doc_msk::fill_annessi(const TString& catdoc)
{
  TRecord_categorie annessi(TRecord_categorie::annessi);
  TToken_string r;
  if (_annessi_sheet == nullptr)
    _annessi_sheet = make_unique<TArray_sheet>(-1, -1, 78, 13, "Annessi", "Categoria\nDocumento (Codice)@15|Descrizione@26", 6);
  _annessi_sheet->destroy();
  annessi.put("CATDOC", catdoc);
  for(bool ok = annessi.read(); ok; ok = annessi.next())
  {
    _categorie_doc.put("NAME", annessi.get("NAME"));
    _categorie_doc.read(true);
    r.cut(0);
    r.add(annessi.get("NAME"), 0);
    r.add(_categorie_doc.get("DESCR"));
    _annessi_sheet->add(r);
  }
}

void TF9_categorie_doc_msk::fill_annessi(const TString_array& annessi)
{
  TToken_string r;
  if (_annessi_sheet == nullptr)
    _annessi_sheet = make_unique<TArray_sheet>(-1, -1, 78, 13, "Annessi", "Categoria\nDocumento (Codice)@15|Descrizione@26", 6);
  _annessi_sheet->destroy();
  FOR_EACH_ARRAY_ITEM(annessi, nr, row)
  {
    _categorie_doc.put("NAME", ((TToken_string*)row)->get(0));
    _categorie_doc.read();
    r.cut(0);
    r.add(((TToken_string*)row)->get(0), 0);
    r.add(_categorie_doc.get("DESCR"));
    _annessi_sheet->add(r);
  }
}

void TF9_categorie_doc_msk::load_table() const
{
  TSheet_field& sf = sfield(S_CLASSDOC);
  sf.hide();
  sf.destroy();

  int idx = 0;
  while (true)
  {
    const TString& appo = ini_get_string(CONFIG_DITTA, "F9", "CATDOC", "", idx++);
    if (appo == "STOP" || appo.empty())   /* STOP: Riga terminatrice */
      break;
    TToken_string& row = sf.row(-1);
    row = appo;
  }

  sf.show();
  sf.force_update();
}

void TF9_categorie_doc_msk::salva_tabella() const
{
  check_spell();
  int idx = 0;
  TString iget = "start";
  while (iget != "STOP" && !iget.empty())
  {
    iget = ini_get_string(CONFIG_DITTA, "F9", "CATDOC", "", idx);
    ini_remove(CONFIG_DITTA, "F9", "CATDOC", idx++);
  }

  idx = 0;
  TSheet_field& sf = sfield(S_CLASSDOC);
  FOR_EACH_SHEET_ROW(sf, nr, row)
  {
    if(row->get(1) && TString(row->get(1)).full())
      ini_set_string(CONFIG_DITTA, "F9", "CATDOC", *row, idx++);
  }
  ini_set_string(CONFIG_DITTA, "F9", "CATDOC", "STOP", idx);  // Riga terminatrice

  // Reload
  load_table();
}


///////////////////////////////////////////////////////////////
// TF9_categorie_doc
///////////////////////////////////////////////////////////////

class TF9_categorie_doc : public TSkeleton_application
{
  TString _log;
  void add_error_log(TString& query);
  void main_loop() override;

public:
  TF9_categorie_doc() = default;
};


void TF9_categorie_doc::add_error_log(TString& query)
{
  _log << "\n" << query << "\n" << fp_db().sq_get_text_error() << "\n" << fp_db().sq_get_string_error();
}

void TF9_categorie_doc::main_loop()
{
  TF9_categorie_doc_msk msk;
  while(msk.run() == K_ENTER)
  {
    TSheet_field& sf = msk.sfield(S_CLASSDOC);
    TString query;
    query << "TRUNCATE TABLE " F9_DRT ";\n";
    bool ok = fp_db().sq_set_exec(query, false) && fp_db().sq_commit();
    if (ok)
    {
      FOR_EACH_SHEET_ROW(sf, nr, row)
      {
        query.cut(0);
        query << "INSERT INTO " F9_DRT "("
          DRT_CODSOC  ", "
          DRT_CATDOC  ", "
          DRT_DESCR   ", "
          DRT_CLASSO  ", "
          DRT_CAUSSO  ", "
          DRT_CAUSCON ", "
          DRT_TIPOCAU ", "
          DRT_TIPOMOV ", "
          DRT_OPCEE   ")\nVALUES('" <<
          F9CONF.get_ambiente() << "', '" <<
          row->get(1)           << "', '" <<  // Catdoc
          escape(row->get(2))   << "', '" <<  // Descr
          row->get(3)           << "', '" <<  // Classe doc sost.
          row->get(4)           << "', '" <<  // Causale sost.
          escape(row->get(5))   << "', '" <<  // Causale cont
          escape(row->get(6))   << "', '" <<  // Tipo caus. cont
          escape(row->get(7))   << "', '" <<  // Tipo mov.
          row->get(8)           << "');\n";   // "Operat. CEE"
          ok &= fp_db().sq_set_exec(query, false) && fp_db().sq_commit();
        if (!ok)
          break;
      }
    }

    if (!ok)
    {
      add_error_log(query);
      ofstream fout;
      fout.open("f9.catdoc.dberror.txt");
      fout << _log << "\n";
      error_box("Errore nel salvataggio dei dati.\nControllare file di errore f9.catdoc.dberror.txt");
    }
  }
}

TString escape(const char* str)
{
  TString string; string << str;
  for (int pos = string.find('\''); pos != -1; pos = string.find('\'', pos + 2))
    string.insert("'", pos);
  return string;
}

int f90200(const int argc, char* argv[])
{
  TF9_categorie_doc app;
  app.run(argc, argv, TR("Configurazione Categorie Documentali."));
  return 0;
}