/*
 * Copyright (c) Huawei Technologies Co., Ltd. 2025. All rights reserved.
 */

#include <gtest/gtest.h>

#include <memory>
#include <string>
#include <vector>
#include <stdexcept>
#include <thread>
#include <future>

#include "server/tool_manager.h"

static constexpr int LOOP_NUM = 3;
static constexpr int TOOL_NUM = 2;

namespace Mcp {

static ToolReturn TestToolFunc(const ServerContext& /* ctx */, const std::string& name,
    const std::string& arguments)
{
    CallToolResult result;
    result.isError = false;

    TextContent textContent;
    textContent.text = R"(Tool )" + name + R"( executed with arguments: )" + arguments;

    result.content.push_back(textContent);

    return result;
}

static ToolReturn TestCallbackToolFunc(const ServerContext& /* ctx */, const std::string& name,
    const std::string& arguments)
{
    (void)arguments;

    CallToolResult result;
    result.isError = false;

    TextContent textContent;
    textContent.text = R"({"callback": "yes", "tool": ")" + name + "\"}";

    result.content.push_back(textContent);
    return result;
}

class ToolManagerTest : public ::testing::Test {
public:
    ~ToolManagerTest() {}
protected:
    void SetUp() override
    {
        toolManager = std::make_unique<ToolManager>(true);
    }

    void TearDown() override
    {
        toolManager.reset();
    }

    ServerTool CreateTestTool(const std::string& name = "test_tool",
                           const std::string& description = "Test tool description")
    {
        ServerTool tool;
        tool.name = name;
        tool.description = description;
        tool.inputSchema = R"({"type": "object", "properties": {}})";
        tool.func = TestToolFunc;
        return tool;
    }

    ServerTool CreateComplexSchemaTool(const std::string& name = "complex_tool")
    {
        ServerTool tool;
        tool.name = name;
        tool.description = "Tool with complex input schema";
        tool.inputSchema = R"({
            "type": "object",
            "properties": {
                "param1": {"type": "string"},
                "param2": {"type": "number"},
                "param3": {"type": "boolean"}
            },
            "required": ["param1"]
        })";
        tool.func = TestToolFunc;
        return tool;
    }

    ServerTool CreateErrorThrowingTool(const std::string& name = "error_tool")
    {
        auto errorFunc = [](const ServerContext& /* ctx */, const std::string& name, const std::string& arguments)
            -> ToolReturn {
            (void)arguments;

            if (name == "error_tool") {
                throw std::runtime_error("Simulated tool error");
            }

            CallToolResult result;
            result.isError = false;

            TextContent textContent;
            textContent.text = "Normal execution";
            result.content.push_back(textContent);

            return result;
        };

        ServerTool tool;
        tool.name = name;
        tool.description = "Tool that throws exceptions";
        tool.inputSchema = R"({"type": "object"})";
        tool.func = errorFunc;
        return tool;
    }

    std::unique_ptr<ToolManager> toolManager;
};

TEST_F(ToolManagerTest, ConstructorWithOverwriteTrue)
{
    ToolManager manager(true);
    EXPECT_TRUE(manager.GetOverwrite());
}

TEST_F(ToolManagerTest, ConstructorWithOverwriteFalse)
{
    ToolManager manager(false);
    EXPECT_FALSE(manager.GetOverwrite());
}

TEST_F(ToolManagerTest, SetOverwrite)
{
    EXPECT_TRUE(toolManager->GetOverwrite());

    toolManager->SetOverwrite(false);
    EXPECT_FALSE(toolManager->GetOverwrite());

    toolManager->SetOverwrite(true);
    EXPECT_TRUE(toolManager->GetOverwrite());
}

TEST_F(ToolManagerTest, DefaultConstructor)
{
    ToolManager manager; // 使用默认参数(true)
    EXPECT_TRUE(manager.GetOverwrite());
}

TEST_F(ToolManagerTest, AddToolSuccess)
{
    ServerTool tool = CreateTestTool();

    EXPECT_NO_THROW(toolManager->AddTool(tool));
}

