#ifndef DBQOP_H
#define DBQOP_H


//FOR LINUX OPERATIVE SYSTEM
#ifdef __linux__
#ifdef BUILD_DBQOP
#define DBQOP_ATTRS extern __attribute__((visibility("default")))
#define DBQOP_STRUCT_EXPORT __attribute__((visibility("default")))
#define DBQOP_DTS_ATTRS
#else
#define DBQOP_ATTRS extern
#define DBQOP_STRUCT_EXPORT
#define DBQOP_DTS_ATTRS
#endif // BUILD_DBQOP
#endif // __linux__

//FOR WINDOWS OPERATIVE SYSTEM
#ifdef __windows__
#ifdef BUILD_DBQOP
#define DBQOP_ATTRS extern __declspec(dllexport)
#define DBQOP_STRUCT_EXPORT __declspec(dllexport)
#define DBQOP_DTS_ATTRS STDCALL
#else
#define DBQOP_ATTRS extern __declspec(dllimport)
#define DBQOP_STRUCT_EXPORT __declspec(dllimport)
#define DBQOP_DTS_ATTRS STDCALL
#endif // BUILD_DBQOP
#include <windows.h>
#include <windef.h>
#endif // __windows__


//THE ORDER OF THESE INCLUDES MATTER

#include <iostream>
#include <cstring>
#include <vector>
#include <ctime>
#include <typeinfo>
#include <string>
#include <sql.h>
#include <sqltypes.h>
#include <sqlext.h>
#include <algorithm>
#include "interop.h"
#include "binrw.h"

#define MAX_COL_TYPE_NAME_LENGTH 64
#define MAX_TYPE_LENGTH sizeof(LONGLONG)
#define MAX_COMMAND_LENGTH 1048576//1024*1024
#define MAX_ERROR_MESSAGES 1024



using namespace canonbit_definitions::interoperatibility;
using namespace canonbit_algorithms::binary_reader_writer;
namespace brw=canonbit_algorithms::binary_reader_writer;

typedef SQLCHAR*              PSQLCHAR;
typedef SQLWCHAR*             PSQLWCHAR;
typedef SQLSMALLINT*          PSQLSMALLINT;
typedef SQLUSMALLINT*         PSQLUSMALLINT;
typedef SQLINTEGER*           PSQLINTEGER;
typedef SQLLEN*               PSQLLEN;
typedef SQL_TIMESTAMP_STRUCT* PTIMESTAMP;
typedef struct DataBuffer
{
    SQLLEN   buffer_size;
    PSQLCHAR buffer;
} CellData;
typedef std::vector<CellData>      RowData;
typedef std::vector<RowData>       TableData;//Collections of row buffers pointers


namespace canonbit_databases{

namespace odbc_database_operations{

    enum TABLE_COLUMN_TYPES
    {
        PRIMARY_KEY=0,
        FOREIGN_KEY,
        DATA_COLUMN
    };

