#include <relapp.h>
#include <lffiles.h>
#include <modaut.h>
#include <utility.h>
#include <pconti.h>
#include <clifo.h>   
#include <anagr.h>  
#include <anafis.h> 
#include <validate.h>
#include <defmask.h>
#include <config.h>
#include "cg0.h"
#include "cg0200.h"

class CG0200_application : public TRelation_application
{
  TMask* _msk;
	TRelation *_rel;
	TLocalisamfile* _saldi;
	TLocalisamfile* _anag; 
	TLocalisamfile* _fis;
	TLocalisamfile* _comuni;
	TLocalisamfile* _pcon;

	bool user_create();
	bool user_destroy();
	virtual TMask* get_mask(int mode) {return _msk;}
	virtual bool changing_mask(int mode) {return FALSE;}
	virtual bool protected_record(TRectype &rec);
	virtual const char* get_next_key();
	virtual void init_query_mode(TMask& m);

public:
	virtual TRelation* get_relation() const {return _rel;}
	CG0200_application() {}
};

bool CG0200_application::protected_record(TRectype &rec)

{
	TMask* m = get_mask(MODE_MOD);
	const int  gruppo = atoi(m->get(F_GRUPPO));
	const int  conto = atoi(m->get(F_CONTO));
	const long sottoc = atol(m->get(F_CODCF));

	_saldi->zero();
	_saldi->put(PCN_GRUPPO, gruppo);
	_saldi->put(PCN_CONTO, conto);
	_saldi->put(PCN_SOTTOCONTO, sottoc);
	_saldi->read();

	return _saldi->good() &&
					gruppo ==_saldi->get_int(PCN_GRUPPO) &&
				  conto ==_saldi->get_int(PCN_CONTO) &&
					sottoc ==_saldi->get_long(PCN_SOTTOCONTO);
}

const char* CG0200_application::get_next_key()

{
  TLocalisamfile& clifo = *_rel->lfile() ;
  long	codcf = 1L ;
  const TString tipo(_msk->get(F_TIPOCF)) ;
  
  if (!clifo.empty())
  {
    clifo.zero() ;
    clifo.setkey(1) ;
    if ( tipo == TCLI )
    {
      clifo.put(CLI_TIPOCF, (const char* ) TFOR);
      clifo.read(_isgteq ) ;
      if (clifo.good())
        clifo.prev() ;
      clifo.setstatus(NOERR);
    }
    else clifo.last( ) ;
    if ( clifo.good() )
    {
      const TFixed_string tipocf(clifo.get(CLI_TIPOCF)); 
      if ( tipocf == tipo )
        codcf += clifo.get_long(CLI_CODCF);
    }
  }
  return format("%d|%s|%d|%ld", F_TIPOCF, (const char*) tipo, F_CODCF, codcf);
}

HIDDEN bool no_dup_fis(TMask_field& f, KEY key)
{
	TMask&	msk = f.mask() ;                                   
	
	if (msk.query_mode() || !f.to_check(key)) return TRUE;
	CG0200_application*  app = (CG0200_application*) MainApp();
	TLocalisamfile&	clifo = *app->get_relation()->lfile(LF_CLIFO) ;

	if ( f.get().not_empty() && !clifo.empty() )
	{
		clifo.zero() ;
		const char t1 = msk.get(F_TIPOCF)[0] ;

		clifo.put(CLI_TIPOCF, t1);
		clifo.put(CLI_COFI, f.get());
		clifo.setkey(4) ;
		clifo.read() ;
		clifo.setkey(1) ;
		const char t = clifo.get_char(CLI_TIPOCF);
		const TFixed_string	s = clifo.get(CLI_CODCF);
		const TFixed_string	s1(msk.get(F_CODCF));

		if (clifo.good() && (t1 != t || s1 != s))
		{
			f.yesno_box("Codice fiscale gia' utilizzato per il codice : %c/%s",
								  t, (const char*) s);
			return FALSE;
		}
	}
	return TRUE ;
}

