/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements. See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "module.h"
#include "utils.h"

#include <ignite/common/detail/defer.h>

#include <Python.h>

#define LAZY_INIT_MODULE_CLASS(class_name)          \
    static PyObject* instance{nullptr};             \
    if (!instance)                                  \
        instance = py_get_module_class(class_name); \
    return instance


void set_error(const ignite::ignite_error &error) {
    auto error_class = py_get_module_interface_error_class();

    switch (error.get_status_code()) {
        case ignite::error::code::NULLABLE_VALUE:
        case ignite::error::code::CURSOR_ALREADY_CLOSED:
        case ignite::error::code::ILLEGAL_ARGUMENT: {
            error_class = py_get_module_interface_error_class();
            break;
        }

        case ignite::error::code::RESOURCE_CLOSING:
        case ignite::error::code::NODE_LEFT:
        case ignite::error::code::COMPONENT_NOT_STARTED:
        case ignite::error::code::NODE_STOPPING: {
            error_class = py_get_module_database_error_class();
            break;
        }

        case ignite::error::code::SSL_CONFIGURATION:
        case ignite::error::code::USER_OBJECT_SERIALIZATION:
        case ignite::error::code::INTERNAL: {
            error_class = py_get_module_programming_error_class();
            break;
        }

        case ignite::error::code::TABLE_ALREADY_EXISTS:
        case ignite::error::code::TABLE_NOT_FOUND:
        case ignite::error::code::COLUMN_ALREADY_EXISTS:
        case ignite::error::code::COLUMN_NOT_FOUND:
        case ignite::error::code::SCHEMA_VERSION_MISMATCH:
        case ignite::error::code::UNSUPPORTED_PARTITION_TYPE: {
            error_class = py_get_module_programming_error_class();
            break;
        }

        case ignite::error::code::CONNECTION:
        case ignite::error::code::PROTOCOL:
        case ignite::error::code::PROTOCOL_COMPATIBILITY:
        case ignite::error::code::TABLE_ID_NOT_FOUND:
        case ignite::error::code::CONFIGURATION:
        case ignite::error::code::CLUSTER_ID_MISMATCH:
        case ignite::error::code::CLIENT_SSL_CONFIGURATION:
        case ignite::error::code::HANDSHAKE_HEADER:
        case ignite::error::code::SERVER_TO_CLIENT_REQUEST: {
            error_class = py_get_module_operational_error_class();
            break;
        }

        case ignite::error::code::QUERY_NO_RESULT_SET:
        case ignite::error::code::SCHEMA_NOT_FOUND:
        case ignite::error::code::STMT_PARSE:
        case ignite::error::code::STMT_VALIDATION:
        case ignite::error::code::EXECUTION_CANCELLED:
        case ignite::error::code::RUNTIME:
        case ignite::error::code::MAPPING:
        case ignite::error::code::TX_CONTROL_INSIDE_EXTERNAL_TX: {
            error_class = py_get_module_programming_error_class();
            break;
        }

        case ignite::error::code::CONSTRAINT_VIOLATION: {
            error_class = py_get_module_integrity_error_class();
            break;
        }

        case ignite::error::code::STARTING_STORAGE:
        case ignite::error::code::RESTORING_STORAGE:
        case ignite::error::code::COMPACTION:
        case ignite::error::code::OP_EXECUTION:
        case ignite::error::code::OP_EXECUTION_TIMEOUT:
        case ignite::error::code::COMPACTED:
        case ignite::error::code::DIVERGED: {
            error_class = py_get_module_database_error_class();
            break;
        }

        case ignite::error::code::INDEX_NOT_FOUND:
        case ignite::error::code::INDEX_ALREADY_EXISTS: {
            error_class = py_get_module_database_error_class();
            break;
        }

        case ignite::error::code::TX_STATE_STORAGE:
        case ignite::error::code::TX_STATE_STORAGE_STOPPED:
        case ignite::error::code::TX_UNEXPECTED_STATE:
        case ignite::error::code::ACQUIRE_LOCK:
        case ignite::error::code::ACQUIRE_LOCK_TIMEOUT:
        case ignite::error::code::TX_COMMIT:
        case ignite::error::code::TX_ROLLBACK:
        case ignite::error::code::TX_FAILED_READ_WRITE_OPERATION:
        case ignite::error::code::TX_STATE_STORAGE_REBALANCE:
        case ignite::error::code::TX_READ_ONLY_TOO_OLD:
        case ignite::error::code::TX_INCOMPATIBLE_SCHEMA:
        case ignite::error::code::TX_PRIMARY_REPLICA_EXPIRED:
        case ignite::error::code::TX_ALREADY_FINISHED:
        case ignite::error::code::TX_STALE_OPERATION:
        case ignite::error::code::TX_STALE_READ_ONLY_OPERATION:
        case ignite::error::code::TX_ALREADY_FINISHED_WITH_EXCEPTION:
        case ignite::error::code::TX_ALREADY_FINISHED_WITH_TIMEOUT: {
            error_class = py_get_module_database_error_class();
            break;
        }

        case ignite::error::code::REPLICA_COMMON:
        case ignite::error::code::REPLICA_IS_ALREADY_STARTED:
        case ignite::error::code::REPLICA_TIMEOUT:
        case ignite::error::code::REPLICA_UNSUPPORTED_REQUEST:
        case ignite::error::code::REPLICA_UNAVAILABLE:
        case ignite::error::code::REPLICA_MISS:
        case ignite::error::code::CURSOR_CLOSE:
        case ignite::error::code::REPLICA_STOPPING: {
            error_class = py_get_module_database_error_class();
            break;
        }

        case ignite::error::code::INDEX_NOT_BUILT:
        case ignite::error::code::STORAGE_CORRUPTED: {
            error_class = py_get_module_database_error_class();
            break;
        }

        case ignite::error::code::ZONE_NOT_FOUND: {
            error_class = py_get_module_database_error_class();
            break;
        }

        case ignite::error::code::UNRESOLVABLE_CONSISTENT_ID:
        case ignite::error::code::BIND:
        case ignite::error::code::RECIPIENT_LEFT:
        case ignite::error::code::ADDRESS_UNRESOLVED: {
            error_class = py_get_module_database_error_class();
            break;
        }

        case ignite::error::code::CONFIG_READ:
        case ignite::error::code::CONFIG_FILE_CREATE:
        case ignite::error::code::CONFIG_WRITE:
        case ignite::error::code::CONFIG_PARSE: {
            error_class = py_get_module_database_error_class();
            break;
        }

        case ignite::error::code::UNIT_NOT_FOUND:
        case ignite::error::code::UNIT_ALREADY_EXISTS:
        case ignite::error::code::UNIT_CONTENT_READ:
        case ignite::error::code::UNIT_UNAVAILABLE:
        case ignite::error::code::UNIT_ZIP:
        case ignite::error::code::UNIT_WRITE:
        case ignite::error::code::UNIT_NON_UNIQUE_FILENAMES: {
            error_class = py_get_module_database_error_class();
            break;
        }

        case ignite::error::code::CLOSED: {
            error_class = py_get_module_database_error_class();
            break;
        }

        case ignite::error::code::UNSUPPORTED_AUTHENTICATION_TYPE:
        case ignite::error::code::INVALID_CREDENTIALS:
        case ignite::error::code::BASIC_PROVIDER: {
            error_class = py_get_module_database_error_class();
            break;
        }

        case ignite::error::code::CLASS_PATH:
        case ignite::error::code::CLASS_LOADER:
        case ignite::error::code::CLASS_INITIALIZATION:
        case ignite::error::code::QUEUE_OVERFLOW:
        case ignite::error::code::COMPUTE_JOB_STATUS_TRANSITION:
        case ignite::error::code::CANCELLING:
        case ignite::error::code::RESULT_NOT_FOUND:
        case ignite::error::code::FAIL_TO_GET_JOB_STATE:
        case ignite::error::code::COMPUTE_JOB_FAILED:
        case ignite::error::code::PRIMARY_REPLICA_RESOLVE:
        case ignite::error::code::CHANGE_JOB_PRIORITY:
        case ignite::error::code::NODE_NOT_FOUND:
        case ignite::error::code::MARSHALLING_TYPE_MISMATCH:
        case ignite::error::code::COMPUTE_JOB_CANCELLED:
        case ignite::error::code::RESOURCE_NOT_FOUND:
        case ignite::error::code::COMPUTE_PLATFORM_EXECUTOR: {
            error_class = py_get_module_database_error_class();
            break;
        }

        case ignite::error::code::VALIDATION: {
            error_class = py_get_module_database_error_class();
            break;
        }

        case ignite::error::code::PRIMARY_REPLICA_AWAIT_TIMEOUT:
        case ignite::error::code::PRIMARY_REPLICA_AWAIT: {
            error_class = py_get_module_database_error_class();
            break;
        }

        case ignite::error::code::SYSTEM_WORKER_BLOCKED:
        case ignite::error::code::SYSTEM_CRITICAL_OPERATION_TIMEOUT: {
            error_class = py_get_module_database_error_class();
            break;
        }

        case ignite::error::code::ILLEGAL_PARTITION_ID:
        case ignite::error::code::NODES_NOT_FOUND:
        case ignite::error::code::PARTITION_STATE:
        case ignite::error::code::CLUSTER_NOT_IDLE: {
            error_class = py_get_module_database_error_class();
            break;
        }

        case ignite::error::code::CLUSTER_NOT_INITIALIZED:
        case ignite::error::code::CLUSTER_INIT_FAILED:
        case ignite::error::code::NODE_NOT_STARTED:
        case ignite::error::code::NODE_START: {
            error_class = py_get_module_database_error_class();
            break;
        }

        case ignite::error::code::COMMON:
        case ignite::error::code::UNSUPPORTED_OBJECT_TYPE:
        case ignite::error::code::UNMARSHALLING: {
            error_class = py_get_module_not_supported_error_class();
            break;
        }

        case ignite::error::code::CLUSTER_NOT_INIT: {
            error_class = py_get_module_database_error_class();
            break;
        }

        case ignite::error::code::UNSUPPORTED_TABLE_BASED_REPLICATION:
        case ignite::error::code::OPERATION_TIMEOUT:
        case ignite::error::code::TX_DELAYED_ACK:
        case ignite::error::code::GROUP_OVERLOADED:
        case ignite::error::code::GROUP_UNAVAILABLE:
        case ignite::error::code::EMPTY_DATA_NODES:
        case ignite::error::code::JOIN_DENIED:
        case ignite::error::code::EMPTY_ASSIGNMENTS:
        case ignite::error::code::NOT_ENOUGH_ALIVE_NODES:
        case ignite::error::code::ILLEGAL_NODES_SET:
        case ignite::error::code::REQUEST_FORWARD:
        case ignite::error::code::REMOTE_NODE:
        case ignite::error::code::CONFIGURATION_APPLY:
        case ignite::error::code::CONFIGURATION_PARSE:
        case ignite::error::code::CONFIGURATION_VALIDATION: {
            error_class = py_get_module_not_supported_error_class();
            break;
        }
    }
    std::string error_str{error.what_str()};
    if (error.get_java_stack_trace()) {
        error_str += "\n" + *error.get_java_stack_trace();
    }
    PyErr_SetString(error_class, error_str.c_str());
}

