#include "settings/dictionary_manager.h"

#include "config/ime_config.h"
#include "utils/common_utils.h"
#include "MetasequoiaImeEngine/common/helpcode_utils.h"
#include "MetasequoiaImeEngine/quanpin/quanpin_query.h"
#include "MetasequoiaImeEngine/quanpin/quanpin_utils.h"

#include <sqlite3.h>
#include <algorithm>
#include <cctype>
#include <memory>
#include <vector>

namespace SettingsDictionary
{
namespace json = boost::json;
namespace
{
struct DbCloser { void operator()(sqlite3 *db) const { if (db) sqlite3_close(db); } };
using Db = std::unique_ptr<sqlite3, DbCloser>;
struct StmtCloser { void operator()(sqlite3_stmt *stmt) const { if (stmt) sqlite3_finalize(stmt); } };
using Stmt = std::unique_ptr<sqlite3_stmt, StmtCloser>;

json::object Result(bool ok, std::string message)
{
    return {{"ok", ok}, {"message", std::move(message)}, {"rows", json::array{}}};
}

std::string StringValue(const json::object &obj, const char *key)
{
    const auto *value = obj.if_contains(key);
    return value && value->is_string() ? std::string(value->as_string()) : std::string{};
}

int IntValue(const json::object &obj, const char *key, int fallback)
{
    const auto *value = obj.if_contains(key);
    return value && value->is_int64() ? static_cast<int>(value->as_int64()) : fallback;
}

bool IsAsciiWord(const std::string &value)
{
    return !value.empty() && std::all_of(value.begin(), value.end(), [](unsigned char ch) {
        return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch == '-' || ch == '\'';
    });
}

Db OpenDatabase(const std::string &name, std::string &error)
{
    sqlite3 *raw = nullptr;
    const std::string path = CommonUtils::get_ime_data_path() + "\\" + name;
    if (sqlite3_open_v2(path.c_str(), &raw, SQLITE_OPEN_READWRITE | SQLITE_OPEN_FULLMUTEX, nullptr) != SQLITE_OK)
    {
        error = raw ? sqlite3_errmsg(raw) : "无法打开数据库";
        if (raw) sqlite3_close(raw);
        return {};
    }
    sqlite3_busy_timeout(raw, 3000);
    return Db(raw);
}

Stmt Prepare(sqlite3 *db, const std::string &sql, std::string &error)
{
    sqlite3_stmt *raw = nullptr;
    if (sqlite3_prepare_v2(db, sql.c_str(), -1, &raw, nullptr) != SQLITE_OK)
    {
        error = sqlite3_errmsg(db);
        return {};
    }
    return Stmt(raw);
}

bool BindText(sqlite3_stmt *stmt, int index, const std::string &value)
{
    return sqlite3_bind_text(stmt, index, value.c_str(), -1, SQLITE_TRANSIENT) == SQLITE_OK;
}

bool NormalizePinyin(const std::string &mode, const std::string &input, quanpin::Segments &segments,
                     std::string &normalized, std::string &message)
{
    std::string source = input;
    source.erase(std::remove_if(source.begin(), source.end(), [](unsigned char ch) { return std::isspace(ch); }), source.end());
    std::transform(source.begin(), source.end(), source.begin(), [](unsigned char ch) { return static_cast<char>(std::tolower(ch)); });
    source.erase(std::remove(source.begin(), source.end(), '\''), source.end());
    const auto cuts = quanpin::cut_pinyin_by_mode(source, "correction");
    std::string joined = cuts.empty() ? std::string{} : quanpin::join_segments(cuts.front());
    std::string joined_without_delimiters = joined;
    joined_without_delimiters.erase(std::remove(joined_without_delimiters.begin(), joined_without_delimiters.end(), '\''),
                                    joined_without_delimiters.end());
    if (cuts.empty() || cuts.front().empty() || joined_without_delimiters != source)
    {
        message = "全拼拼音不合法";
        return false;
    }
    segments = cuts.front();
    normalized = std::move(joined);
    return true;
}

bool ValidateChineseEntry(const std::string &mode, const std::string &code, const std::string &word,
                          quanpin::Segments &segments, std::string &normalized, std::string &message)
{
    if (word.empty()) { message = "词条不能为空"; return false; }
    if (!NormalizePinyin(mode, code, segments, normalized, message)) return false;
    const size_t han_count = HelpcodeUtils::count_han_chars(word);
    if (han_count == 0 || han_count != segments.size())
    {
        message = "拼音音节数量必须与汉字数量一致";
        return false;
    }
    return true;
}

json::object QueryChinese(const std::string &mode, const std::string &search)
{
    std::string error;
    Db db = OpenDatabase("msime.db", error);
    if (!db) return Result(false, "打开拼音词库失败：" + error);
    quanpin::Segments segments;
    std::string normalized;
    if (!search.empty() && !NormalizePinyin(mode, search, segments, normalized, error)) return Result(false, error);

    json::array rows;
    if (!normalized.empty())
    {
        const std::string table = quanpin::build_table_name(segments);
        Stmt stmt = Prepare(db.get(), "SELECT key,value,weight FROM \"" + table + "\" WHERE key=?1 ORDER BY weight DESC", error);
        if (!stmt || !BindText(stmt.get(), 1, normalized)) return Result(false, "查询失败：" + error);
        while (sqlite3_step(stmt.get()) == SQLITE_ROW)
        {
            rows.push_back({{"code", reinterpret_cast<const char *>(sqlite3_column_text(stmt.get(), 0))},
                            {"word", reinterpret_cast<const char *>(sqlite3_column_text(stmt.get(), 1))},
                            {"weight", sqlite3_column_int(stmt.get(), 2)}});
        }
    }
    json::object result = Result(true, rows.empty() ? "没有找到词条" : "查询成功");
    result["rows"] = std::move(rows);
    return result;
}

bool ChineseExists(sqlite3 *db, const quanpin::Segments &segments, const std::string &key, const std::string &word)
{
    std::string error;
    Stmt stmt = Prepare(db, "SELECT 1 FROM \"" + quanpin::build_table_name(segments) + "\" WHERE key=?1 AND value=?2 LIMIT 1", error);
    if (!stmt || !BindText(stmt.get(), 1, key) || !BindText(stmt.get(), 2, word)) return false;
    return sqlite3_step(stmt.get()) == SQLITE_ROW;
}

json::object MutateChinese(const json::object &request)
{
    const std::string mode = StringValue(request, "dictionary");
    const std::string action = StringValue(request, "action");
    const std::string code = StringValue(request, "code");
    const std::string word = StringValue(request, "word");
    const int weight = (std::max)(0, IntValue(request, "weight", 10000));
    quanpin::Segments segments;
    std::string key, error;
    if (!ValidateChineseEntry(mode, code, word, segments, key, error)) return Result(false, error);
    Db db = OpenDatabase("msime.db", error);
    if (!db) return Result(false, "打开拼音词库失败：" + error);
    const std::string table = quanpin::build_table_name(segments);

    if (action == "create")
    {
        if (ChineseExists(db.get(), segments, key, word)) return Result(false, "词条已经存在");
        Stmt stmt = Prepare(db.get(), "INSERT INTO \"" + table + "\"(key,jp,value,weight) VALUES(?1,?2,?3,?4)", error);
        if (!stmt || !BindText(stmt.get(), 1, key) || !BindText(stmt.get(), 2, quanpin::segments_to_jianpin(segments)) ||
            !BindText(stmt.get(), 3, word) || sqlite3_bind_int(stmt.get(), 4, weight) != SQLITE_OK || sqlite3_step(stmt.get()) != SQLITE_DONE)
            return Result(false, "新增失败：" + std::string(sqlite3_errmsg(db.get())));
        return Result(true, "词条新增成功");
    }

    const std::string old_code = StringValue(request, "oldCode");
    const std::string old_word = StringValue(request, "oldWord");
    quanpin::Segments old_segments;
    std::string old_key;
    if (!ValidateChineseEntry(mode, old_code, old_word, old_segments, old_key, error)) return Result(false, "原词条无效：" + error);
    const std::string old_table = quanpin::build_table_name(old_segments);
    if (!ChineseExists(db.get(), old_segments, old_key, old_word)) return Result(false, "原词条不存在或已被删除");

    if (action == "delete")
    {
        Stmt stmt = Prepare(db.get(), "DELETE FROM \"" + old_table + "\" WHERE key=?1 AND value=?2", error);
        if (!stmt || !BindText(stmt.get(), 1, old_key) || !BindText(stmt.get(), 2, old_word) || sqlite3_step(stmt.get()) != SQLITE_DONE)
            return Result(false, "删除失败：" + std::string(sqlite3_errmsg(db.get())));
        return Result(true, "词条删除成功");
    }

    if (action != "update") return Result(false, "未知操作");
    if ((old_key != key || old_word != word) && ChineseExists(db.get(), segments, key, word)) return Result(false, "修改后的词条已经存在");
    sqlite3_exec(db.get(), "BEGIN IMMEDIATE", nullptr, nullptr, nullptr);
    Stmt remove = Prepare(db.get(), "DELETE FROM \"" + old_table + "\" WHERE key=?1 AND value=?2", error);
    Stmt insert = Prepare(db.get(), "INSERT INTO \"" + table + "\"(key,jp,value,weight) VALUES(?1,?2,?3,?4)", error);
    const bool ok = remove && insert && BindText(remove.get(), 1, old_key) && BindText(remove.get(), 2, old_word) &&
        sqlite3_step(remove.get()) == SQLITE_DONE && BindText(insert.get(), 1, key) &&
        BindText(insert.get(), 2, quanpin::segments_to_jianpin(segments)) && BindText(insert.get(), 3, word) &&
        sqlite3_bind_int(insert.get(), 4, weight) == SQLITE_OK && sqlite3_step(insert.get()) == SQLITE_DONE;
    sqlite3_exec(db.get(), ok ? "COMMIT" : "ROLLBACK", nullptr, nullptr, nullptr);
    return Result(ok, ok ? "词条修改成功" : "修改失败：" + std::string(sqlite3_errmsg(db.get())));
}

json::object HandleEnglish(const json::object &request)
{
    const std::string action = StringValue(request, "action");
    std::string word = StringValue(request, "word");
    const std::string display = StringValue(request, "display");
    std::transform(word.begin(), word.end(), word.begin(), [](unsigned char ch) { return static_cast<char>(std::tolower(ch)); });
    std::string error;
    Db db = OpenDatabase("english.db", error);
    if (!db) return Result(false, "打开英文词库失败：" + error);
    if (action == "query")
    {
        Stmt stmt = Prepare(db.get(), "SELECT word,display FROM english_words WHERE word LIKE ?1 ORDER BY word", error);
        const std::string pattern = word + "%";
        if (!stmt || !BindText(stmt.get(), 1, pattern)) return Result(false, "查询失败");
        json::array rows;
        while (sqlite3_step(stmt.get()) == SQLITE_ROW)
            rows.push_back({{"word", reinterpret_cast<const char *>(sqlite3_column_text(stmt.get(), 0))},
                            {"display", reinterpret_cast<const char *>(sqlite3_column_text(stmt.get(), 1))}});
        json::object result = Result(true, rows.empty() ? "没有找到词条" : "查询成功"); result["rows"] = std::move(rows); return result;
    }
    if (!IsAsciiWord(word) || display.empty()) return Result(false, "英文单词仅支持英文字母、连字符和撇号，显示内容不能为空");
    const std::string old_word = StringValue(request, "oldWord");
    std::string sql;
    if (action == "create") sql = "INSERT INTO english_words(word,display) VALUES(?1,?2)";
    else if (action == "update") sql = "UPDATE english_words SET word=?1,display=?2 WHERE word=?3";
    else if (action == "delete") sql = "DELETE FROM english_words WHERE word=?1";
    else return Result(false, "未知操作");
    Stmt stmt = Prepare(db.get(), sql, error);
    bool ok = stmt && BindText(stmt.get(), 1, action == "delete" ? old_word : word);
    if (ok && action != "delete") ok = BindText(stmt.get(), 2, display);
    if (ok && action == "update") ok = BindText(stmt.get(), 3, old_word);
    ok = ok && sqlite3_step(stmt.get()) == SQLITE_DONE && sqlite3_changes(db.get()) > 0;
    const char *label = action == "create" ? "新增" : action == "update" ? "修改" : "删除";
    return Result(ok, ok ? std::string("英文词条") + label + "成功" : std::string(label) + "失败：" + sqlite3_errmsg(db.get()));
}

json::object HandleWubi(const json::object &request)
{
    const std::string action = StringValue(request, "action");
    std::string code = StringValue(request, "code");
    const std::string word = StringValue(request, "word");
    const int weight = (std::max)(0, IntValue(request, "weight", 10000));
    std::transform(code.begin(), code.end(), code.begin(), [](unsigned char ch) { return static_cast<char>(std::tolower(ch)); });
    std::string error;
    Db db = OpenDatabase("msime.db", error);
    if (!db) return Result(false, "打开五笔词库失败：" + error);
    if (action == "query")
    {
        if (code.empty() || !std::all_of(code.begin(), code.end(), [](unsigned char ch) { return ch >= 'a' && ch <= 'z'; }))
            return Result(false, "请输入合法的五笔编码");
        Stmt stmt = Prepare(db.get(), "SELECT key,value,weight FROM wubi86 WHERE key LIKE ?1 ORDER BY weight DESC", error);
        if (!stmt || !BindText(stmt.get(), 1, code + "%")) return Result(false, "查询失败：" + error);
        json::array rows;
        while (sqlite3_step(stmt.get()) == SQLITE_ROW)
            rows.push_back({{"code", reinterpret_cast<const char *>(sqlite3_column_text(stmt.get(), 0))},
                            {"word", reinterpret_cast<const char *>(sqlite3_column_text(stmt.get(), 1))},
                            {"weight", sqlite3_column_int(stmt.get(), 2)}});
        json::object result = Result(true, rows.empty() ? "没有找到词条" : "查询成功"); result["rows"] = std::move(rows); return result;
    }
    if (code.empty() || word.empty() || !std::all_of(code.begin(), code.end(), [](unsigned char ch) { return ch >= 'a' && ch <= 'z'; }))
        return Result(false, "五笔编码和词条不能为空，编码只能包含英文字母");
    const std::string old_code = StringValue(request, "oldCode");
    const std::string old_word = StringValue(request, "oldWord");
    std::string sql;
    if (action == "create") sql = "INSERT INTO wubi86(key,value,weight) VALUES(?1,?2,?3)";
    else if (action == "update") sql = "UPDATE wubi86 SET key=?1,value=?2,weight=?3 WHERE key=?4 AND value=?5";
    else if (action == "delete") sql = "DELETE FROM wubi86 WHERE key=?1 AND value=?2";
    else return Result(false, "未知操作");
    Stmt stmt = Prepare(db.get(), sql, error);
    bool ok = stmt != nullptr;
    if (ok && action == "delete") ok = BindText(stmt.get(), 1, old_code) && BindText(stmt.get(), 2, old_word);
    else if (ok)
    {
        ok = BindText(stmt.get(), 1, code) && BindText(stmt.get(), 2, word) && sqlite3_bind_int(stmt.get(), 3, weight) == SQLITE_OK;
        if (ok && action == "update") ok = BindText(stmt.get(), 4, old_code) && BindText(stmt.get(), 5, old_word);
    }
    ok = ok && sqlite3_step(stmt.get()) == SQLITE_DONE && sqlite3_changes(db.get()) > 0;
    const char *label = action == "create" ? "新增" : action == "update" ? "修改" : "删除";
    return Result(ok, ok ? std::string("五笔词条") + label + "成功" : std::string(label) + "失败：" + sqlite3_errmsg(db.get()));
}

json::object HandleQuickPhrase(const json::object &request)
{
    const std::string action = StringValue(request, "action");
    std::string code = StringValue(request, "code");
    const std::string phrase = StringValue(request, "word");
    const int weight = (std::max)(0, IntValue(request, "weight", 10));
    std::transform(code.begin(), code.end(), code.begin(), [](unsigned char ch) { return static_cast<char>(std::tolower(ch)); });
    const auto valid_code = [](const std::string &value) {
        return !value.empty() && std::all_of(value.begin(), value.end(), [](unsigned char ch) { return ch >= 'a' && ch <= 'z'; });
    };
    std::string error;
    Db db = OpenDatabase("msime.db", error);
    if (!db) return Result(false, "打开快捷短语表失败：" + error);

    if (action == "query")
    {
        if (!code.empty() && !valid_code(code)) return Result(false, "编码只能包含英文字母");
        Stmt stmt = Prepare(db.get(), "SELECT key,value,weight FROM quick_parases WHERE key LIKE ?1 "
                                      "ORDER BY weight DESC,key,value", error);
        if (!stmt || !BindText(stmt.get(), 1, code + "%")) return Result(false, "查询失败：" + error);
        json::array rows;
        while (sqlite3_step(stmt.get()) == SQLITE_ROW)
            rows.push_back({{"code", reinterpret_cast<const char *>(sqlite3_column_text(stmt.get(), 0))},
                            {"word", reinterpret_cast<const char *>(sqlite3_column_text(stmt.get(), 1))},
                            {"weight", sqlite3_column_int(stmt.get(), 2)}});
        json::object result = Result(true, rows.empty() ? "没有找到快捷短语" : "查询成功");
        result["rows"] = std::move(rows);
        return result;
    }

    if (!valid_code(code) || phrase.empty()) return Result(false, "编码只能包含英文字母，短语不能为空");
    const std::string old_code = StringValue(request, "oldCode");
    const std::string old_phrase = StringValue(request, "oldWord");
    std::string sql;
    if (action == "create") sql = "INSERT INTO quick_parases(key,value,weight) VALUES(?1,?2,?3)";
    else if (action == "update") sql = "UPDATE quick_parases SET key=?1,value=?2,weight=?3 WHERE key=?4 AND value=?5";
    else if (action == "delete") sql = "DELETE FROM quick_parases WHERE key=?1 AND value=?2";
    else return Result(false, "未知操作");

    Stmt stmt = Prepare(db.get(), sql, error);
    bool ok = stmt != nullptr;
    if (ok && action == "delete") ok = BindText(stmt.get(), 1, old_code) && BindText(stmt.get(), 2, old_phrase);
    else if (ok)
    {
        ok = BindText(stmt.get(), 1, code) && BindText(stmt.get(), 2, phrase) &&
             sqlite3_bind_int(stmt.get(), 3, weight) == SQLITE_OK;
        if (ok && action == "update") ok = BindText(stmt.get(), 4, old_code) && BindText(stmt.get(), 5, old_phrase);
    }
    ok = ok && sqlite3_step(stmt.get()) == SQLITE_DONE && sqlite3_changes(db.get()) > 0;
    const char *label = action == "create" ? "新增" : action == "update" ? "修改" : "删除";
    return Result(ok, ok ? std::string("快捷短语") + label + "成功" : std::string(label) + "失败：" + sqlite3_errmsg(db.get()));
}
}

json::object HandleRequest(const json::object &request)
{
    const std::string dictionary = StringValue(request, "dictionary");
    const std::string action = StringValue(request, "action");
    if (dictionary == "english") return HandleEnglish(request);
    if (dictionary == "wubi") return HandleWubi(request);
    if (dictionary == "quick") return HandleQuickPhrase(request);
    if (dictionary != "quanpin") return Result(false, "未知词库");
    if (action == "query") return QueryChinese(dictionary, StringValue(request, "code"));
    return MutateChinese(request);
}
}