HIDDEN bool no_dup_iva(TMask_field& f, KEY key)
{
	TMask&					msk = f.mask() ;
	
	if (msk.query_mode() || !f.to_check(key)) return TRUE;
	
	CG0200_application*  app = (CG0200_application*) MainApp();
	TLocalisamfile&	clifo = *app->get_relation()->lfile(LF_CLIFO) ;

	if ( f.get().not_empty() && !clifo.empty() )
	{
		clifo.zero() ;
		const char t1  = msk.get(F_TIPOCF)[0];
		
		clifo.put(CLI_TIPOCF, t1) ;
		clifo.put(CLI_STATOPAIV, msk.get(F_STATOPAIV)) ;
		clifo.put(CLI_PAIV, f.get()) ;
		clifo.setkey(5) ;
		clifo.read() ;
		clifo.setkey(1) ;
		const char t  = clifo.get_char(CLI_TIPOCF);
		const TFixed_string	s = clifo.get(CLI_CODCF);
		const TFixed_string	s1(msk.get(F_CODCF));
		
		if (clifo.good() && (t1 != t || s1 != s))
		{
			f.error_box("Partita iva gia' definita per il codice : %c/%s",
								  t, (const char*) s);
			return FALSE ;
		}
	}
	return TRUE ;
}

HIDDEN bool autoexit_handler(TMask_field& f, KEY key)

{ 
	if (f.mask().query_mode())
	{
	  if (key == K_TAB && f.focusdirty())
	  {
	  	TArray parms;
	  	parms.add((TString)format("%d", f.dlg()));
	  	::validate(AUTOEXIT_FUNC, (TEdit_field&) f, key, parms);
	  }	
	}  
	else
		if (f.to_check(key) && f.mask().get(F_ALLEG) != "4")
		{
			if (f.dlg() == F_COFI) return no_dup_fis(f, key);
			else return no_dup_iva(f, key);
		}	
  return TRUE;  
}

HIDDEN bool lbcn = FALSE;

HIDDEN bool tipo_handler(TMask_field& f, KEY key)
                                        
{
  TMask& m = f.mask();
  
  const bool fis = f.get() == "F";
  
  m.send_key(K_SHIFT + K_CTRL + (lbcn && fis ? 's' : 'h'), -5);
  return TRUE;
}

HIDDEN bool percip_handler(TMask_field& f, KEY key)
                                        
{
  TMask& m = f.mask();


	if (f.to_check(key) && m.get(F_CODANAGPER).not_empty())
	{     
	  TLocalisamfile anag(LF_ANAG);
	  TString c(m.get(F_COFI)), p(m.get(F_PAIV));

		if ((c.not_empty() && c != anag.get(ANA_COFI)) || 
				(p.not_empty() && p != anag.get(ANA_PAIV))) return error_box("Percipiente non corretto");
		TString r(anag.get(ANA_RAGSOC));
		if (m.get(F_RAGSOC).empty() || 
				(key == K_TAB && yesno_box("Ragione sociale differente correggo in %s", (const char*) r)))
			m.set(F_RAGSOC, r, TRUE);
		if (m.get(F_INDCF).empty()) m.set(F_INDCF, anag.get(ANA_INDRES));
		if (m.get(F_CIVCF).empty()) m.set(F_CIVCF, anag.get(ANA_CIVRES));
		if (m.get(F_CAPCF).empty()) m.set(F_CAPCF, anag.get(ANA_CAPRES));
		if (m.get(F_COMCF).empty()) 
		{
			m.set(F_STATOCF, anag.get(ANA_STATORES), TRUE);
			m.set(F_COMCF, anag.get(ANA_COMRES), TRUE);
		}
		if (c.empty()) m.set(F_COFI, anag.get(ANA_COFI));
		if (p.empty()) m.set(F_PAIV, anag.get(ANA_PAIV));
		if (m.get(F_TIPOAPER) == "F")
		{
			m.send_key(K_SHIFT + K_CTRL + (lbcn ? 's' : 'h'), -5);
			if (lbcn)
			{
		  	TLocalisamfile fis(LF_ANAGFIS);
		   
		  	fis.zero();
		  	fis.put(ANF_CODANAGR, anag.get(ANA_CODANAGR));
		  	fis.read();
		  	if (fis.good())
		  	{
					if (m.get(F_DATANASC).empty()) m.set(F_DATANASC, fis.get(ANF_DATANASC));
					if (m.get(F_COMNASC).empty())
					{
						m.set(F_STATONASC, fis.get(ANF_STATONASC));
						m.set(F_COMNASC, fis.get(ANF_COMNASC));
					}	
		  	}
		  }	
		}
	}
  return TRUE;                                  
}
  
  
HIDDEN bool alleg_handler(TMask_field& f, KEY key)

