#include <cassert>
#include <cstdio>
#include <cstring>
#include <memory>

#include <cstdlib>

#include "sqdb.hpp"

#include <unistd.h>

using namespace sqdb;

Exception::Exception(sqlite3* db)
{
    m_errorCode = sqlite3_errcode(db);
    auto* c = (SQDB_CHAR*)
#ifdef SQDB_UTF8
            sqlite3_errmsg
#else
            sqlite3_errmsg16
#endif
                    (db);
    m_errorMsg = SQDB_STRDUP(c);
}

Exception::Exception(sqlite3* db, int errorCode)
        : m_errorCode(errorCode)
{
    auto* c = (SQDB_CHAR*)
#ifdef SQDB_UTF8
            sqlite3_errmsg
#else
            sqlite3_errmsg16
#endif
                    (db);
    m_errorMsg = SQDB_STRDUP(c);
}

Exception::Exception(const SQDB_CHAR* errorMsg)
        : m_errorCode(-1)
{
    m_errorMsg = SQDB_STRDUP(errorMsg);
}

Exception::~Exception()
{
    free(m_errorMsg);
}

int Exception::GetErrorCode() const
{
    return m_errorCode;
}

const SQDB_CHAR* Exception::GetErrorMsg() const
{
    return m_errorMsg;
}

RefCount::RefCount()
        : m_refCount(nullptr)
{
}

RefCount::RefCount(const RefCount& x)
        : m_refCount(x.m_refCount)
{
}

RefCount& RefCount::operator=(const RefCount& x)
{
    if ( this != &x )
    {
        m_refCount = x.m_refCount;
    }
    return *this;
}

void RefCount::IncRef()
{
    if ( !m_refCount )
    {
        m_refCount = new unsigned;
        *m_refCount = 0;
    }
    ++*m_refCount;
}

unsigned RefCount::DecRef()
{
    assert(m_refCount);
    unsigned value = --*m_refCount;
    if ( value == 0 )
    {
        delete m_refCount;
        m_refCount = nullptr;
    }
    return value;
}

Blob::Blob(const void* data, int size)
        : m_size(size)
{
    m_data = new char[size];
    std::uninitialized_copy((char*)data, (char*)data + size, m_data);
    IncRef();
}

Blob::Blob(const Blob& x)
        : RefCount(x), m_data(x.m_data), m_size(x.m_size)
{
    IncRef();
}

Blob& Blob::operator=(const Blob& x)
{
    if ( this != &x )
    {
        RefCount::operator=(x);
        IncRef();
        m_data = x.m_data;
        m_size = x.m_size;
    }
    return *this;
}

int Blob::GetSize() const
{
    return m_size;
}

const char* Blob::GetData() const
{
    return m_data;
}

Blob::~Blob()
{
    if ( DecRef() == 0 )
    {
        delete[] m_data;
    }
}

Convertor::Convertor(sqlite3* db, sqlite3_stmt* stmt, int field)
        : m_db(db), m_stmt(stmt), m_field(field)
{
}

Convertor::operator int() const
{
    return GetInt();
}

Convertor::operator unsigned long() const
{
    return GetUnsignedLong();
}

Convertor::operator long long() const
{
    return GetLongLong();
}

Convertor::operator double() const
{
    return GetDouble();
}

Convertor::operator SQDB_STD_STRING() const
{
    return GetString();
}

Convertor::operator const SQDB_CHAR*() const
{
    return GetText();
}

Convertor::operator Blob() const
{
    return GetBlob();
}

int Convertor::GetInt() const
{
    assert(m_stmt);
    return sqlite3_column_int(m_stmt, m_field);
}

unsigned long Convertor::GetUnsignedLong() const
{
    assert(m_stmt);
    const char* data = (char*) sqlite3_column_blob(m_stmt, m_field);
    return strtoul(data, nullptr, 10);
}

long long Convertor::GetLongLong() const
{
    assert(m_stmt);
    return sqlite3_column_int64(m_stmt, m_field);
}

double Convertor::GetDouble() const
{
    assert(m_stmt);
    return sqlite3_column_double(m_stmt, m_field);
}

SQDB_STD_STRING Convertor::GetString() const
{
    assert(m_stmt);
    const auto* result = (const SQDB_CHAR*)
#ifdef SQDB_UTF8
            sqlite3_column_text
#else
            sqlite3_column_text16
#endif
                    (m_stmt, m_field);
    return result;
}

const SQDB_CHAR* Convertor::GetText() const
{
    assert(m_stmt);
    const auto* result = (const SQDB_CHAR*)
#ifdef SQDB_UTF8
            sqlite3_column_text
#else
            sqlite3_column_text16
#endif
                    (m_stmt, m_field);
    return result;
}

Blob Convertor::GetBlob() const
{
    assert(m_stmt);
    const void* data = sqlite3_column_blob(m_stmt, m_field);
    int size = sqlite3_column_bytes(m_stmt, m_field);
    return Blob(data, size);
}

Statement::Statement(sqlite3* db, sqlite3_stmt* stmt)
        : RefCount(), m_db(db), m_stmt(stmt), m_needReset(false)
{
    IncRef();
}

Statement::Statement(const Statement& x)
        : RefCount(x), m_db(x.m_db), m_stmt(x.m_stmt), m_needReset(false)
{
    IncRef();
}

Statement& Statement::operator=(const Statement& x)
{
    if ( this != &x )
    {
        RefCount::operator=(x);
        IncRef();
        m_db = x.m_db;
        m_stmt = x.m_stmt;
        m_needReset = x.m_needReset;
    }
    return *this;
}

