#include <memory>
#include <mutex>
#include <shared_mutex>
#include <spdlog/spdlog.h>
#include <filesystem>
#include "./utils/text_coordinates.hpp"
#include "../language/ast/deserializer.hpp"
#include "./parser.hpp"

namespace lsp::service
{
    // ============= TreeSitter ================== //

    TreeSitter::TreeSitter()
    {
        parser_ = ts_parser_new();
        if (!parser_)
            throw std::runtime_error("Failed to create tree-sitter parser");
    }

    TreeSitter::~TreeSitter()
    {
        if (parser_)
            ts_parser_delete(parser_);
    }

    TreeSitter::TreeSitter(TreeSitter&& other) noexcept :
        parser_(other.parser_)
    {
        other.parser_ = nullptr;
    }

    bool TreeSitter::SetLanguage(const TSLanguage* language)
    {
        if (!parser_)
            return false;
        return ts_parser_set_language(parser_, language);
    }

    TSTree* TreeSitter::Parse(const char* content, size_t length, TSTree* old_tree)
    {
        if (!parser_)
            return nullptr;
        return ts_parser_parse_string(parser_, old_tree, content, length);
    }

    TSParser* TreeSitter::GetRawParser() const
    {
        return parser_;
    };

    // ============= SyntaxTree ================== //

    SyntaxTree::SyntaxTree(TSTree* tree) :
        tree_(tree, ts_tree_delete) {}

    SyntaxTree::~SyntaxTree() = default;

    TSTree* SyntaxTree::Get() const
    {
        return tree_.get();
    }

    void SyntaxTree::ApplyEdit(const protocol::TextDocumentContentChangeEvent& change, const protocol::string& content)
    {
        if (!tree_)
            return;
        protocol::uinteger start_offset = utils::text_coordinates::ToOffset(change.range.start, content);
        protocol::uinteger end_offset = utils::text_coordinates::ToOffset(change.range.end, content);

        TSInputEdit edit = {};
        edit.start_byte = start_offset;
        edit.old_end_byte = end_offset;
        edit.new_end_byte = start_offset + change.text.length();

        edit.start_point = utils::text_coordinates::ToPoint(change.range.start);
        edit.old_end_point = utils::text_coordinates::ToPoint(change.range.end);
        edit.new_end_point = utils::text_coordinates::CalculateEndPoint(change.text, edit.start_point);

        ts_tree_edit(tree_.get(), &edit);
    }

    TSNode SyntaxTree::GetRootNode() const
    {
        return tree_ ? ts_tree_root_node(tree_.get()) : TSNode{};
    }

    // ============= SyntaxTreeManager ================== //

    void SyntaxTreeManager::StoreTree(const protocol::DocumentUri& uri, std::unique_ptr<SyntaxTree> tree)
    {
        std::unique_lock<std::shared_mutex> lock(mutex_);
        trees_[uri] = std::move(tree);
    }

    void SyntaxTreeManager::RemoveTree(const protocol::DocumentUri& uri)
    {
        std::unique_lock<std::shared_mutex> lock(mutex_);
        trees_.erase(uri);
    }

    SyntaxTree* SyntaxTreeManager::GetTree(const protocol::DocumentUri& uri)
    {
        std::shared_lock<std::shared_mutex> lock(mutex_);
        auto it = trees_.find(uri);
        return (it != trees_.end()) ? it->second.get() : nullptr;
    }

    const SyntaxTree* SyntaxTreeManager::GetTree(const protocol::DocumentUri& uri) const
    {
        std::shared_lock<std::shared_mutex> lock(mutex_);
        auto it = trees_.find(uri);
        return (it != trees_.end()) ? it->second.get() : nullptr;
    }

    size_t SyntaxTreeManager::GetTreeCount() const
    {
        std::shared_lock<std::shared_mutex> lock(mutex_);
        return trees_.size();
    }

    void SyntaxTreeManager::Clear()
    {
        std::unique_lock<std::shared_mutex> lock(mutex_);
        trees_.clear();
    }

    // ============= Parser ================== //

    Parser::Parser(std::shared_ptr<EventBus> event_bus) :
        event_bus_(std::move(event_bus))
    {
        if (parser_.SetLanguage(tree_sitter_tsf()))
            spdlog::info("Set tree-sitter-tsf successfully");
        else
            spdlog::error("Failed to set tree-sitter language");

        event_bus_->Subscribe<events::DocumentOpend>(
            [this](const auto& e) { OnDocumentOpened(e); });
        event_bus_->Subscribe<events::DocumentChanged>(
            [this](const auto& e) { OnDocumentChanged(e); });
        event_bus_->Subscribe<events::DocumentClosed>(
            [this](const auto& e) { OnDocumentClosed(e); });
    }