TEST_F(ToolManagerTest, AddToolWithComplexSchema)
{
    ServerTool tool = CreateComplexSchemaTool();

    EXPECT_NO_THROW(toolManager->AddTool(tool));
}

TEST_F(ToolManagerTest, AddToolEmptyName)
{
    ServerTool tool = CreateTestTool();
    tool.name = "";

    EXPECT_NO_THROW(toolManager->AddTool(tool));
}

TEST_F(ToolManagerTest, AddToolEmptyDescription)
{
    ServerTool tool = CreateTestTool();
    tool.description = "";

    EXPECT_NO_THROW(toolManager->AddTool(tool));
}

TEST_F(ToolManagerTest, AddToolNullFunction)
{
    ServerTool tool = CreateTestTool();
    tool.func = nullptr;

    EXPECT_NO_THROW(toolManager->AddTool(tool));
}

TEST_F(ToolManagerTest, AddToolOverwriteWhenOverwriteTrue)
{
    ServerTool tool1 = CreateTestTool("same_tool", "First description");
    ServerTool tool2 = CreateTestTool("same_tool", "Second description");
    tool2.func = TestCallbackToolFunc;

    EXPECT_NO_THROW(toolManager->AddTool(tool1));

    EXPECT_NO_THROW(toolManager->AddTool(tool2));
}

TEST_F(ToolManagerTest, AddToolNoOverwriteWhenOverwriteFalse)
{
    toolManager->SetOverwrite(false);

    ServerTool tool1 = CreateTestTool("same_tool", "First description");
    ServerTool tool2 = CreateTestTool("same_tool", "Second description");

    EXPECT_NO_THROW(toolManager->AddTool(tool1));

    EXPECT_THROW(toolManager->AddTool(tool2), std::runtime_error);
}

TEST_F(ToolManagerTest, AddMultipleTools)
{
    std::vector<ServerTool> tools;

    for (int i = 0; i < LOOP_NUM; i++) {
        ServerTool tool = CreateTestTool("tool_" + std::to_string(i), "Tool " + std::to_string(i));
        EXPECT_NO_THROW(toolManager->AddTool(tool));
    }
}

TEST_F(ToolManagerTest, RemoveToolSuccess)
{
    ServerTool tool = CreateTestTool("tool_to_remove");

    toolManager->AddTool(tool);
    EXPECT_NO_THROW(toolManager->RemoveTool("tool_to_remove"));
}

TEST_F(ToolManagerTest, RemoveToolEmptyName)
{
    EXPECT_THROW(toolManager->RemoveTool(""), std::invalid_argument);
}

TEST_F(ToolManagerTest, RemoveNonExistentTool)
{
    EXPECT_THROW(toolManager->RemoveTool("non_existent_tool"), std::runtime_error);
}

TEST_F(ToolManagerTest, RemoveToolMultipleTimes)
{
    ServerTool tool = CreateTestTool("tool_to_remove");

    toolManager->AddTool(tool);
    EXPECT_NO_THROW(toolManager->RemoveTool("tool_to_remove"));

    EXPECT_THROW(toolManager->RemoveTool("tool_to_remove"), std::runtime_error);
}

TEST_F(ToolManagerTest, ListToolsEmpty)
{
    ListToolsResult result = toolManager->ListTools();
    EXPECT_EQ(result.tools.size(), 0);
}

TEST_F(ToolManagerTest, ListToolsSingleTool)
{
    ServerTool tool = CreateTestTool("tool1", "First tool");
    toolManager->AddTool(tool);

    ListToolsResult result = toolManager->ListTools();
    ASSERT_EQ(result.tools.size(), 1);
    EXPECT_EQ(result.tools[0].name, "tool1");
    EXPECT_EQ(result.tools[0].description, "First tool");
    EXPECT_TRUE(result.tools[0].inputSchema.has_value());
}