    //Database connection parameters and values
    struct DBQOP_STRUCT_EXPORT DBConnection
    {
        DBConnection();
        DBConnection(const DBConnection& other);
        ~DBConnection();
        DBConnection& operator=(const DBConnection& rhs);
        SQLHENV     environment_handle;//Environment handle
        SQLHDBC     database_connection_handle;//Database connection handle
        bool        environment_handle_allocated;
        bool        connection_handle_allocated;
        bool        sql_command_prepared;
        bool        asynch_support;
        bool        is_connected;
        bool        is_open;
        int         flag;
        std::string connection_string;
        std::string output_connection_string;
        std::string server_string;
        std::string user_string;
        std::string password_string;
        std::string last_message;
    };
    struct DBQOP_STRUCT_EXPORT DBColumn
    {
        DBColumn();
        ~DBColumn();
        explicit DBColumn(const short& new_column_type,const long& buffer_length);
        DBColumn(const DBColumn& other);
        DBColumn& operator=(const DBColumn& rhs);
        brw::Archive& operator&(brw::Archive& ar);
        uintptr_t table_owner;
        short     column_type;
        short     catalog_name_length;
        short     schema_name_length;
        short     table_name_length;
        short     column_name_length;
        short     column_type_name_length;
        long      data_length_indicator;
        long      column_buffer_length;//Max byte length of the column
        SQLCHAR   catalog_name[SQL_MAX_CATALOG_NAME_LEN];
        SQLCHAR   schema_name[SQL_MAX_SCHEMA_NAME_LEN];
        SQLCHAR   table_name[SQL_MAX_TABLE_NAME_LEN];
        SQLCHAR   column_name[SQL_MAX_COLUMN_NAME_LEN];
        SQLCHAR   column_type_name[MAX_COL_TYPE_NAME_LENGTH];
        PSQLCHAR  column_buffer;
    };
    struct DBKeyColumn
    {
        SQLCHAR     key_catalog_name[SQL_MAX_CATALOG_NAME_LEN];
        SQLCHAR     key_schema_name[SQL_MAX_SCHEMA_NAME_LEN];
        SQLCHAR     key_table_name[SQL_MAX_TABLE_NAME_LEN];
        SQLCHAR     key_column_name[SQL_MAX_COLUMN_NAME_LEN];
        SQLSMALLINT key_ordinal;
        SQLCHAR     key_name[SQL_MAX_COLUMN_NAME_LEN];
        SQLSMALLINT key_catalog_name_length;
        SQLSMALLINT key_schema_name_length;
        SQLSMALLINT key_table_name_length;
        SQLSMALLINT key_column_name_length;
        SQLSMALLINT key_name_length;
    };
    struct DBQOP_STRUCT_EXPORT DBRow
    {
    public:
        DBRow();
        DBRow(const DBRow& other);
        explicit DBRow(const uintptr_t& row_table_owner,const UINT& new_row_index);
        DBRow& operator=(const DBRow& rhs);
        ~DBRow();
        uintptr_t table_owner;
        UINT      row_index;
        void*     getValue(const short& column_index) const;
        void      getValue(const short& column_index,CellData& value) const;
        void      setValue(const short& column_index,void* value) const;
        void      setValue(const short& column_index,const CellData& value);
        DBRow     cloneRow() const;
    private:
        RowData   row_data;
    };
    struct DBQOP_STRUCT_EXPORT DBTable
    {
    public:
        DBTable();
        ~DBTable();
        explicit DBTable(const short& new_total_columns,DBColumn* new_table_columns);
        DBTable(const DBTable& other);
        DBTable& operator=(const DBTable& rhs);
        brw::Archive& operator&(brw::Archive& ar);
        std::string sql_statement;
        std::string database_name;
        std::string catalog_name;
        std::string schema_name;
        std::string table_name;
        short       total_columns;
        short       total_primary_key_columns;
        short       total_foreign_key_columns;
        short*      primary_key_columns;//Ordinals in zero based index
        short*      foreign_key_columns;//Ordinals in zero based index
        UINT        total_rows;
        DBColumn*   table_columns;
        DBRow       newRow() const;
        DBRow       getRow(const UINT& row_index) const;
        void        addRow(UINT& new_row_index);
        void        addRow(const DBRow& new_row);
        void*       getValue(const UINT& row_index,const short& column_index) const;
        void getValue
            (
                const UINT& row_index,
                const short& column_index,
                CellData& value
            ) const;
        void setValue
            (
                const UINT& row_index,
                const short& column_index,
                void* value,
                const long& value_length=1
            );
        void setValue
            (
                const UINT& row_index,
                const short& column_index,
                const CellData& value
            );
        template<typename T>
        T getValue(const UINT& row_index,const short& column_index)
        {
            T value;
            T* value_ptr=reinterpret_cast<T*>(getValue(row_index,column_index));
            if(value_ptr)
            {
                value=*value_ptr;
            }
            return value;
        }
        bool findRow
            (
                const short& key_column_index,
                const CellData& value,
                const UINT& starting_row_index,
                DBRow& row
            );/*Binary search for a complete match value*/
        bool findRowPattern
            (
                const short& key_column_index,
                const std::string& value,
                const UINT& starting_row_index,
                DBRow& row
            ) const;/*String search with pattern*/
        bool getPrimaryKeys
            (
                short*& primary_keys,
                short& total_primary_keys,
                std::string& message
            );
        bool getForeignKeys
            (
                short*& foreign_keys,
                short& total_foreign_keys,
                std::string& message
            );