{ 
  if (f.to_check(key))
  {
    const int tipoall = atoi(f.get());
    TMask& m = f.mask();

    if (tipoall == 0 || tipoall == 4) m.enable(F_CODALLEG);
    else
    {
      m.disable(F_CODALLEG);
      m.reset(F_CODALLEG);
    }
    m.set(F_OCCASIONALE, (tipoall == 2) ? "X" : " ");
  }
  return TRUE;
}

HIDDEN bool occas_handler(TMask_field& f, KEY key)

{ 
  if (f.to_check(key))
  {
    const bool occas = f.get().not_empty();
    TMask& m = f.mask();

    if (occas) m.set(F_ALLEG, "2");
    else
      if (m.get_int(F_ALLEG) == 2)  m.set(F_ALLEG, " ");
  }
  return TRUE;
}

HIDDEN bool codalleg_handler(TMask_field& f, KEY key)

{ 
  if (f.to_check(key))
  {
    const TString cod(f.get());

    if (cod.not_empty())
    {
      TMask& m = f.mask();

      if (cod == m.get(F_TIPOCF))
        return error_box("Codice per allegato non corretto");

      TLocalisamfile clifo(LF_CLIFO);
      const TString tipo(m.get(F_TIPOCF));

      clifo.zero() ;
      clifo.setkey(1) ;
      clifo.put(CLI_TIPOCF, tipo);
      clifo.put(CLI_CODCF, cod);
      clifo.read() ;
      if (clifo.bad()) return FALSE;
      TString tipoall(clifo.get(CLI_ALLEG));
      if (clifo.get(CLI_CODALLEG).not_empty() ||
          clifo.get(CLI_PAIV).empty() || 
          (tipoall.not_empty() && tipoall != "4"))
        return error_box("Codice per allegato non corretto");
    }
  }
  return TRUE;
}

void CG0200_application::init_query_mode(TMask& m)

{
	TConfig conf(CONFIG_DITTA, "cg");
	
	lbcn = (conf.get("GsLbCn") == "X");
	m.send_key(K_SHIFT + K_CTRL + (lbcn ? 's' : 'h'), -5);
}

bool CG0200_application::user_create() // initvar e arrmask
{
	const bool ftaut = has_module(FTAUT);
	const bool spaut = has_module(SPAUT);
	const bool anyaut = spaut || ftaut;

	_rel = new TRelation(LF_CLIFO);
  _saldi = new TLocalisamfile(LF_SALDI);
	_anag = new TLocalisamfile(LF_ANAG);
	_fis = new TLocalisamfile(LF_ANAGFIS);
  _pcon = new TLocalisamfile(LF_PCON);
  _comuni = new TLocalisamfile(LF_COMUNI);
  _msk = new TMask("cg0200a") ;
  _msk->enable(F_SCONTO,ftaut);
  _msk->enable(F_CODVAL,ftaut);
  _msk->enable(F_RAGGRB,ftaut);
  _msk->enable(F_RAGGFT,ftaut);
  _msk->enable(F_CODVETT1,ftaut);
  _msk->enable(F_CODVETT2,ftaut);
  _msk->enable(F_CODVETT3,ftaut);
  _msk->enable(F_CODCFFATT,ftaut);
  _msk->enable(F_DESTIN,ftaut);
  _msk->enable(F_FIDO,spaut);
  _msk->enable(F_CODABI, anyaut);
  _msk->enable(F_CODBAN, anyaut);
  _msk->enable(F_CODAG, anyaut);
  _msk->set_handler(F_OCCASIONALE, occas_handler);
  _msk->set_handler(F_COFI, autoexit_handler);
  _msk->set_handler(F_PAIV, autoexit_handler);
  _msk->set_handler(F_CODANAGPER, percip_handler);
  _msk->set_handler(F_TIPOPERS, tipo_handler);
  _msk->set_handler(F_ALLEG, alleg_handler);
  _msk->set_handler(F_CODALLEG, codalleg_handler);

  _saldi->setkey(2);
  return TRUE;
}

bool CG0200_application::user_destroy() // releasev e arrmask
{
  delete  _msk;
  delete  _rel;
  delete  _saldi;
  delete  _anag;
  delete  _fis;
  delete  _pcon;
  delete  _comuni;
  return TRUE;
}

int cg0200(int argc, char* argv[])
{
  CG0200_application a ;
  a.run(argc, argv, "Clienti/Fornitori");
  return 0;
}