#include "blueprint.hpp"

#include <cppbase/logger.hpp>
#include <cppbase/result.hpp>
#include <cppbase/strings.hpp>

#include <ikarus/objects/blueprint.h>
#include <ikarus/objects/entity.h>
#include <ikarus/objects/object_type.h>

#include <id.hpp>
#include <objects/entity.hpp>
#include <objects/property.hpp>
#include <persistence/project.hpp>

IkarusBlueprint * ikarus_blueprint_create(struct IkarusProject * project, char const * name) {
    LOG_INFO("creating new blueprint");

    if (project == nullptr) {
        LOG_ERROR("project is nullptr");
        return nullptr;
    }

    auto ctx = project->function_context();

    if (name == nullptr) {
        ctx->set_error("name is nullptr", true, IkarusErrorInfo_Source_Client, IkarusErrorInfo_Type_Client_Input);
        return nullptr;
    }

    if (cppbase::is_empty_or_blank(name)) {
        ctx->set_error("name is empty or blank", true, IkarusErrorInfo_Source_Client, IkarusErrorInfo_Type_Client_Input);
        return nullptr;
    }

    LOG_VERBOSE("project={}; name={}", project->path().c_str(), name);

    VTRYRV(
        auto id,
        nullptr,
        project->db()
            ->transact([name](auto * db) -> cppbase::Result<IkarusId, sqlitecpp::TransactionError> {
                LOG_VERBOSE("creating blueprint in objects table");

                TRY(db->execute(
                    "INSERT INTO `objects` (`object_type`, `name`) VALUES(?, ?);",
                    static_cast<int>(IkarusObjectType_Blueprint),
                    name
                ));

                auto id = db->last_insert_rowid();

                LOG_VERBOSE("id is {}", id);

                LOG_VERBOSE("inserting blueprint into blueprints table");

                TRY(db->execute("INSERT INTO `blueprints`(`id`) VALUES(?);", id));

                return cppbase::ok(id);
            })
            .on_error([ctx](auto const& err) {
                ctx->set_error(
                    fmt::format("unable to insert blueprint into database: {}", err),
                    true,
                    IkarusErrorInfo_Source_SubSystem,
                    IkarusErrorInfo_Type_SubSystem_Database
                );
            })
    );

    LOG_VERBOSE("successfully created blueprint");

    return project->get_blueprint(id);
}

void ikarus_blueprint_delete(IkarusBlueprint * blueprint) {
    LOG_INFO("deleting blueprint");

    if (blueprint == nullptr) {
        LOG_ERROR("blueprint is nullptr");
        return;
    }

    auto * ctx = blueprint->project->function_context();

    LOG_VERBOSE("blueprint={}", blueprint->id);

    TRYRV(
        ,
        blueprint->project->db()
            ->execute("DELETE FROM `objects` WHERE `id` = ?", blueprint->id)
            .on_error([ctx](auto const& err) {
                ctx->set_error(
                    fmt::format("failed to delete blueprint from objects table: {}", err),
                    true,
                    IkarusErrorInfo_Source_SubSystem,
                    IkarusErrorInfo_Type_SubSystem_Database
                );
            })
    );

    LOG_VERBOSE("blueprint was successfully deleted from database, freeing blueprint");

    blueprint->project->remove_blueprint(blueprint);

    LOG_VERBOSE("successfully deleted blueprint");
}

size_t ikarus_blueprint_get_property_count(IkarusBlueprint const * blueprint) {
    LOG_VERBOSE("fetching blueprint property count");

    if (blueprint == nullptr) {
        LOG_ERROR("blueprint is nullptr");
        return 0;
    }

    auto * ctx = blueprint->project->function_context();

    LOG_VERBOSE("blueprint={}", blueprint->id);

    VTRYRV(
        auto count,
        0,
        blueprint->project->db()
            ->query_one<int>("SELECT COUNT(*) FROM `blueprint_properties` WHERE `blueprint_id` = ?;", blueprint->id)
            .on_error([ctx](auto const& err) {
                ctx->set_error(
                    fmt::format("failed to fetch blueprint property count: {}", err),
                    true,
                    IkarusErrorInfo_Source_SubSystem,
                    IkarusErrorInfo_Type_SubSystem_Database
                );
            })
    );

    return static_cast<size_t>(count);
}

void ikarus_blueprint_get_properties(
    IkarusBlueprint const * blueprint, struct IkarusProperty ** properties_out, size_t properties_out_size
) {
    LOG_VERBOSE("fetching blueprint properties");

    if (blueprint == nullptr) {
        LOG_ERROR("blueprint is nullptr");
        return;
    }

    auto * ctx = blueprint->project->function_context();

    if (properties_out == nullptr) {
        LOG_ERROR("properties_out is nullptr");
        return;
    }

    LOG_VERBOSE("blueprint={}; properties_out_size={}", blueprint->id, properties_out_size);

    IkarusId ids[properties_out_size];

    TRYRV(
        ,
        blueprint->project->db()
            ->query_many_buffered<IkarusId>(
                "SELECT `id` FROM `properties` WHERE `source` = ?",
                static_cast<IkarusId *>(ids),
                properties_out_size,
                blueprint->id
            )
            .on_error([ctx](auto const& err) {
                ctx->set_error(
                    fmt::format("failed to fetch blueprint property ids: {}", err),
                    true,
                    IkarusErrorInfo_Source_SubSystem,
                    IkarusErrorInfo_Type_SubSystem_Database
                );
            })
    );

    for (size_t i = 0; i < properties_out_size; ++i) {
        /// NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
        properties_out[i] = blueprint->project->get_property(ids[i]);
    }

    LOG_VERBOSE("successfully fetched blueprint properties");
}