TEST_F(ToolManagerTest, ListToolsMultipleTools)
{
    const int numTools = LOOP_NUM;

    for (int i = 0; i < numTools; i++) {
        ServerTool tool = CreateTestTool("tool_" + std::to_string(i), "Tool " + std::to_string(i));
        toolManager->AddTool(tool);
    }

    ListToolsResult result = toolManager->ListTools();
    EXPECT_EQ(result.tools.size(), numTools);

    // 检查所有工具都包含在列表中
    std::set<std::string> expectedNames;
    for (int i = 0; i < numTools; i++) {
        expectedNames.insert("tool_" + std::to_string(i));
    }

    std::set<std::string> actualNames;
    for (const auto& tool : result.tools) {
        actualNames.insert(tool.name);
    }

    EXPECT_EQ(expectedNames, actualNames);
}

TEST_F(ToolManagerTest, ListToolsAfterRemove)
{
    for (int i = 0; i < LOOP_NUM; i++) {
        ServerTool tool = CreateTestTool("tool_" + std::to_string(i));
        toolManager->AddTool(tool);
    }

    toolManager->RemoveTool("tool_1");

    ListToolsResult result = toolManager->ListTools();
    EXPECT_EQ(result.tools.size(), TOOL_NUM);

    std::set<std::string> expectedNames = {"tool_0", "tool_2"};
    std::set<std::string> actualNames;
    for (const auto& tool : result.tools) {
        actualNames.insert(tool.name);
    }

    EXPECT_EQ(expectedNames, actualNames);
}

TEST_F(ToolManagerTest, CallToolSuccess)
{
    ServerTool tool = CreateTestTool("test_tool");
    toolManager->AddTool(tool);

    JsonValue arguments = R"({"param": "value"})"_json;
    CallToolResult result = toolManager->CallTool("test_tool", arguments.dump());

    EXPECT_FALSE(result.isError);
    EXPECT_FALSE(result.content.empty());
    EXPECT_TRUE(std::holds_alternative<TextContent>(result.content[0]));

    auto& textContent = std::get<TextContent>(result.content[0]);
    EXPECT_EQ(textContent.type, "text");
    EXPECT_FALSE(textContent.text.empty());
}

TEST_F(ToolManagerTest, CallToolWithJsonArguments)
{
    ServerTool tool = CreateTestTool("json_tool");
    toolManager->AddTool(tool);

    std::string arguments = R"({"key1": "value1", "key2": 123, "key3": true})";
    CallToolResult result = toolManager->CallTool("json_tool", arguments);

    EXPECT_FALSE(result.isError);
    EXPECT_FALSE(result.content.empty());
}

TEST_F(ToolManagerTest, CallNonExistentTool)
{
    EXPECT_THROW(toolManager->CallTool("non_existent_tool", R"({})"), std::runtime_error);
}

TEST_F(ToolManagerTest, CallToolEmptyName)
{
    EXPECT_THROW(toolManager->CallTool("", R"({})"), std::runtime_error);
}

TEST_F(ToolManagerTest, CallToolThrowsException)
{
    ServerTool tool = CreateErrorThrowingTool("error_tool");
    toolManager->AddTool(tool);

    CallToolResult result = toolManager->CallTool("error_tool", R"({})");
    EXPECT_TRUE(result.isError);
    ASSERT_FALSE(result.content.empty());
    ASSERT_TRUE(std::holds_alternative<TextContent>(result.content[0]));

    const auto& textContent = std::get<TextContent>(result.content[0]);
    EXPECT_EQ(textContent.type, "text");
    EXPECT_EQ(textContent.text, "Simulated tool error");
}

TEST_F(ToolManagerTest, CallToolAfterRemove)
{
    ServerTool tool = CreateTestTool("temp_tool");
    toolManager->AddTool(tool);

    EXPECT_NO_THROW(toolManager->CallTool("temp_tool", R"({})"));

    toolManager->RemoveTool("temp_tool");

    EXPECT_THROW(toolManager->CallTool("temp_tool", R"({})"), std::runtime_error);
}

TEST_F(ToolManagerTest, CallToolAfterOverwrite)
{
    ServerTool tool1 = CreateTestTool("tool", "First tool");
    ServerTool tool2 = CreateTestTool("tool", "Second tool");
    tool2.func = TestCallbackToolFunc;

    toolManager->AddTool(tool1);
    toolManager->AddTool(tool2);

    CallToolResult result = toolManager->CallTool("tool", R"({})");

    EXPECT_FALSE(result.isError);
    EXPECT_FALSE(result.content.empty());
}

