#include <applicat.h>
#include <config.h>
#include <msksheet.h>
#include <utility.h>

#include "ba1.h"
#include "ba1600.h"

///////////////////////////////////////////////////////////
// Configurazione per installazione
///////////////////////////////////////////////////////////

class TInstall_ini : public TConfig
{ 
public:
  TInstall_ini() : TConfig("install.ini") { }
  virtual ~TInstall_ini() { }
};

///////////////////////////////////////////////////////////
// Maschera modulo
///////////////////////////////////////////////////////////

class TModule_mask : public TMask
{ 
protected:
  static bool link_handler(TMask_field& f, KEY k);
   
public:
  TModule_mask(const TString& module);
  virtual ~TModule_mask() { }
};

bool TModule_mask::link_handler(TMask_field& f, KEY k)
{
  if (k == K_SPACE)
  {
    TMask& modmask = f.mask();
    TSheet_field* sf = modmask.get_sheet();
    TMask& mainmask = sf->mask();
    TSheet_field& sheet = mainmask.sfield(F_SHEET);
    TToken_string& newrow = sheet.row(-1);
    newrow = modmask.get(101);
    TString16 submod = newrow.left(2);
    submod << '0';
    newrow.add(submod);
    if (modmask.is_running())
    {
      modmask.stop_run(K_ESC);
      do_events();
    }  
    sf->destroy(sf->selected());
    sheet.force_update();  
    sf->force_update();
  }
  return TRUE;
}


TModule_mask::TModule_mask(const TString& module)
            : TMask("ba1600b")
{
  TInstall_ini ini;
  TString paragraph, file;
  
  TSheet_field& s = sfield(F_SHEET);
  for (int sub = 0; ; sub++)
  {
    paragraph = module;
    paragraph << sub;
    if (ini.set_paragraph(paragraph))
    {
      for (int index = 0; ini.exist("File", index); index++)
      { 
        file = ini.get("File", NULL, index);
        file.lower();  
        TToken_string& row = s.row(-1);
        row = file;
        row.add(paragraph);
      }
    }  
    else
      break;
  }
  
  TToken_string externals(ini.get("Esterni", module), ' ');
  for (TString16 e = externals.get(0); !e.blank(); e = externals.get())
  {
    if (ini.set_paragraph(e))
    {
      for (int index = 0; ini.exist("File", index); index++)
      {
        file = ini.get("File", NULL, index);
        file.lower();    
        TToken_string& row = s.row(-1);
        row = file;
        row.add(e);
        s.disable_cell(s.items()-1, -1);
      }
    }  
    else
      break;
  }
  
  TSheet_field& miss = sfield(F_MISSING);
  miss.disable();   // Read-only sheet
  TMask& sm = miss.sheet_mask();
  sm.set_handler(100, link_handler);

  TFilename mask; 
  mask << module << "*.*";                    
  
  TString_array& arr = miss.rows_array();
  list_files(mask, arr);
  
  const char* goodext[] = { "exe", "msk", "frm", "rpt", NULL };
  
  for (int index = arr.items()-1; index >= 0; index--)
  { 
    bool keep = FALSE;             
    mask = arr.row(index);     
    mask.lower();
  
    const TString16 ext = mask.ext();
    for (int e = 0; goodext[e]; e++)
    {                        
      if (ext.compare(goodext[e], -1, TRUE) == 0)
      {       
        TString_array& sarr = s.rows_array();
        for (int i = sarr.items()-1; i >= 0; i--)
        {
          if (mask.compare(sarr.row(i).get(0), -1, TRUE) == 0)
            break;
        }
        keep = i < 0;
        break;
      }
    }
    
    if (keep)
      arr.row(index) = mask;
    else
      arr.destroy(index);
  }       
  arr.pack();
  miss.force_update();
}

///////////////////////////////////////////////////////////
// Maschera principale
///////////////////////////////////////////////////////////

class TFascicolator_mask : public TMask
{ 
protected:
  static bool list_handler(TMask_field& f, KEY k);

public:
  TFascicolator_mask();
  virtual ~TFascicolator_mask() { }
};

bool TFascicolator_mask::list_handler(TMask_field& f, KEY k)
{
  if (k == K_SPACE)
  {                
    const TMask& m = f.mask();
    const TString& module = m.get(S_MODULE);
    
    TModule_mask mm(module);
    if (mm.run() == K_ENTER)
    {   
      TInstall_ini ini;
      int index;
      for (index = 0; ; index++)
      {
        TString16 sub; sub << module << index;
        if (ini.set_paragraph(sub))
        {
          TAssoc_array& list = (TAssoc_array&)ini.list_variables();
          list.destroy();
        }
        else
          break;
      }
      
      TSheet_field& sheet = mm.sfield(F_SHEET);
      index = 0;
      for (int r = sheet.items()-1; r >= 0; r--)
      {
        if (!sheet.cell_disabled(r, 0))
        {
          TToken_string& row = sheet.row(r);
          TString16 sub = row.get(1);
          if (isdigit(sub[0]) || sub.left(2) == module)
          {
            if (isdigit(sub[0]))
              sub.insert(module, 0);
            ini.set("File", row.get(0), sub, TRUE, index++);
          }
        }
      }
    }
  }     
  return TRUE;
}

TFascicolator_mask::TFascicolator_mask()
                  : TMask("ba1600a")
{ 
  TSheet_field& s = sfield(F_SHEET);
  TMask& m = s.sheet_mask();
  m.set_handler(S_LIST, list_handler);
  
  TScanner scanner("prassi.aut");
  TString tmp;
  
  TInstall_ini ini;
  
  for (int modulo = 0; ;modulo++)
  {
    const TString& lin = scanner.line();
    if (lin.empty())
      break;
    TToken_string& row = s.row(modulo);
    tmp = lin.left(2);   
    row = lin.mid(3);
    row.add(tmp);
    
    if (tmp != "xx")
    {
      ini.set_paragraph(tmp);
      
      tmp = ini.get("Versione");
      row.add(tmp.left(2));
      row.add(tmp.mid(2));
  
      tmp = ini.get("Data");
      row.add(tmp);
      
      tmp = ini.get("Moduli");
      row.add(tmp);
    }  
    else  
      s.disable_cell(modulo, -1);
  }
}

///////////////////////////////////////////////////////////
// Programma principale
///////////////////////////////////////////////////////////

class TFascicolator : public TSkeleton_application
{ 
protected:
  virtual bool use_files() const { return FALSE; }
  virtual void main_loop();
};

void TFascicolator::main_loop()
{
  TFascicolator_mask m;
  m.run();
}

int ba1600(int argc, char* argv[])
{ 
  TFascicolator app;
  app.run(argc, argv, "The Fascicolator");
  return 0;
}