std::string get_current_exception_as_string() {
    auto err_obj = PyErr_Occurred();
    if (!err_obj)
        return {};

    auto err_str_obj = PyObject_Str(err_obj);
    if (!err_str_obj)
        return "<Can not cast exception to a string>";

    auto *data = PyBytes_AsString(err_str_obj);
    auto len = PyBytes_Size(err_str_obj);
    return {data, std::size_t(len)};
}

const char* py_object_get_typename(const PyObject* obj) {
    if (!obj || !obj->ob_type || !obj->ob_type->tp_name) {
        return "Unknown";
    }

    return obj->ob_type->tp_name;
}

PyObject* py_get_module() {
    static PyObject* instance{nullptr};
    // No need for sync here - Python is single-threaded
    if (!instance) {
        instance = PyImport_ImportModule(MODULE_NAME);
    }
    return instance;
}

PyObject* py_get_class(const char* module_name, const char* class_name) {
    auto module_obj = PyImport_ImportModule(module_name);
    if (!module_obj)
        return nullptr;

    auto class_obj = PyObject_GetAttrString(module_obj, class_name);
    Py_DECREF(module_obj);

    return class_obj;
}

PyObject* py_get_module_class(const char* class_name) {
    auto pyignite_dbapi_mod = py_get_module();
    if (!pyignite_dbapi_mod)
        return nullptr;

    return PyObject_GetAttrString(pyignite_dbapi_mod, class_name);
}