        DBTable cloneTable();//Clone table schema and data
        DBTable cloneSchema();//Just for cloning table schema
        DBTable getSubTable
            (
                const short columns_indices[],
                const short& total_sub_columns
            );
        void splitPKFKDC
            (
                DBTable& primary_keys,
                DBTable& foreign_keys,
                DBTable& data_columns,
                bool& has_primary_keys,
                bool& has_foreign_keys
            );
        friend SQLHSTMT& getStatementHandle(DBTable& table);
        friend void      setStatementHandle(DBTable& table,const SQLHSTMT handle);

    private:
        SQLHSTMT  statement_handle;//Statement handle
        TableData table_data;
        bool      is_primary_keys_set;
        bool      is_foreign_keys_set;
    };
    struct DBQOP_STRUCT_EXPORT DBDataSet
    {
        DBDataSet();
        explicit DBDataSet
            (
                const std::string& sql_statement,
                const std::string& driver,
                const std::string& server,
                const std::string& user,
                const std::string& password
            );
        ~DBDataSet();
        DBConnection                   data_connection;
        std::vector<DBTable>           data_tables;
        std::vector<DBTable>::iterator begin();
        std::vector<DBTable>::iterator end();
        int                            total_data_tables;
    };
    struct DBDataRelation
    {
        DBTable* table;
        short    column_ordinal;
    };

    //METHODS THE CONNECTION ARGUMENT WILL HOLD THE OUTPUT MESSAGE IN CASE
    //OF ERROR OR WARNING
    DBQOP_ATTRS
    bool DBConnect
        (
            DBConnection& connection,
            const std::string& driver,
            const std::string& server,
            const std::string& user,
            const std::string& password
        );

    DBQOP_ATTRS
    bool DBDisconnect(DBConnection& connection);

    DBQOP_ATTRS
    VECSTR DBGetDrivers(DBConnection& connection);

    DBQOP_ATTRS
    VECSTR DBGetDataSources(DBConnection& connection);

    DBQOP_ATTRS
    bool DBSelect
        (
            DBConnection& connection,
            const std::string& sqlcmd,
            DBTable& select_table
        );

    DBQOP_ATTRS
    bool DBInsert
        (
            DBConnection& connection,
            const std::string& sqlcmd,
            const DBTable& rows_to_insert,
            DBTable& rows_rejected
        );

    DBQOP_ATTRS
    bool DBUpdate
        (
            DBConnection& connection,
            const std::string& sqlcmd,
            const DBTable& rows_to_update,
            const DBTable& primary_keys_values,
            DBTable& rows_rejected
        );

    DBQOP_ATTRS
    bool DBDelete
        (
            DBConnection& connection,
            const std::string& sqlcmd,
            const DBTable& primary_keys_values,
            DBTable& rows_rejected
        );

    DBQOP_ATTRS
    bool DBGetPrimaryKeys
        (
            DBTable& table,
            DBKeyColumn*& primary_keys,
            short& total_primary_keys,
            std::string& message
        );

    DBQOP_ATTRS
    bool DBGetForeignKeys
        (
            DBTable& table,
            DBKeyColumn*& foreign_keys,
            short& total_foreign_keys,
            std::string& message
        );

    DBQOP_ATTRS
    bool DBTransaction(const std::string& sqlcmd,std::string& message);

    DBQOP_ATTRS
    short DBGetNumberOfColumns(SQLHSTMT& statement_handle);//Statement handle must be prepared or executed