TEST_F(ToolManagerTest, AddToolWithVeryLongName)
{
    std::string longName(1000, 'a'); // 1000个'a'
    ServerTool tool = CreateTestTool(longName);

    EXPECT_NO_THROW(toolManager->AddTool(tool));

    ListToolsResult result = toolManager->ListTools();
    ASSERT_EQ(result.tools.size(), 1);
    EXPECT_EQ(result.tools[0].name, longName);

    EXPECT_NO_THROW(toolManager->CallTool(longName, R"({})"));
}

TEST_F(ToolManagerTest, AddManyTools)
{
    const int numTools = 1000;

    for (int i = 0; i < numTools; i++) {
        ServerTool tool = CreateTestTool("tool_" + std::to_string(i));
        EXPECT_NO_THROW(toolManager->AddTool(tool));
    }

    std::optional<std::string> cursor;
    std::size_t total = 0;
    do {
        ListToolsResult page = toolManager->ListTools(cursor);
        total += page.tools.size();
        cursor = page.nextCursor;
    } while (cursor.has_value());

    EXPECT_EQ(total, static_cast<std::size_t>(numTools));
}

TEST_F(ToolManagerTest, RemoveToolExceptionMessages)
{
    try {
        toolManager->RemoveTool("");
        FAIL() << "Expected std::invalid_argument";
    } catch (const std::invalid_argument& e) {
        EXPECT_STREQ(e.what(), "Tool name cannot be empty");
    }

    try {
        toolManager->RemoveTool("non_existent");
        FAIL() << "Expected std::runtime_error";
    } catch (const std::runtime_error& e) {
        EXPECT_STREQ(e.what(), "Tool 'non_existent' not found");
    }
}

TEST_F(ToolManagerTest, CallToolExceptionMessages)
{
    try {
        toolManager->CallTool("non_existent", R"({})");
        FAIL() << "Expected std::runtime_error";
    } catch (const std::runtime_error& e) {
        EXPECT_STREQ(e.what(), "Tool not found: non_existent");
    }

    ServerTool tool = CreateErrorThrowingTool("error_tool");
    toolManager->AddTool(tool);

    CallToolResult result = toolManager->CallTool("error_tool", R"({})");
    EXPECT_TRUE(result.isError);
    ASSERT_FALSE(result.content.empty());
    ASSERT_TRUE(std::holds_alternative<TextContent>(result.content[0]));
    EXPECT_EQ(std::get<TextContent>(result.content[0]).text, "Simulated tool error");
}

// ================ Output Schema Validation Tests ================

static ToolReturn StructuredOutputToolFunc(const ServerContext& /* ctx */, const std::string& name,
    const std::string& arguments)
{
    (void)name;
    JsonValue argumentsJson = JsonValue::parse(arguments);
    if (argumentsJson.contains("returnData")) {
        return argumentsJson["returnData"].dump();
    }
    return R"({"status": "success", "code": 200})";
}

static ToolReturn ErrorResultToolFunc(const ServerContext& /* ctx */, const std::string& name,
    const std::string& arguments)
{
    (void)name;
    (void)arguments;
    CallToolResult result;
    result.isError = true;
    result.structuredContent = R"({"invalid": "data"})";
    return result;
}

// 覆盖: outputSchema存在且验证通过
TEST_F(ToolManagerTest, OutputSchemaValidation_Pass)
{
    ServerTool tool;
    tool.name = "test";
    tool.outputSchema = R"({"type": "object", "properties": {"status": {"type": "string"},
        "code": {"type": "number"}}, "required": ["status", "code"]})";
    tool.func = StructuredOutputToolFunc;
    toolManager->AddTool(tool);
    
    EXPECT_NO_THROW(toolManager->CallTool("test", R"({})"));
}