PyObject* py_call_method_no_arg(PyObject* obj, const char* method_name) {
    PyObject* py_method_name = PyUnicode_FromString(method_name);
    if (!py_method_name)
        return nullptr;
    auto py_method_name_guard = ignite::detail::defer([&]{ Py_DECREF(py_method_name); });

    return PyObject_CallMethodObjArgs(obj, py_method_name, nullptr);
}

std::int64_t py_get_attr_int(PyObject* obj, const char* attr_name) {
    auto attr_obj = PyObject_GetAttrString(obj, attr_name);
    if (!attr_obj) {
        throw ignite::ignite_error(get_current_exception_as_string());
    }
    auto attr_obj_guard = ignite::detail::defer([&] { Py_DECREF(attr_obj); });
    if (PyErr_Occurred()) {
        throw ignite::ignite_error(get_current_exception_as_string());
    }
    auto res = PyLong_AsLongLong(attr_obj);
    if (PyErr_Occurred()) {
        throw ignite::ignite_error(get_current_exception_as_string());
    }
    return res;
}

PyObject* py_get_module_uuid_class() {
    LAZY_INIT_MODULE_CLASS("UUID");
}

PyObject* py_get_module_date_class() {
    LAZY_INIT_MODULE_CLASS("DATE");
}

PyObject* py_get_module_time_class() {
    LAZY_INIT_MODULE_CLASS("TIME");
}

