#ifndef __TRANSACTION_H
#define __TRANSACTION_H 

#ifndef __ASSOC_H
#include <assoc.h>
#endif

#ifndef __COLORS_H
#include <colors.h>
#endif

#ifndef __REAL_H
#include <real.h>
#endif

#ifndef __REPUTILS_H
#include <reputils.h>
#endif

#define TRANSACTION_RUN "RUN"       // Run application (eventually sets firm)
#define TRANSACTION_INSERT "INSERT" // Create a new record and fill it
#define TRANSACTION_MODIFY "MODIFY" // Load and modify an existing record
#define TRANSACTION_DELETE "DELETE" // Delete an existing record
#define TRANSACTION_LINK "LINK"     // Load an existing record and interactively edit it

#define TRANSACTION_HEADER 0

typedef enum {ini_transaction, xml_transaction} transaction_type;
typedef enum { transaction_mode_interactive = 'I', transaction_mode_automatic = 'A', transaction_mode_remain = 'R'} transaction_mode;

// @doc EXTERNAL

// @class TTransaction | Classe per la gestione dei file di configurazione in formato
//                  Windows
//
// @base public | TObject
class TTransaction : public TObject

  // @author:(INTERNAL) Bonazzi


    // @access:(INTERNAL) Private Member
{
  // @cmember:(INTERNAL) Contenuto della testata
  TAssoc_array _head;
  // @cmember:(INTERNAL) Contenuto delle righe
  TAssoc_array _rows;
  // @cmember:(INTERNAL) Nome del file 
  TFilename _file;
  // @cmember:(INTERNAL) tipo transazione 
  transaction_type _type;
  TString _executer;

  // @access Protected Member
protected:
  // @cmember legge da in file ini
  bool TTransaction::read_ini();
  // @cmember legge da un xml
  bool TTransaction::read_xml();
  // @cmember scrivono un file ini
  void write_ini_row_para(TConfig & cnf, const TString & para, bool exec = true);
  bool TTransaction::write_ini();
  // @cmember scrivono un xml
  void write_xml_row_para(TXmlItem & xml, const TString & rowkey, bool exec = true);
  bool TTransaction::write_xml();
  // @cmember costruisce il nome di una variabile
  const char* build_rowkey(const char * file, int row = 0) const;
  // @cmember ritorna il file di una riga
  const char * TTransaction::get_rowkey_logicnum(const TString & var) const;
    // @cmember ritorna il numero di riga di una riga
  int TTransaction::get_rowkey_row(const TString & var) const;
  // @cmember costruisce il nome di una variabile
  const char* build_varkey(const char* var, int index) const;
  // @cmember ritorna l'indice di una variabile
  int get_varkey_index(const TString & var) const;
  // @cmember ritorna il nome di una variabile
  const char * get_varkey_name(const TString & var) const;
  // @cmember Duplica una transazione.
  virtual TObject* dup() const { return new TTransaction(*this); }
  // @cmember Copia da una transazione.
  virtual TTransaction & copy(const TTransaction & t);
  // @access Public Memeber
public:

  // @cmember Ritornano il valore della variabile nella testata o nella righa specificata
  virtual const TString& get(const char* var, int index = -1, const char * table = nullptr, int row = 0) const;
  long get_long(const char* var, int index = -1, const char * table = nullptr, int row = 0) const { return atol(get(var, index, table, row)); }
  real get_real(const char* var, int index = -1, const char * table = nullptr, int row = 0) const { return (real)get(var, index, table, row); }
  int get_int(const char* var, int index = -1, const char * table = nullptr, int row = 0) const { return atoi(get(var, index, table, row)); }
  bool get_bool(const char* var, int index = -1, const char * table = nullptr, int row = 0) const;
  COLOR get_color(const char* var, int index = -1, const char * table = nullptr, int row = 0) const;

  const TString& get(const char* var, int index = -1, int logic = TRANSACTION_HEADER, int row = 0) const
    { return get(var, index, (logic != TRANSACTION_HEADER) ? format("%d", logic) : "", row); }
  long get_long(const char* var, int index = -1, int logic = TRANSACTION_HEADER, int row = 0) const 
    { return get_long(var, index, (logic != TRANSACTION_HEADER) ? format("%d", logic) : "", row); }
  real get_real(const char* var, int index = -1, int logic = TRANSACTION_HEADER, int row = 0) const
    { return get_real(var, index, (logic != TRANSACTION_HEADER) ? format("%d", logic) : "", row); }
  int get_int(const char* var, int index = -1, int logic = TRANSACTION_HEADER, int row = 0) const
    { return get_int(var, index, (logic != TRANSACTION_HEADER) ? format("%d", logic) : "", row); }
  bool get_bool(const char* var, int index = -1, int logic = TRANSACTION_HEADER, int row = 0) const
    { return get_int(var, index, (logic != TRANSACTION_HEADER) ? format("%d", logic) : "", row); }
  COLOR get_color(const char* var, int index = -1, int logic = TRANSACTION_HEADER, int row = 0) const
    { return get_int(var, index, (logic != TRANSACTION_HEADER) ? format("%d", logic) : "", row); }


  // @cmember Setta la variabile nella nella testata o nella righa specificata
  virtual bool set(const char* var, const char* value, int index = -1, const char * table = nullptr, int row = 0);
  bool set(const char* var, long value, int index = -1, const char * table = nullptr, int row = 0);
  bool set(const char* var, real value, int index = -1, const char * table = nullptr, int row = 0);
  bool set(const char* var, int value, int index = -1, const char * table = nullptr, int row = 0);
  bool set(const char* var, bool value, int index = -1, const char * table = nullptr, int row = 0);
  bool set(const char* var, COLOR col, int index = -1, const char * table = nullptr, int row = 0);

  bool set(const char* var, const char* value, int index = -1, int logic = TRANSACTION_HEADER, int row = 0)
    { return set(var, value, index, (logic != TRANSACTION_HEADER) ? format("%d", logic) : "", row); }
  bool set(const char* var, long value, int index = -1, int logic = TRANSACTION_HEADER, int row = 0)
    { return set(var, value, index, (logic != TRANSACTION_HEADER) ? format("%d", logic) : "", row);  }
  bool set(const char* var, real value, int index = -1, int logic = TRANSACTION_HEADER, int row = 0)
  { return set(var, value, index, (logic != TRANSACTION_HEADER) ? format("%d", logic) : "", row); }
  bool set(const char* var, int value, int index = -1, int logic = TRANSACTION_HEADER, int row = 0)
    { return set(var, value, index, (logic != TRANSACTION_HEADER) ? format("%d", logic) : "", row); }
  bool set(const char* var, bool value, int index = -1, int logic = TRANSACTION_HEADER, int row = 0)
    { return set(var, value, index, (logic != TRANSACTION_HEADER) ? format("%d", logic) : "", row); }
  bool set(const char* var, COLOR col, int index = -1, int logic = TRANSACTION_HEADER, int row = 0)
    { return set(var, col, index, (logic != TRANSACTION_HEADER) ? format("%d", logic) : "", row); }
  // @cmember Controlla se esite una variabile nella nella testata o nella righa specificata
  
  bool exist(const char* var, int index = -1, const char * table = nullptr, int row = 0);
  bool exist(const char* var, int index = -1, int logic = TRANSACTION_HEADER, int row = 0)
  { return exist(var, index, (logic != TRANSACTION_HEADER) ? format("%d", logic) : "", row); }

  // @cmember Elimina una variabile nella nella testata o nella righa specificata
  bool remove(const char* var, int index = -1, const char * table = nullptr, int row = 0);
  bool remove(const char* var, int index = -1, int logic = TRANSACTION_HEADER, int row = 0)
  { return remove(var, index, (logic != TRANSACTION_HEADER) ? format("%d", logic) : "", row); }

  // @cmember Elimina una array di variabili nella nella testata o nella righa specificata
  bool remove_array(const char* var, const char * table = nullptr, int row = 0);
  bool remove_array(const char* var, int logic = TRANSACTION_HEADER, int row = 0)
  { return remove_array(var, (logic != TRANSACTION_HEADER) ? format("%d", logic) : "", row); }

  // @cmember Elimina tutte le variabili 
  void remove_all();
  // @cmember nouva transazione
  void new_transaction(const char* file) { set_name(file); remove_all(); }

  // @cmember Ritorna il nome del file di configurazione
  const TFilename& name() const { return _file; }
  void set_name(const char * name) { _file = name; _file.ext(_type == ini_transaction ? "ini" : "xml"); }
  const TString & executer() const { return _executer; }
  const char * record_header() const;
  const TString & get_action() const { return (const char *)get("Action", -1, nullptr); }
  char get_mode() const { get("Mode", -1, TRANSACTION_HEADER)[0]; }
  int get_stop_on_error() const { return get_bool("StopOnError", -1, nullptr) ? 1 : 0; }
  const TString & get_caller() const { get("From", -1, nullptr); }
  long get_firm() const { get_long("Firm", -1, nullptr); }
  bool result_ok() const { return get("Result", -1, nullptr) == "OK"; }
  bool result_error() const { return !ok(); }
  bool get_errors(TString_array & errors) const;
  bool get_warnings(TString_array & warnings) const;

  void set_executer(int logicnum) { _executer = format("%d", logicnum); }
  void set_executer(const char * table) { _executer = table; }
  bool set_action(TString & action) { return set("Action", action.upper(), -1, nullptr); }
  bool set_action(const char * action) { TString a(action); return set("Action", a.upper(), -1, nullptr); }
  bool set_mode(transaction_mode mode) { TString val; val << (char) mode; return set("Mode", val, -1, nullptr); }
  bool set_stop_on_error(bool val) { return set("StopOnError", val ? 1 : 0, -1, nullptr); }
  bool set_caller(const TString & caller) { return set("From", caller, -1, nullptr); }
  bool set_firm(int firm) { return set("Firm", firm, -1, nullptr); }
  const char * ext() const { return _type == ini_transaction ? "ini" : "xml"; }

  bool read();
  bool write();

  TTransaction & operator= (const TTransaction & t) { return copy(t); }

  // @cmember Costruttore di copia
  TTransaction(const TTransaction & t) { copy(t); }
  // @cmember Costruttore
  TTransaction(const char* file, const char* table, transaction_type type = ini_transaction) : _type(type), _executer(table) { set_name(file); if (_file.exist()) read(); }
  TTransaction(const char* file, int logicnum = 0, transaction_type type = ini_transaction) : _type(type), _executer(logicnum > 0 ? format("%d", logicnum) : "") { set_name(file); if (_file.exist()) read();
  }

  // @ cmember Distruttore. Riscrive il file con le modifiche se necessrio,
  virtual ~TTransaction() {}
};

void execute_transactions(TArray & transactions, TLog_report & log, bool interactive = true, const char * msg = nullptr);

#endif