package mcp.tools.helper;

import io.modelcontextprotocol.spec.McpSchema;
import mcp.util.Result;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import java.util.HashMap;
import java.util.Map;

import static org.junit.jupiter.api.Assertions.*;

public class ToolQueryValidatorTest {
    private ToolQueryValidator validator;

    @BeforeEach
    void setUp() {
        validator = new ToolQueryValidator();
    }

    @Test
    void testRequiredFieldsSuccess() {
        McpSchema.JsonSchema schema = new SchemaBuilder()
                .addProperty("name", "string", "User name")
                .required("name")
                .build();

        Map<String, Object> arguments = new HashMap<>();
        arguments.put("name", "John Doe");

        Result<Void, Exception> result = validator.validate(schema, arguments);
        assertTrue(result.isOk());
    }

    @Test
    void testRequiredFieldsMissing() {
        McpSchema.JsonSchema schema = new SchemaBuilder()
                .addProperty("name", "string", "User name")
                .required("name")
                .build();

        Map<String, Object> arguments = new HashMap<>();

        Result<Void, Exception> result = validator.validate(schema, arguments);
        assertTrue(result.isError());
        assertTrue(result.err().unwrap().getMessage().contains("Missing required argument: name"));
    }

    @Test
    void testTypeValidationSuccess() {
        McpSchema.JsonSchema schema = new SchemaBuilder()
                .addProperty("age", "integer", "User age")
                .build();

        Map<String, Object> arguments = new HashMap<>();
        arguments.put("age", 30);

        Result<Void, Exception> result = validator.validate(schema, arguments);
        assertTrue(result.isOk());
    }

    @Test
    void testTypeValidationFailure() {
        McpSchema.JsonSchema schema = new SchemaBuilder()
                .addProperty("age", "integer", "User age")
                .build();

        Map<String, Object> arguments = new HashMap<>();
        arguments.put("age", "thirty");

        Result<Void, Exception> result = validator.validate(schema, arguments);
        assertTrue(result.isError());
        assertTrue(result.err().unwrap().getMessage().contains("invalid type"));
    }

    @Test
    void testCustomValidator() {
        McpSchema.JsonSchema schema = new SchemaBuilder().build();
        Map<String, Object> arguments = new HashMap<>();

        validator.addValidator((s, args) -> Result.Err(new Exception("Custom error")));

        Result<Void, Exception> result = validator.validate(schema, arguments);
        assertTrue(result.isError());
        assertEquals("Custom error", result.err().unwrap().getMessage());
    }

    @Test
    void testIntegerValidation() {
        McpSchema.JsonSchema schema = new SchemaBuilder()
                .addProperty("count", "integer", "item count")
                .build();

        Map<String, Object> arguments = new HashMap<>();

        arguments.put("count", 10);
        assertTrue(validator.validate(schema, arguments).isOk(), "Integer should be valid");

        arguments.put("count", 10L);
        assertTrue(validator.validate(schema, arguments).isOk(), "Long should be valid as integer");

        arguments.put("count", 10.0);
        assertTrue(validator.validate(schema, arguments).isOk(), "Double 10.0 should be valid as integer");

        arguments.put("count", 10.5);
        assertTrue(validator.validate(schema, arguments).isError(), "Double 10.5 should NOT be valid as integer");
    }
}