PyObject* py_get_module_datetime_class() {
    LAZY_INIT_MODULE_CLASS("DATETIME");
}

PyObject* py_get_module_timestamp_class() {
    LAZY_INIT_MODULE_CLASS("TIMESTAMP");
}

PyObject* py_get_module_number_class() {
    LAZY_INIT_MODULE_CLASS("NUMBER");
}

PyObject* py_get_module_duration_class() {
    LAZY_INIT_MODULE_CLASS("DURATION");
}

PyObject* py_get_module_warning_class() {
    LAZY_INIT_MODULE_CLASS("Warning");
}

PyObject* py_get_module_interface_error_class() {
    LAZY_INIT_MODULE_CLASS("InterfaceError");
}

PyObject* py_get_module_database_error_class() {
    LAZY_INIT_MODULE_CLASS("DatabaseError");
}

PyObject* py_get_module_data_error_class() {
    LAZY_INIT_MODULE_CLASS("DataError");
}

PyObject* py_get_module_operational_error_class() {
    LAZY_INIT_MODULE_CLASS("OperationalError");
}

PyObject* py_get_module_integrity_error_class() {
    LAZY_INIT_MODULE_CLASS("IntegrityError");
}

PyObject* py_get_module_internal_error_class() {
    LAZY_INIT_MODULE_CLASS("InternalError");
}

PyObject* py_get_module_programming_error_class() {
    LAZY_INIT_MODULE_CLASS("ProgrammingError");
}

PyObject* py_get_module_not_supported_error_class() {
    LAZY_INIT_MODULE_CLASS("NotSupportedError");
}

PyObject* py_create_uuid(ignite::bytes_view bytes) {
    auto uuid_class = py_get_module_uuid_class();
    if (!uuid_class)
        return nullptr;

    auto args = PyTuple_New(0);
    if (!args)
        return nullptr;
    auto args_guard = ignite::detail::defer([&]{ Py_DECREF(args); });

    auto kwargs = PyDict_New();
    if (!kwargs)
        return nullptr;
    auto kwargs_guard = ignite::detail::defer([&]{ Py_DECREF(kwargs); });

    PyObject* py_bytes = PyBytes_FromStringAndSize(reinterpret_cast<const char*>(bytes.data()), bytes.size());
    if (!py_bytes)
        return nullptr;

    if (PyDict_SetItemString(kwargs, "bytes", py_bytes) < 0) {
        Py_DECREF(py_bytes);
        return nullptr;
    }

    return PyObject_Call(uuid_class, args, kwargs);
}