    DBQOP_ATTRS
    UINT DBGetNumberOfRows(SQLHSTMT& statement_handle);//Statement handle must be prepared or executed

    DBQOP_ATTRS
    std::string DBGetErrorMsg(SQLHANDLE handle,SQLSMALLINT handle_type);

    DBQOP_ATTRS
    std::string GetSQLTypeName(const short sql_type_id,bool& is_type_variable);

//==========================================================================================
//METHODS FOR INTEROPERABILITY WITH EXCEL AND LIBREOFFICE MACROS
    DBQOP_ATTRS DBQOP_DTS_ATTRS
    bool DTSDBConnect
        (
            const char*& driver,
            const char*& server,
            const char*& user,
            const char*& password
        );

    DBQOP_ATTRS DBQOP_DTS_ATTRS
    bool DTSDBDisconnect();

    DBQOP_ATTRS DBQOP_DTS_ATTRS
    bool DTSDBSelect(const char*& sqlcmd);

    DBQOP_ATTRS DBQOP_DTS_ATTRS
    bool DTSDBInsert(const char*& sqlcmd);

    DBQOP_ATTRS DBQOP_DTS_ATTRS
    bool DTSDBUpdate(const char*& sqlcmd);

    DBQOP_ATTRS DBQOP_DTS_ATTRS
    bool DTSDBDelete(const char*& sqlcmd);

    DBQOP_ATTRS DBQOP_DTS_ATTRS
    void DTSDBSetColumnIndex(const short& index);

    DBQOP_ATTRS DBQOP_DTS_ATTRS
    int DTSDBGetColumnType(const short& index);




#ifdef BUILD_DBQOP
//==========================================================================================
    //VERY IMPORTANT VARIABLES THAT ARE GOING TO BE USED AS A BUFFER
    //TO HOLD VARIABLE DATA ON FETCHING
    static RowData sql_cmd_buffer;
//==========================================================================================

//==========================================================================================
    //VERY IMPORTANT VARIABLES THAT ARE GOING TO BE USED WITH DATASHEET APPLICATIONS
    static DBConnection dts_connection;
    static DBTable      dts_select_table;
    static DBTable      dts_rows_to_insert;
    static DBTable      dts_rows_to_update;
    static DBTable      dts_primary_keys_values;
    static DBTable      dts_rows_rejected;
    static short        dts_current_column_index;
//==========================================================================================



    static
    bool DBGetColumnsAndBind
        (
            DBConnection& connection,
            SQLHSTMT& statement_handle,
            const short& total_columns,
            DBColumn*& columns
        );

    static
    bool DBBindInsertParameters
        (
            DBConnection& connection,
            SQLHSTMT& statement_handle,
            const short& total_columns,
            DBColumn*& columns
        );

    static
    bool DBBindUpdateParameters
        (
            DBConnection& connection,
            SQLHSTMT& statement_handle,
            const short& total_data_columns,
            const short& total_primary_keys,
            DBColumn*& data_columns,
            DBColumn*& primary_keys
        );

    static
    bool DBBindDeleteParameters
        (
            DBConnection& connection,
            SQLHSTMT& statement_handle,
            const short& total_primary_keys,
            DBColumn*& primary_keys
        );

    static
    bool DBPrepareSelect
        (
            DBConnection& connection,
            SQLHSTMT& statement_handle,
            const std::string& sqlcmd
        );

    static
    bool DBPrepareInsert
        (
            DBConnection& connection,
            SQLHSTMT& statement_handle,
            const std::string& sqlcmd
        );

    static
    bool DBPrepareUpdate
        (
            DBConnection& connection,
            SQLHSTMT& statement_handle,
            const std::string& sqlcmd
        );

    static
    bool DBPrepareDelete
        (
            DBConnection& connection,
            SQLHSTMT& statement_handle,
            const std::string& sqlcmd
        );


#endif // BUILD_DBQOP

}//odbc_database_operations namespace

}//canonbit_databases namespace

#endif // DBQOP_H