// 覆盖: outputSchema存在但验证失败
TEST_F(ToolManagerTest, OutputSchemaValidation_Fail)
{
    ServerTool tool;
    tool.name = "test";
    tool.outputSchema = R"({"type": "object", "properties": {"required_field": {"type": "string"}},
        "required": ["required_field"]})";
    tool.func = StructuredOutputToolFunc;
    toolManager->AddTool(tool);
    
    EXPECT_THROW(toolManager->CallTool("test", R"({})"), std::runtime_error);
}

// 覆盖: structuredContent不是对象
TEST_F(ToolManagerTest, OutputSchemaValidation_NotObject)
{
    auto arrayFunc = [](const ServerContext&, const std::string&, const std::string&) -> ToolReturn {
        return R"([1, 2, 3])";
    };
    
    ServerTool tool;
    tool.name = "test";
    tool.outputSchema = R"({"type": "object"})";
    tool.func = arrayFunc;
    toolManager->AddTool(tool);
    
    EXPECT_THROW(toolManager->CallTool("test", R"({})"), std::runtime_error);
}

// 覆盖: structuredContent为空,跳过验证
TEST_F(ToolManagerTest, OutputSchemaValidation_NoStructuredContent)
{
    auto noStructuredFunc = [](const ServerContext&, const std::string&, const std::string&) -> ToolReturn {
        CallToolResult result;
        TextContent text;
        text.text = "no structured";
        result.content.push_back(text);
        return result;
    };
    
    ServerTool tool;
    tool.name = "test";
    tool.outputSchema = R"({"type": "object"})";
    tool.func = noStructuredFunc;
    toolManager->AddTool(tool);
    
    EXPECT_NO_THROW(toolManager->CallTool("test", R"({})"));
}

// 覆盖: isError为true,跳过验证
TEST_F(ToolManagerTest, OutputSchemaValidation_ErrorSkipValidation)
{
    ServerTool tool;
    tool.name = "test";
    tool.outputSchema = R"({"type": "object",
        "properties": {"required": {"type": "string"}}, "required": ["required"]})";
    tool.func = ErrorResultToolFunc;
    toolManager->AddTool(tool);
    
    EXPECT_NO_THROW(toolManager->CallTool("test", R"({})"));
}

static ServerTool MakeInputSchemaTool(const std::string& name, const std::string& schema)
{
    ServerTool tool;
    tool.name = name;
    tool.inputSchema = schema;
    tool.func = TestToolFunc;
    return tool;
}

TEST_F(ToolManagerTest, InputSchemaValidation_Pass)
{
    auto tool = MakeInputSchemaTool("test", R"({
        "type": "object",
        "properties": {"name": {"type": "string"}, "count": {"type": "integer"}},
        "required": ["name"]
    })");
    toolManager->AddTool(tool);

    EXPECT_NO_THROW(toolManager->CallTool("test", R"({"name":"a","count":1})"));
}

TEST_F(ToolManagerTest, InputSchemaValidation_MissingRequired)
{
    auto tool = MakeInputSchemaTool("test", R"({
        "type": "object",
        "properties": {"name": {"type": "string"}},
        "required": ["name"]
    })");
    toolManager->AddTool(tool);

    try {
        (void)toolManager->CallTool("test", R"({})");
        FAIL() << "Expected ToolInputValidationError";
    } catch (const ToolInputValidationError& e) {
        EXPECT_NE(std::string(e.what()).find("Input validation failed"), std::string::npos);
        EXPECT_NE(std::string(e.what()).find("name"), std::string::npos);

        const JsonValue& data = e.Data();
        EXPECT_EQ(data.value("tool", std::string()), "test");
        ASSERT_TRUE(data.contains("error"));
        ASSERT_TRUE(data["error"].is_object());
        const std::string errorMessage = data["error"].value("message", std::string());
        EXPECT_NE(errorMessage.find("name"), std::string::npos);
    }
}

TEST_F(ToolManagerTest, InputSchemaValidation_TypeMismatch)
{
    auto tool = MakeInputSchemaTool("test", R"({
        "type": "object",
        "properties": {"name": {"type": "string"}}
    })");
    toolManager->AddTool(tool);

    try {
        (void)toolManager->CallTool("test", R"({"name":123})");
        FAIL() << "Expected ToolInputValidationError";
    } catch (const ToolInputValidationError& e) {
        const JsonValue& data = e.Data();
        ASSERT_TRUE(data.contains("error"));
        EXPECT_EQ(data["error"].value("instancePath", std::string()), "/name");
    }
}

