#include <cstdio>
#include <cstring>
#include <cstring>
#include <trantor/utils/Logger.h>
#include <helpers.h>
#include "controller_dbo.h"
#include "globals.h"

static bool controller_db_update_insert(controller_dbo *controller, sqlite3_stmt *stmt)
{
    int rc;

    sqlite3_bind_text(stmt, 1, controller->id, -1, SQLITE_STATIC);
    sqlite3_bind_text(stmt, 2, controller->name, -1, SQLITE_STATIC);
    sqlite3_bind_text(stmt, 3, controller->ip, -1, SQLITE_STATIC);
    sqlite3_bind_int(stmt, 4, controller->active);
    sqlite3_bind_int(stmt, 5, controller->port);
    sqlite3_bind_int(stmt, 6, controller->relay_count);

    rc = sqlite3_step(stmt);
    if (rc != SQLITE_DONE)
    {
        printf("ERROR inserting data: %s\n", sqlite3_errmsg(globals::db));
        return false;
    }

    sqlite3_finalize(stmt);

    return true;
}

static controller_dbo*
controller_db_select_mapper(sqlite3_stmt *stmt)
{
    auto *new_controller = new controller_dbo();
    for(int i = 0; i < sqlite3_column_count(stmt); i++)
    {
        const char *name = sqlite3_column_name(stmt, i);
        switch(name[0])
        {
            case 'a': // active
                new_controller->active = (bool)sqlite3_column_int(stmt, i);
                break;
            case 'i':
                switch(name[1])
                {
                    case 'd': // id
                        strncpy(new_controller->id, (const char*)sqlite3_column_text(stmt, i), 32);
                        break;
                    case 'p': // ip
                        strncpy(new_controller->ip, (const char*)sqlite3_column_text(stmt, i), 16);
                        break;
                    default: // ignore columns not implemented
                        break;
                }
                break;
            case 'n': // name
                strncpy(new_controller->name, (const char*)sqlite3_column_text(stmt, i), 127);
                break;
            case 'p': // port
                new_controller->port = sqlite3_column_int(stmt, i);
                break;
            case 'r': // relay_count
                new_controller->relay_count = sqlite3_column_int(stmt, i);
                break;
            default: // ignore columns not implemented
                break;
        }
    }
    return new_controller;
}

static controller_dbo**
controller_db_select(sqlite3_stmt *stmt)
{
    auto **all_controllers = (controller_dbo**)malloc(sizeof(controller_dbo*));

    int row = 0;

    while(true)
    {
        int s;

        s = sqlite3_step(stmt);
        if (s == SQLITE_ROW)
        {
            controller_dbo *new_controller = controller_db_select_mapper(stmt);
            row++;

            all_controllers = (controller_dbo**)realloc(all_controllers, sizeof(controller_dbo*) * (row + 1));
            all_controllers[row - 1] = new_controller;
        }
        else
        {
            if (s == SQLITE_DONE)
            {
                break;
            }
            else
            {
                LOG_ERROR << "Error Selecting controllers from database";
                sqlite3_finalize(stmt);
                return nullptr;
            }
        }
    }

    sqlite3_finalize(stmt);
    all_controllers[row] = nullptr;

    return all_controllers;
}

bool
controller_dbo::update()
{
    sqlite3_stmt *stmt;

    sqlite3_prepare_v2(globals::db, "UPDATE controllers set name = ?2, ip = ?3, active = ?4, port = ?5, relay_count = ?6 WHERE id = ?1;", -1, &stmt, nullptr);

    return controller_db_update_insert(this, stmt);
}

bool
controller_dbo::insert()
{
    sqlite3_stmt *stmt;

    sqlite3_prepare_v2(globals::db, "INSERT INTO controllers(id, name, ip, active, port, relay_count) values (?1, ?2, ?3, ?4, ?5, ?6);", -1, &stmt, nullptr);

    return controller_db_update_insert(this, stmt);
}

bool
controller_dbo::remove()
{
    sqlite3_stmt *stmt;
    int rc;

    sqlite3_prepare_v2(globals::db, "DELETE FROM controllers WHERE id=?1;", -1, &stmt, nullptr);
    sqlite3_bind_text(stmt, 1, this->id, -1, SQLITE_STATIC);
    rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);

    return rc == SQLITE_DONE;

}

Json::Value
controller_dbo::to_json()
{
    Json::Value controller_json;
    controller_json["name"] = this->name;
    controller_json["id"] = this->id;
    controller_json["ip"] = this->ip;
    controller_json["port"] = this->port;
    controller_json["relay_count"] = this->relay_count;
    controller_json["active"] = this->active;

    return controller_json;
}

controller_dbo**
controller_dbo::get_all()
{
    sqlite3_stmt *stmt;

    sqlite3_prepare_v2(globals::db, "SELECT * FROM controllers;", -1, &stmt, nullptr);

    return controller_db_select(stmt);
}

controller_dbo**
controller_dbo::get_by_simple(const char *key, const void *value, intptr_t bind_func)
{
    helpers::sql_filter_builder *filters[1];
    helpers::sql_filter_builder filter
            {
                    key,
                    value,
                    bind_func,
                    ";"
            };
    filters[0] = &filter;
    sqlite3_stmt *stmt = helpers::create_sql_filtered_query("SELECT * FROM controllers WHERE", filters);

    return controller_db_select(stmt);
}

controller_dbo**
controller_dbo::get_by(helpers::sql_filter_builder **filters)
{
    sqlite3_stmt *stmt = helpers::create_sql_filtered_query("SELECT * FROM controllers WHERE", filters);

    return controller_db_select(stmt);
}

void
controller_dbo::free_list(controller_dbo **controllers_list)
{
    for(int i = 0; controllers_list[i] != nullptr; i++)
    {
        free(controllers_list[i]);
    }
    free(controllers_list);
}