#ifndef DBICASCADER_H
#define DBICASCADER_H

//////////////////////////////////////////////////////////////////////////
////////////////////////////     ROOT API     ////////////////////////////
//////////////////////////////////////////////////////////////////////////

/**
 *
 *
 * \class COMET::IDbiCascader
 *
 *
 * \brief
 * <b>Concept</b> A cascade (prioritorised list) of IDbiConnection s, one
 *  for each database in the cascade.
 *
 * \brief
 * <b>Purpose</b> Implements the concept of a cascade allowing user to
 *   overrride parts of the standard database by introducing higher
 *   priority non-standard ones above it in a cascade.
 *
 * Contact: A.Finch@lancaster.ac.uk
 *
 *
 */

#include <map>
#include <ostream>
#include <string>
using std::string;
#include <vector>
using std::vector;

#if !defined(__CINT__) || defined(__MAKECINT__)
#include "Rtypes.h"
#endif

#include "IDbiConnection.hxx"
#include "IDbiStatement.hxx"
namespace COMET {
class IDbiCascader;
std::ostream& operator<<(std::ostream& os, const COMET::IDbiCascader& cascader) ;
}
class TSQL_Statement;

namespace COMET {
class IDbiCascader
{

  friend class IDbiDatabaseManager;  //Only it can create
  friend std::ostream& operator<<(std::ostream& s, const COMET::IDbiCascader& cascader);

public:

  /// Check we can connect to the database defined in the environment variables. Allows a
    /// user program to skip using the database if it doesn't need to and it is not there, or
    /// if it does need it then die in a civilised manner.
  static bool canConnect();
  friend class TDbiValidate;      //Allow TDbiValidate access SetAuthorisingEntry

  enum Status { kFailed, kClosed, kOpen };

// State testing member functions

// Cascade entry-specific getters.

/// Create a IDbiStatement.  Caller must delete.
 IDbiStatement* CreateStatement(UInt_t dbNo) const;

/// Return associated IDbiConnection. IDbiCascader retains ownership.
const IDbiConnection*
               GetConnection(UInt_t dbNo) const;
      IDbiConnection*
               GetConnection(UInt_t dbNo) ;

        string GetDbName(UInt_t dbNo) const;
         Int_t GetDbNo(const string& dbName) const;
         Int_t GetStatus(UInt_t dbNo) const {
                 if ( dbNo >= GetNumDb() || ! fConnections[dbNo]  ) return kFailed;
                 return fConnections[dbNo]->IsClosed() ? kClosed : kOpen; }
        string GetStatusAsString(UInt_t dbNo) const ;
        string GetURL(UInt_t dbNo) const {
                      return ( dbNo < GetNumDb() ) ? fConnections[dbNo]-> GetUrl(): ""; }
        Bool_t IsTemporaryTable(const string& tableName,
                                Int_t dbNo) const;
// Cascade-wide getters.

         Int_t AllocateSeqNo(const string& tableName,
                             Int_t requireGlobal = 0,
                             Int_t dbNo = 0) const;
         Int_t GetAuthorisingDbNo() const { return fGlobalSeqNoDbNo; }
        UInt_t GetNumDb() const {return fConnections.size();}
  Int_t  GetTableDbNo(const string& tableName, Int_t selectDbNo = -1) const;
        Bool_t TableExists(const string& tableName, Int_t selectDbNo = -1) const {
                      return this->GetTableDbNo(tableName,selectDbNo) >= 0; }

// State changing member functions

           Int_t CreateTemporaryTable(const string& tableName,
                                      const string& tableDescr);
     void HoldConnections();
     void ReleaseConnections();
     void SetPermanent(UInt_t dbNo, Bool_t permanent = true);

protected:

private:

     Int_t ReserveNextSeqNo(const string& tableName,
                            Bool_t isGlobal,
                            UInt_t dbNo) const;
     void SetAuthorisingEntry(Int_t entry) {fGlobalSeqNoDbNo = entry;}

// Constructors and destructors.
     IDbiCascader(bool beQuiet=false);
  virtual ~IDbiCascader();
IDbiCascader(const IDbiCascader&);  // Not implemented

// Data members

/// 1st db in cascade with GlobalSeqNo table
  Int_t fGlobalSeqNoDbNo;

/// Vector of TDbiConnections, one for each DB
  vector<IDbiConnection*> fConnections;

/// Mapping Name->DbNo for temporary tables.
  std::map<string,Int_t> fTemporaryTables;


/// Private Locker object used by IDbiCascader
class Lock {

public:
       Lock(IDbiStatement* stmtDB, const string& seqnoTable, const string& dataTable);
      ~Lock();

Bool_t IsLocked() const { return fLocked; }

private:

  void SetLock(Bool_t setting = kTRUE);

   IDbiStatement* fStmt;            // Statement to be used to issue lock
          string fSeqnoTableName;  // The SEQNO table that is locked
          string fDataTableName;   // The data table that is locked
          Bool_t fLocked;          // Lock status

};

 ClassDef(IDbiCascader,0)     //A cascade of TDbiConnectionss

};
};


#endif  // DBISKEL_H