bool Statement::Next() {
    assert(m_stmt);
    int ret = SQLITE_BUSY;

    while (ret == SQLITE_BUSY) {
        ret = sqlite3_step(m_stmt);
        m_needReset = true;
        if ( ret == SQLITE_DONE ) {
            return false;
        } else if ( ret == SQLITE_ROW ) {
            return true;
        } else if ( ret == SQLITE_BUSY ) {
            sleep(1);
            continue;
        } else {
            throw Exception(m_db, ret);
        }
    }
    return false;
}

Convertor Statement::GetField(int field) const
{
    return {m_db, m_stmt, field};
}

Statement::~Statement()
{
    if ( DecRef() == 0 )
    {
        sqlite3_finalize(m_stmt);
    }
}

void Statement::BindBlob(int i, const void* value, int n)
{
    if ( m_needReset )
        Reset();
    DoBind(i, value, n);
}

void Statement::BindNull(int i)
{
    if ( m_needReset )
        Reset();
    DoBind(i);
}

void Statement::DoBind(int i, int value)
{
    const int ret = sqlite3_bind_int(m_stmt, i, value);
    CHECK(m_db, ret);
}

void Statement::DoBind(int i, long long value)
{
    const int ret = sqlite3_bind_int64(m_stmt, i, value);
    CHECK(m_db, ret);
}

void Statement::DoBind(int i, double value)
{
    const int ret = sqlite3_bind_double(m_stmt, i, value);
    CHECK(m_db, ret);
}

void Statement::DoBind(int i, const SQDB_STD_STRING& value)
{
    const int ret =
#ifdef SQDB_UTF8
            sqlite3_bind_text
#else
            sqlite3_bind_text16
#endif
                    (m_stmt, i, value.c_str(), value.size() * sizeof(SQDB_STD_STRING::value_type), SQLITE_TRANSIENT);
    CHECK(m_db, ret);
}

void Statement::DoBind(int i, const SQDB_CHAR* value)
{
    const int len = SQDB_STRLEN(value);

    const int ret =
#ifdef SQDB_UTF8
            sqlite3_bind_text
#else
            sqlite3_bind_text16
#endif
                    (m_stmt, i, value, len * sizeof(SQDB_CHAR), SQLITE_TRANSIENT);

    CHECK(m_db, ret);
}

void Statement::DoBind(int i, const void* value, int n)
{
    const int ret = sqlite3_bind_blob(m_stmt, i, value, n, SQLITE_TRANSIENT);
    CHECK(m_db, ret);
}

void Statement::DoBind(int i)
{
    const int ret = sqlite3_bind_null(m_stmt, i);
    CHECK(m_db, ret);
}

void Statement::Reset()
{
    assert(m_needReset);
    assert(m_stmt);

    sqlite3_reset(m_stmt);
    m_needReset = false;
}

QueryStr::QueryStr()
        : m_buf(nullptr)
{
}

const SQDB_CHAR* QueryStr::Format(const SQDB_CHAR* fmt, ...)
{
    va_list va;
    va_start(va, fmt);
#ifdef SQDB_UTF8
    sqlite3_free(m_buf);
  m_buf = sqlite3_vmprintf(fmt, va);
#else
    free(m_buf);
    int len = _vscwprintf(fmt, va) + 1;
    m_buf = (SQDB_CHAR*)malloc(len * sizeof(SQDB_CHAR));
    vswprintf(m_buf, len, fmt, va);
#endif

    va_end(va);

    return m_buf;
}

const SQDB_CHAR* QueryStr::Get() const
{
    return m_buf;
}

QueryStr::~QueryStr()
{
#ifdef SQDB_UTF8
    sqlite3_free(m_buf);
#else
    free(m_buf);
#endif
}

Db::Db(const SQDB_CHAR* fileName)
        : RefCount()
{
#ifdef SQDB_UTF8
    const int ret = sqlite3_open(fileName, &m_db);
#else
    const int ret = sqlite3_open16(fileName, &m_db);
#endif
    CHECK(m_db, ret);

    IncRef();
}

void Db::BeginTransaction()
{
    Query(SQDB_MAKE_TEXT("BEGIN;")).Next();
}

void Db::CommitTransaction()
{
    Query(SQDB_MAKE_TEXT("COMMIT;")).Next();
}

void Db::RollbackTransaction()
{
    Query(SQDB_MAKE_TEXT("ROLLBACK;")).Next();
}

bool Db::TableExists(const SQDB_CHAR* tableName)
{
    QueryStr str;
    Statement s =
            Query(
                    str.Format(SQDB_MAKE_TEXT("select count(*) from sqlite_master where type='table' and name='%s';"), tableName));
    s.Next();
    const int count = s.GetField(0);
    return count > 0;
}

Statement Db::Query(const SQDB_CHAR* queryStr)
{
    sqlite3_stmt* stmt = nullptr;
#ifdef SQDB_UTF8
    const int ret = sqlite3_prepare(m_db, queryStr, -1, &stmt, nullptr);
#else
    const int ret = sqlite3_prepare16(m_db, queryStr, -1, &stmt, NULL);
#endif
    CHECK(m_db, ret);

    return Statement(m_db, stmt);
}

long long Db::LastId()
{
    long long ret = sqlite3_last_insert_rowid(m_db);
    return ret;
}

Db::Db(const Db& x)
        : RefCount(x),
          m_db(x.m_db)
{
    IncRef();
}

Db& Db::operator=(const Db& x)
{
    if ( this != &x )
    {
        RefCount::operator=(x);

        IncRef();
        m_db = x.m_db;
    }
    return *this;
}

Db::~Db()
{
    if ( DecRef() == 0 )
    {
        sqlite3_close(m_db);
    }
}