#include <errno.h>
#include <stdio.h>
#include <stdlib.h>

#define __PREFIX_CPP
#include <prefix.h>

#ifndef FOXPRO
#include <applicat.h>
#endif

#include <extcdecl.h>
#include <isam.h>
#include <scanner.h>
#include <utility.h>

#include <lffiles.h> 
#include <codeb.h>

extern int get_error(int);


///////////////////////////////////////////////////////////
// extern variables are NO-NO!
///////////////////////////////////////////////////////////

HIDDEN TString16 _user;
HIDDEN TPrefix* _prefhndl = NULL;

TString& user()
{
  return _user;
}

TPrefix& prefix_init()
{
  CHECK(_prefhndl == NULL, "Can't create two prefix objects");
  _prefhndl = new TPrefix;
  return *_prefhndl;
}

TPrefix& prefix()
{
  CHECK(_prefhndl, "Can't access null prefix");
  return *_prefhndl;
}

void prefix_destroy()
{
  delete _prefhndl;
  _prefhndl = NULL;
}

///////////////////////////////////////////////////////////
// TPrefix
///////////////////////////////////////////////////////////

HIDDEN const char* const glockname = "xx";

TPrefix::TPrefix() : _filelevel(0), _items(0)
{
  _prefix = ".";
  _dirfl = dirfl;
  _recfl = recfl;
  _fdir = fdir;
  _rdir = rdir;
  
  CGetPref();
  const TFilename dir(cprefix);

  const long primaditta = atol(dir.name());
  if (primaditta > 0 && !exist(primaditta))
  {
    ofstream out_pr(prefname());
    out_pr << "com" << endl;
  }  
}


TPrefix::~TPrefix()

{
  set();
}


HIDDEN int closeall(bool changestudy, TBit_array& excl, TBit_array& toclose)

{
  if (!openf) return 0;
  TDir    d;
  d.get(1);
  const int max = (int) d.eod();

  int err = NOERR;

  for (int i = 1; i < max; i++)
    if (openf[i] != NULL)
    {
      isfdptr isfd = openf[i];
      d.get(i + 1, _nolock, _nordir, _sysdirop);
      if (toclose[i + 1] || changestudy || !d.is_com())
      {
        excl.set(i, DB_file_locked(isfd->fhnd) == _excllock);
        err=DB_close(isfd->fhnd);
        if (err != NOERR) err=get_error(err);
        if (err != NOERR) fatal_box("Can't close file %d. Error n. %d",isfd->ln,err);
        exclunlock(CInsPref((char*) glockname, _nordir), FALSE);
      }
    }
  return max;
}


HIDDEN void openall(bool changestudy, TBit_array& excl, int oldmax, TBit_array& toopen) 

{
  if (!openf) return ;
  TDir    d;
  d.get(1);
  const int max = (int) d.eod();

  for (int i = max; i < oldmax; i++)
    if (openf[i] != NULL)
    {
      d.get(i + 1, _nolock, _nordir, _sysdirop);
      if (changestudy || !d.is_com())
        fatal_box("Can't reopen file n. %d", i + 1);
    }

  int err = NOERR;

  for (i = 1; i < max; i++)
    if (openf[i] != NULL)
    {
      isfdptr isfd = openf[i];
      d.get(i + 1, _nolock, _nordir, _sysdirop);
      const bool com = d.is_com();
      if (toopen[i + 1] || changestudy || !com)
      {
        isfd->ft = com ? _comdir : _nordir;
        d.get(i + 1, _nolock, (TDirtype) isfd->ft);
        *isfd->d = *d.filedesc();

        TTrec r;
        r.get(i + 1, (TDirtype) isfd->ft);
        *isfd->r = *r.rec();
        if (excllock(CInsPref((char*) glockname, NORDIR), FALSE) == -1 && errno == EACCES)
          fatal_box("Can't reopen file n. %d : file in use", i + 1);
        isfd->fhnd = DB_open(isfd->d->SysName,excl[i]==_excllock);
        if (isfd->fhnd < 0 ) err=get_error(isfd->fhnd);
        else err = NOERR;
        if (err == _islocked)   
          fatal_box("Can't reopen file n. %d : file in use", i + 1);
        if (err != NOERR) 
          fatal_box("Can't reopen file n. %d : error n. %d", i + 1, err);
      }
    }
}         

// @mfunc Riapre tutti gli archivi della ditta attiva
void TPrefix::reopen() const

{
  if (_prefix != ".")
  {
    TBit_array excl, comfiles;
    comfiles.set(LF_PCON);
    comfiles.set(LF_CLIFO);
    comfiles.set(LF_CAUSALI);
    comfiles.set(LF_RCAUSALI);
    int max = closeall(FALSE, excl, comfiles);

    openall(FALSE, excl, max, comfiles);
  }
}