    Parser::~Parser() = default;

    TSParser* Parser::GetRawParser() const
    {
        return parser_.GetRawParser();
    };

    TSTree* Parser::GetTree(const protocol::DocumentUri& uri) const
    {
        auto* syntax_tree = syntax_tree_manager_.GetTree(uri);
        return syntax_tree ? syntax_tree->Get() : nullptr;
    }

    std::optional<symbol::EditingSymbolTable> Parser::ParseTsfFile(const std::string& file_path)
    {
        std::string extension = std::filesystem::path(file_path).extension().string();
        std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower);
        if (extension != ".tsf" && extension != ".tsl")
            return std::nullopt;
        spdlog::debug("Parse tsf file: {}", file_path);

        // 读取文件
        std::ifstream file(file_path);
        if (!file.is_open())
        {
            spdlog::trace("Cannot open file: {}", file_path);
            return std::nullopt;
        }

        std::string content((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
        file.close();

        // 创建局部的 parser 和 extractor（线程安全）
        TreeSitter local_parser;
        if (!local_parser.SetLanguage(tree_sitter_tsf()))
        {
            spdlog::error("Failed to set tree-sitter language in ParseTsfFile");
            return std::nullopt;
        }

        // 解析
        TSTree* tree = local_parser.Parse(content.c_str(), content.length());
        if (!tree)
        {
            spdlog::trace("Failed to parse file: {}", file_path);
            return std::nullopt;
        }
        // 解析
        auto tree_deleter = [](TSTree* t) { ts_tree_delete(t); };
        std::unique_ptr<TSTree, decltype(tree_deleter)> tree_guard(tree, tree_deleter);

        symbol::EditingSymbolTable table;
        table.uri = "file://" + std::filesystem::absolute(file_path).string();
        table.version = 0;
        table.last_parsed = std::chrono::system_clock::now();
        table.is_dirty = false;
        table.deserializer = std::make_unique<language::ast::Deserializer>();
        table.file_path = std::filesystem::absolute(file_path).string();

        auto ast_result = table.deserializer->Parse(ts_tree_root_node(tree), content);
        if (ast_result.HasErrors())
        {
            for (const auto& it : ast_result.errors)
                spdlog::warn("Parse Error = {}", it.message);
        }
        if (!ast_result.root)
        {
            spdlog::error("AST root is null for: {}", file_path);
            return std::nullopt;
        }
        table.ast_root = std::move(ast_result.root);
        table.symbol_table = std::make_unique<language::symbol::SymbolTable>();

        try
        {
            // 使用 Builder 构建符号表
            table.symbol_table->Build(*table.ast_root);
            spdlog::debug("Successfully built symbol table for: {}", file_path);
        }
        catch (const std::exception& e)
        {
            spdlog::error("Failed to build symbol table for {}: {}", file_path, e.what());
            return std::nullopt;
        }

        auto metadata = InferFileMetadata(*table.symbol_table);
        if (!metadata)
        {
            spdlog::warn("Cannot infer file metadata from symbol table: {}", file_path);
            return std::nullopt;
        }
        table.file_type = metadata->file_type;

        // 验证TSF文件
        std::string file_stem = std::filesystem::path(file_path).stem().string();
        auto normalize_name = [](std::string s) {
            std::transform(s.begin(), s.end(), s.begin(), ::tolower);
            size_t at_pos = s.find("@");
            if (at_pos != std::string::npos)
                s = s.substr(0, at_pos);
            return s;
        };
        if (normalize_name(file_stem) != normalize_name(metadata->primary_symbol))
            spdlog::warn("File name '{}' doesn't match primary symbol '{}' in: {}", file_stem, metadata->primary_symbol, file_path);

        spdlog::debug("Successfully parsed file: {} (type: {}, symbol: {})",
                      file_path,
                      static_cast<int>(metadata->file_type),
                      metadata->primary_symbol);
        return table;
    }

    std::optional<Parser::FileMetadata> Parser::InferFileMetadata(const language::symbol::SymbolTable& table)
    {
        auto top_level_symbols = table.GetDocumentSymbols();

        if (top_level_symbols.empty())
        {
            spdlog::warn("No top-level symbol definitions found in symbol table");
            return std::nullopt;
        }

        // 过滤掉特殊的全局命名空间符号 "::"
        std::vector<const language::symbol::SymbolDefinition*> filtered_symbols;
        for (const auto* sym : top_level_symbols)
        {
            if (sym->name != "::")
            {
                filtered_symbols.push_back(sym);
            }
        }

        if (filtered_symbols.empty())
        {
            spdlog::warn("No valid top-level symbols found (only global namespace)");
            return std::nullopt;
        }

        // 按位置排序
        std::sort(filtered_symbols.begin(), filtered_symbols.end(), [](const language::symbol::SymbolDefinition* a, const language::symbol::SymbolDefinition* b) {
            if (a->location.start_byte != b->location.start_byte)
            {
                return a->location.start_byte < b->location.start_byte;
            }
            if (a->location.start_line != b->location.start_line)
            {
                return a->location.start_line < b->location.start_line;
            }
            return a->location.start_column < b->location.start_column;
        });

        // 取第一个真实的顶层符号
        const language::symbol::SymbolDefinition* first_top_level = filtered_symbols[0];

        FileMetadata metadata;
        metadata.primary_symbol = first_top_level->name;
        metadata.primary_kind = first_top_level->kind;

        // 根据第一个符号推断文件类型
        switch (first_top_level->kind)
        {
        case protocol::SymbolKind::Module:
            metadata.file_type = symbol::TsfFileType::kUnit;
            spdlog::trace("File type inferred as Unit from first symbol: '{}'", first_top_level->name);
            break;

        case protocol::SymbolKind::Class:
            metadata.file_type = symbol::TsfFileType::kClass;
            spdlog::trace("File type inferred as Class from first symbol: '{}'", first_top_level->name);
            break;

        case protocol::SymbolKind::Function:
            metadata.file_type = symbol::TsfFileType::kFunction;
            spdlog::trace("File type inferred as Function from first symbol: '{}'", first_top_level->name);
            break;

        default:
            metadata.file_type = symbol::TsfFileType::kScript;
            spdlog::trace("File type inferred as Script (default) from first symbol: '{}'", first_top_level->name);
            break;
        }

        spdlog::debug("Inferred file metadata: type={}, symbol='{}', kind={}, location={}:{}",
                      static_cast<int>(metadata.file_type),
                      metadata.primary_symbol,
                      static_cast<int>(metadata.primary_kind),
                      first_top_level->location.start_line,
                      first_top_level->location.start_column);

        return metadata;
    }

    void Parser::OnDocumentOpened(const events::DocumentOpend& event)
    {
        TSTree* tree = parser_.Parse(event.textDocument.text.c_str(), event.textDocument.text.length());
        if (tree)
        {
            syntax_tree_manager_.StoreTree(event.textDocument.uri, std::make_unique<SyntaxTree>(tree));
            event_bus_->Publish(events::DocumentParsed{
                .item = event.textDocument,
                .tree = tree });
            spdlog::debug("Successfully parsed document: {}", event.textDocument.uri);
        }
        else
        {
            spdlog::error("Failed to parsed document: {}", event.textDocument.uri);
        }
    }

    void Parser::OnDocumentChanged(const events::DocumentChanged& event)
    {
        SyntaxTree* syntax_tree = syntax_tree_manager_.GetTree(event.uri);
        TSTree* old_tree = syntax_tree ? syntax_tree->Get() : nullptr;

        // 应用增量编辑
        if (syntax_tree && old_tree)
            for (const auto& change : event.changes)
                syntax_tree->ApplyEdit(change, event.content);

        // 增量解析
        TSTree* tree = parser_.Parse(event.content.c_str(), event.content.length(), old_tree);

        if (tree)
        {
            syntax_tree_manager_.StoreTree(event.uri, std::make_unique<SyntaxTree>(tree));
            event_bus_->Publish(events::DocumentReparsed{
                .item{ .uri = event.uri, .languageId = "", .version = event.version, .text = std::move(event.content) },
                .tree = tree,
            });

            spdlog::debug("Document reparsed successfully: {}", event.uri);
        }
        else
        {
            spdlog::error("Failed to reparse document: {}", event.uri);
        }
    }

    void Parser::OnDocumentClosed(const events::DocumentClosed& event)
    {
        syntax_tree_manager_.RemoveTree(event.textDocument.uri);
        spdlog::debug("Removed syntax tree for: {}", event.textDocument.uri);
    }

}