#pragma once

#include <string>

#include "sqlite3.h"

#ifdef _WIN32
#  include <tchar.h>
#  define SQDB_MAKE_TEXT(x) _TEXT(x)
#  define SQDB_STRLEN _tcslen
#  define SQDB_STRDUP _tcsdup
#else
#  define SQDB_MAKE_TEXT(x) (x)
#  define SQDB_STRLEN strlen
#  define SQDB_STRDUP strdup
#endif

#if !defined(SQDB_UTF16) && !defined(SQDB_UTF8)
#  ifdef _WIN32
#    if defined(UNICODE) || defined(_UNICODE)
#      define SQDB_UTF16
#    else
#      define SQDB_UTF8
#    endif
#  else
#    define SQDB_UTF8
#  endif
#endif

#ifdef SQDB_UTF8
#  define SQDB_CHAR char
#  define SQDB_STD_STRING std::string
#endif

#ifdef SQDB_UTF16
#  define SQDB_CHAR TCHAR
#  define SQDB_STD_STRING std::wstring
#endif

namespace sqdb
{

    class Exception
    {
    public:
        Exception(sqlite3* db);

        Exception(sqlite3* db, int errorCode);

        Exception(const SQDB_CHAR* errorMsg);

        ~Exception();

        int GetErrorCode() const;

        const SQDB_CHAR* GetErrorMsg() const;
    private:
        int m_errorCode;
        SQDB_CHAR* m_errorMsg;
    };

#define CHECK(db, returnCode) \
  if ( (returnCode) != SQLITE_OK ) throw Exception(db, returnCode)

    class RefCount
    {
    protected:
        RefCount();

        RefCount(const RefCount& x);
        RefCount& operator=(const RefCount& x);

        void IncRef();
        unsigned DecRef();

    private:
        unsigned* m_refCount;
    };

    class Blob : public RefCount
    {
    public:
        Blob(const void* data, int size);

        Blob(const Blob& x);
        Blob& operator=(const Blob& x);

        int GetSize() const;
        const char* GetData() const;

        ~Blob();

    private:
        char* m_data;
        int m_size;
    };

    class Convertor
    {
    public:
        Convertor(sqlite3* db, sqlite3_stmt* stmt, int field);

        operator int() const;
        operator unsigned long() const;
        operator long long() const;
        operator double() const;
        operator SQDB_STD_STRING() const;
        operator const SQDB_CHAR*() const;
        operator Blob() const;

        int GetInt() const;
        unsigned long GetUnsignedLong() const;
        long long GetLongLong() const;
        double GetDouble() const;
        SQDB_STD_STRING GetString() const;
        const SQDB_CHAR* GetText() const;
        Blob GetBlob() const;

    private:
        sqlite3* m_db;
        sqlite3_stmt* m_stmt;
        int m_field;
    };

    class Statement : public RefCount
    {
    public:
        Statement(sqlite3* db, sqlite3_stmt* stmt);

        Statement(const Statement& x);
        Statement& operator=(const Statement& x);

        bool Next();
        Convertor GetField(int field) const;

        template<class T>
        void Bind(int i, const T& value)
        {
            if ( m_needReset )
                Reset();
            DoBind(i, value);
        }

        void BindBlob(int i, const void* value, int n);
        void BindNull(int i);

        ~Statement();

    private:
        void DoBind(int i, int value);
        void DoBind(int i, long long value);
        void DoBind(int i, double value);
        void DoBind(int i, const SQDB_STD_STRING& value);
        void DoBind(int i, const SQDB_CHAR* value);

        // Bind blob.
        void DoBind(int i, const void* value, int n);

        // Bind null.
        void DoBind(int i);

        // Reset binders so that new values can be bound.
        void Reset();

        sqlite3* m_db;
        sqlite3_stmt* m_stmt;
        bool m_needReset;
    };

    class QueryStr
    {
    public:
        QueryStr();

        const SQDB_CHAR* Format(const SQDB_CHAR* fmt, ...);

        const SQDB_CHAR* Get() const;

        ~QueryStr();

    private:
        SQDB_CHAR* m_buf;
    };

    class Db : public RefCount
    {
    public:
        Db(const SQDB_CHAR* fileName);

        void BeginTransaction();
        void CommitTransaction();
        void RollbackTransaction();

        bool TableExists(const SQDB_CHAR* tableName);
        Statement Query(const SQDB_CHAR* queryStr);
        long long LastId();

        Db(const Db& x);
        Db& operator=(const Db& x);

        ~Db();

    private:
        sqlite3* m_db;
    };

}