// @mfunc Setta la ditta corrente                 
void TPrefix::set(
  const char* name, // @parm Nome del direttorio dati da attivare (default NULL)
  bool force,       // @parm Permette di settarla anche se non esiste (default FALSE)
  TFilelock mode)   // @parm Permette di aprire la ditta in modo esclusico (default _manulock)
  
  // @comm Il parametro <p name> puo' assumere i seguenti valori:
  //
  // @flag NULL | Chiude tutti i files
  // @flag COM | Apre il direttorio con i dati comuni
  // @flga DEF | Riapre la ditta indicata nel file prefix.txt
  // @flag codice ditta | Apre la ditta indicata
{
  if (name == NULL)
  {
    CCloseDir(NORDIR);
    CCloseDir(COMDIR);
    CCloseRecDir(NORDIR);
    CCloseRecDir(COMDIR);
    _prefix = ".";
    return;
  }

  if (_prefix == name) return;

  if (!force && !test(name)) return;

  TBit_array excl, comfiles;
  int     max = 0;
  comfiles.set(LF_PCON);
  comfiles.set(LF_CLIFO);
  comfiles.set(LF_CAUSALI);
  comfiles.set(LF_RCAUSALI);

  if (_prefix != ".")
  {
    max = closeall(FALSE, excl, comfiles);
    CCloseDir(NORDIR);
    CCloseDir(COMDIR);
    CCloseRecDir(NORDIR);
    CCloseRecDir(COMDIR);
  }

  if (strcmp(name, "DEF") == 0)
  {
    CGetPref();
    _prefix = cprefix;
    const int l = strlen(__ptprf);
    if (l > 0) _prefix.ltrim(l);
  }
  else
  {      
    _prefix = name;
    if (*__ptprf && *name) strcpy(cprefix, __ptprf);
    else strcpy(cprefix, "");
    strcat(cprefix, name);
  }

  if (!test(_prefix)) 
    fatal_box("Impossibile utilizzare la ditta %s", name);

  COpenDir((int) mode, NORDIR);
  COpenDir((int) mode, COMDIR);
  COpenRecDir((int) mode, NORDIR);
  COpenRecDir((int) mode, COMDIR);
  if (_prefix != ".")
  {    
    FileDes d;
    
    CGetFile(LF_DIR, &d, _nolock, NORDIR);
    _filelevel = d.Flags;
    _items = (int)d.EOD;
    openall(FALSE, excl, max, comfiles);
  }
}

bool TPrefix::exist(long codditta) const
{
  CHECKD(codditta > 0, "Solo le ditte con codice maggiore di zero possono esistere : codice ", codditta);
  TFilename s(firm2dir(codditta)); s << "/dir.gen";

  if (fexist(s))
  {
    s = s.path();
    s << "/trc.gen";
    return fexist(s);
  }
  return FALSE;
}

bool TPrefix::test(const char* s) const
{
  if (s && *s && strcmp(s, "DEF"))
  {
    TFilename s1(__ptprf);
    s1 << s << "/dir.gen";
    if (!fexist(s1))
      return error_box("Impossibile trovare il file '%s'", (const char*)s1);
  }

  if ((_dirfl[0] > 1) || (_dirfl[1] > 1) ||
      (_recfl[0] > 1) || (_recfl[1] > 1))
    return error_box("Impossibile cambiare ditta (dir.gen o trc.gen in uso)");
  
  return TRUE;
}


void TPrefix::put()

{
  CPutPref((char*)(const char*)_prefix);
}


bool TPrefix::test(long codditta) const
{
  TString16 s; s.format("%05lda", codditta);
  return test(s);
}


long TPrefix::get_codditta() const

{
  const long codditta = atol((const char*)_prefix);
  return codditta;
}


bool TPrefix::set_codditta(long codditta, bool force)
{
  if (force || test(codditta))
  {
    TString16 s; s.format("%05lda", codditta); 
    set(s, force);
    put();
    return TRUE;
  }
  return FALSE;
}


// @mfunc Ritorna la descrizione del file passato
const char* TPrefix::description(
  const char* cod) const // @parm Nome del file di cui si vuole conoscere la descrizione

  // @syntax const char* description(const char* cod);
  // @syntax const char* description(int cod);
  //                    
  // @comm Il parametro <p cod> puo' indicare anche il nome di una tabella. In questo caso ne
  //       ritorna la descrizione.
  //             <nl>Passando il nome di una tabella in <p cod> si ottiene la stessa cosa della
  //             funzione <mf TDir::Tab_des>, ma viene cercato la descrizione nel titolo della maschera.
{
  TString80 n(cod);

  if (n[0] == '%') 
    n.ltrim(1);
  
  const int logicnum = atoi(n);
  if (logicnum == 0)
  {
    TFilename name("batb"); 
    name << n << ".msk";
    if (fexist(name.lower()))
    {
      TScanner m(name);
      while (m.line().left(2) != "PA");      // Find PAGE
      const int apicia = m.token().find('"')+1;
      const int apicic = m.token().find('"', apicia);
      n = m.token().sub(apicia, apicic);
    } 
    else n.cut(0);
  }  
  else
  {
    if (logicnum > 0 && logicnum < items())
    { 
      const TBaseisamfile f(logicnum);
      n = f.description();
    } 
    else n.cut(0);
  }  
  
  return strcpy(__tmp_string, n);
}

const char* TPrefix::description(int cod) const
{
  TString16 n; n << cod;
  return description(n);
}


// Restituisce il nome di una directory dati
// Certified 90%
const char* firm2dir(long codditta)
{                  
  TFixed_string dir(__tmp_string, 256); 
  switch (codditta)
  {
  case -2:                                     // Dati generali campione
  case -1:                                     // Dati di studio
    dir = ""; break;
  case  0:                                     // Dati comuni
    dir = "com"; break;
  default:                                     // Dati ditta
    dir.format("%05lda", codditta); break;
  }    
  dir.insert(__ptprf, 0);
  return __tmp_string;
}