PyObject* py_create_date(const ignite::ignite_date &value) {
    auto date_class = py_get_module_date_class();
    if (!date_class)
        return nullptr;

    PyObject* year = PyLong_FromLong(value.get_year());
    if (!year)
        return nullptr;
    auto year_guard = ignite::detail::defer([&]{ Py_DECREF(year); });

    PyObject* month = PyLong_FromLong(value.get_month());
    if (!month)
        return nullptr;
    auto month_guard = ignite::detail::defer([&]{ Py_DECREF(month); });

    PyObject* day = PyLong_FromLong(value.get_day_of_month());
    if (!day)
        return nullptr;
    auto day_guard = ignite::detail::defer([&]{ Py_DECREF(day); });

    auto args = PyTuple_Pack(3, year, month, day);
    if (!args)
        return nullptr;
    auto args_guard = ignite::detail::defer([&]{ Py_DECREF(args); });

    year_guard.release();
    month_guard.release();
    day_guard.release();

    auto kwargs = PyDict_New();
    if (!kwargs)
        return nullptr;
    auto kwargs_guard = ignite::detail::defer([&]{ Py_DECREF(kwargs); });

    return PyObject_Call(date_class, args, kwargs);
}

PyObject* py_create_time(const ignite::ignite_time &value) {
    auto time_class = py_get_module_time_class();
    if (!time_class)
        return nullptr;

    PyObject* hour = PyLong_FromLong(value.get_hour());
    if (!hour)
        return nullptr;
    auto hour_guard = ignite::detail::defer([&]{ Py_DECREF(hour); });

    PyObject* minute = PyLong_FromLong(value.get_minute());
    if (!minute)
        return nullptr;
    auto minute_guard = ignite::detail::defer([&]{ Py_DECREF(minute); });

    PyObject* second = PyLong_FromLong(value.get_second());
    if (!second)
        return nullptr;
    auto second_guard = ignite::detail::defer([&]{ Py_DECREF(second); });

    PyObject* u_second = PyLong_FromLong(value.get_nano() / 1000);
    if (!u_second)
        return nullptr;
    auto u_second_guard = ignite::detail::defer([&]{ Py_DECREF(u_second); });

    auto args = PyTuple_Pack(4, hour, minute, second, u_second);
    if (!args)
        return nullptr;
    auto args_guard = ignite::detail::defer([&]{ Py_DECREF(args); });

    hour_guard.release();
    minute_guard.release();
    second_guard.release();
    u_second_guard.release();

    auto kwargs = PyDict_New();
    if (!kwargs)
        return nullptr;
    auto kwargs_guard = ignite::detail::defer([&]{ Py_DECREF(kwargs); });

    return PyObject_Call(time_class, args, kwargs);
}