TEST_F(ToolManagerTest, InputSchemaValidation_RejectAdditionalProperty)
{
    auto tool = MakeInputSchemaTool("test", R"({
        "type": "object",
        "properties": {"name": {"type": "string"}},
        "additionalProperties": false
    })");
    toolManager->AddTool(tool);

    EXPECT_THROW(toolManager->CallTool("test", R"({"name":"a","extra":1})"), ToolInputValidationError);
}

TEST_F(ToolManagerTest, InputSchemaValidation_AllowAdditionalPropertyByDefault)
{
    auto tool = MakeInputSchemaTool("test", R"({
        "type": "object",
        "properties": {"name": {"type": "string"}}
    })");
    toolManager->AddTool(tool);

    EXPECT_NO_THROW(toolManager->CallTool("test", R"({"name":"a","extra":1})"));
}

TEST_F(ToolManagerTest, InputSchemaValidation_NullArguments)
{
    auto tool = MakeInputSchemaTool("test", R"({
        "type": "object",
        "properties": {"name": {"type": "string"}},
        "required": ["name"]
    })");
    toolManager->AddTool(tool);

    EXPECT_THROW(toolManager->CallTool("test", "null"), ToolInputValidationError);
}

static ToolFunc MakeTrackingToolFunc(bool& handlerCalled)
{
    return [&handlerCalled](const ServerContext&, const std::string&, const std::string&) -> ToolReturn {
        handlerCalled = true;
        return CallToolResult{};
    };
}

TEST_F(ToolManagerTest, InputSchemaValidation_AnyOfProbeDoesNotRejectValidInput)
{
    bool handlerCalled = false;
    ServerTool tool;
    tool.name = "test";
    tool.inputSchema = R"({
        "type": "object",
        "anyOf": [
            {"required": ["a"]},
            {"required": ["b"]}
        ]
    })";
    tool.func = MakeTrackingToolFunc(handlerCalled);
    toolManager->AddTool(tool);

    EXPECT_NO_THROW(toolManager->CallTool("test", R"({"b":1})"));
    EXPECT_TRUE(handlerCalled);
}

TEST_F(ToolManagerTest, InputSchemaValidation_OneOfProbeDoesNotRejectValidInput)
{
    bool handlerCalled = false;
    ServerTool tool;
    tool.name = "test";
    tool.inputSchema = R"({
        "type": "object",
        "oneOf": [
            {"required": ["a"]},
            {"required": ["b"]}
        ]
    })";
    tool.func = MakeTrackingToolFunc(handlerCalled);
    toolManager->AddTool(tool);

    EXPECT_NO_THROW(toolManager->CallTool("test", R"({"b":1})"));
    EXPECT_TRUE(handlerCalled);
}

TEST_F(ToolManagerTest, InputSchemaValidation_NotProbeDoesNotRejectValidInput)
{
    bool handlerCalled = false;
    ServerTool tool;
    tool.name = "test";
    tool.inputSchema = R"({
        "type": "object",
        "not": {"required": ["a"]}
    })";
    tool.func = MakeTrackingToolFunc(handlerCalled);
    toolManager->AddTool(tool);

    EXPECT_NO_THROW(toolManager->CallTool("test", R"({"b":1})"));
    EXPECT_TRUE(handlerCalled);
}

TEST_F(ToolManagerTest, InputSchemaValidation_IfThenElseProbeDoesNotRejectValidInput)
{
    bool handlerCalled = false;
    ServerTool tool;
    tool.name = "test";
    tool.inputSchema = R"({
        "type": "object",
        "if": {"required": ["a"]},
        "then": {"required": ["b"]},
        "else": {"required": ["c"]}
    })";
    tool.func = MakeTrackingToolFunc(handlerCalled);
    toolManager->AddTool(tool);

    EXPECT_NO_THROW(toolManager->CallTool("test", R"({"c":1})"));
    EXPECT_TRUE(handlerCalled);
}

} // namespace Mcp