PyObject* py_create_datetime(const ignite::ignite_date_time &value) {
    auto datetime_class = py_get_module_datetime_class();
    if (!datetime_class)
        return nullptr;

    PyObject* year = PyLong_FromLong(value.get_year());
    if (!year)
        return nullptr;
    auto year_guard = ignite::detail::defer([&]{ Py_DECREF(year); });

    PyObject* month = PyLong_FromLong(value.get_month());
    if (!month)
        return nullptr;
    auto month_guard = ignite::detail::defer([&]{ Py_DECREF(month); });

    PyObject* day = PyLong_FromLong(value.get_day_of_month());
    if (!day)
        return nullptr;
    auto day_guard = ignite::detail::defer([&]{ Py_DECREF(day); });

    PyObject* hour = PyLong_FromLong(value.get_hour());
    if (!hour)
        return nullptr;
    auto hour_guard = ignite::detail::defer([&]{ Py_DECREF(hour); });

    PyObject* minute = PyLong_FromLong(value.get_minute());
    if (!minute)
        return nullptr;
    auto minute_guard = ignite::detail::defer([&]{ Py_DECREF(minute); });

    PyObject* second = PyLong_FromLong(value.get_second());
    if (!second)
        return nullptr;
    auto second_guard = ignite::detail::defer([&]{ Py_DECREF(second); });

    PyObject* u_second = PyLong_FromLong(value.get_nano() / 1000);
    if (!u_second)
        return nullptr;
    auto u_second_guard = ignite::detail::defer([&]{ Py_DECREF(u_second); });

    auto args = PyTuple_Pack(7, year, month, day, hour, minute, second, u_second);
    if (!args)
        return nullptr;
    auto args_guard = ignite::detail::defer([&]{ Py_DECREF(args); });

    year_guard.release();
    month_guard.release();
    day_guard.release();
    hour_guard.release();
    minute_guard.release();
    second_guard.release();
    u_second_guard.release();

    auto kwargs = PyDict_New();
    if (!kwargs)
        return nullptr;
    auto kwargs_guard = ignite::detail::defer([&]{ Py_DECREF(kwargs); });

    return PyObject_Call(datetime_class, args, kwargs);
}

PyObject* py_create_datetime(const ignite::ignite_timestamp &value) {
    auto datetime_class = py_get_module_datetime_class();
    if (!datetime_class)
        return nullptr;

    PyObject* second = PyLong_FromLongLong(value.get_epoch_second());
    if (!second)
        return nullptr;
    auto second_guard = ignite::detail::defer([&]{ Py_DECREF(second); });

    PyObject* u_second = PyLong_FromLongLong(value.get_nano() / 1000);
    if (!u_second)
        return nullptr;
    auto u_second_guard = ignite::detail::defer([&]{ Py_DECREF(u_second); });

    PyObject* constructor_name = PyUnicode_FromString("fromtimestamp");
    if (!constructor_name)
        return nullptr;
    auto constructor_name_guard = ignite::detail::defer([&]{ Py_DECREF(constructor_name); });

    return PyObject_CallMethodObjArgs(datetime_class, constructor_name, second, nullptr);
}

PyObject* py_create_number(std::string_view value) {
    auto number_class = py_get_module_number_class();
    if (!number_class)
        return nullptr;

    PyObject* str_obj = PyUnicode_FromStringAndSize(value.data(), value.size());
    if (!str_obj)
        return nullptr;
    auto str_obj_guard = ignite::detail::defer([&]{ Py_DECREF(str_obj); });

    auto args = PyTuple_Pack(1, str_obj);
    if (!args)
        return nullptr;
    auto args_guard = ignite::detail::defer([&]{ Py_DECREF(args); });

    str_obj_guard.release();

    auto kwargs = PyDict_New();
    if (!kwargs)
        return nullptr;
    auto kwargs_guard = ignite::detail::defer([&]{ Py_DECREF(kwargs); });

    return PyObject_Call(number_class, args, kwargs);
}

PyObject* py_create_timedelta(const ignite::ignite_duration &value) {
    auto duration_class = py_get_module_duration_class();
    if (!duration_class)
        return nullptr;

    auto args = PyTuple_New(0);
    if (!args)
        return nullptr;
    auto args_guard = ignite::detail::defer([&]{ Py_DECREF(args); });

    PyObject* second = PyLong_FromLong(value.get_seconds());
    if (!second)
        return nullptr;
    auto second_guard = ignite::detail::defer([&]{ Py_DECREF(second); });

    PyObject* u_second = PyLong_FromLong(value.get_nano() / 1000);
    if (!u_second)
        return nullptr;
    auto u_second_guard = ignite::detail::defer([&]{ Py_DECREF(u_second); });

    auto kwargs = PyDict_New();
    if (!kwargs)
        return nullptr;
    auto kwargs_guard = ignite::detail::defer([&]{ Py_DECREF(kwargs); });

    if (PyDict_SetItemString(kwargs, "seconds", second) < 0)
        return nullptr;
    second_guard.release();

    if (PyDict_SetItemString(kwargs, "microseconds", u_second) < 0)
        return nullptr;
    u_second_guard.release();

    return PyObject_Call(duration_class, args, kwargs);
}