import { IOConnectBrowser } from "@interopio/browser";
import { IOConnectDesktop } from "@interopio/desktop";
import { IoIntelWorkingContext, IoIntelWorkingContextFactoryFunction } from "@interopio/working-context";
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";

export namespace IoIntelMCPCore {

    export interface ClientCapabilities {
        [x: string]: unknown;
        experimental?: {
            [x: string]: unknown;
        };
        sampling?: {
            [x: string]: unknown;
        };
        elicitation?: {
            [x: string]: unknown;
        };
        roots?: {
            [x: string]: unknown;
            listChanged?: boolean;
        };
        extensions?: {
            [key: string]: unknown;
            "io.modelcontextprotocol/ui"?: {
                mimeTypes?: string[];
                protocolVersion?: string;
            };
        };
    }

    export interface StaticToolConfig {
        description: string;
        inputSchema: Record<string, any>;
        outputSchema: Record<string, any>;
        title?: string;
        annotations?: {
            title?: string;
            readOnlyHint?: boolean;
            destructiveHint?: boolean;
            idempotentHint?: boolean;
            openWorldHint?: boolean;
        }
        _meta?: ToolMeta;
    }

    export interface StaticToolDefinition {
        availability: "variable" | "constant";
        name: string;
        config: StaticToolConfig;
    }

    export interface StaticMethodToolConfig extends StaticToolDefinition {
        interop: {
            methodName: string;
            responseTimeoutMs?: number;
            allowedApplications?: string[]; // default: all applications allowed
        }
    }

    // recommended input schema to have type: string, as this is passed as context.type
    export interface StaticIntentToolConfig extends StaticToolDefinition {
        interop: {
            intentName: string;
            responseTimeoutMs?: number;
            resolutionStrategy?: "mcp" | "io_connect"; // default: mcp
            allowedApplications?: string[]; // default: all applications allowed
        }
    }

    export interface DynamicToolsConfig {
        methods?: {
            enabled?: boolean; // default: true
            guard?(method: IOConnectBrowser.Interop.Method, server: IOConnectBrowser.Interop.Instance): boolean;
        }
    }

    export interface StaticToolsConfig {
        methods?: StaticMethodToolConfig[];
        intents?: StaticIntentToolConfig[];
    }

    export interface SystemToolConfig {
        searchApps?: {
            enabled?: boolean; // default: true
            overrides?: {
                name?: string;
                description?: string;
            };
            guard?(app: { name: string }): boolean;
        };
        searchWorkspaces?: {
            enabled?: boolean; // default: true
            overrides?: {
                name?: string;
                description?: string;
            };
            guard?(workspace: { name: string }): boolean;
        };
        startApps?: {
            enabled?: boolean; // default: true
            overrides?: {
                name?: string;
                description?: string;
            }
        };
        startWorkspaces?: {
            enabled?: boolean; // default: true
            overrides?: {
                name?: string;
                description?: string;
            }
        };
        getWorkspaceWidget?: {
            enabled?: boolean; // default: true
            overrides?: {
                name?: string;
                description?: string;
            }
        }
    }

    export interface McpServerConfig {
        name: string;
        title?: string | undefined;
        tools?: {
            dynamic?: DynamicToolsConfig;
            static?: StaticToolsConfig;
            system?: SystemToolConfig;
        }
    }

    export interface McpTransportConfig {
        type: "stdio" | "http" | "web";
    }

    export interface WorkingContextConfig {
        factory: IoIntelWorkingContextFactoryFunction;
        config?: IoIntelWorkingContext.Config;
    }

    export interface MCPCore {
        id: string;
        instance: McpServer;
    }

    export interface Config {
        server: McpServerConfig;
        licenseKey: string;
        transport: McpTransportConfig;
        context?: WorkingContextConfig;
    }

    export interface API {
        createMCPInstance(clientCapabilities: ClientCapabilities): MCPCore;
        removeMCPInstance(id: string): void;
    }

    export interface ToolUIMetadata {
        resourceUri?: string;
        visibility?: ("model" | "app")[];
        csp?: {
            connectDomains?: string[];
            resourceDomains?: string[];
            frameDomains?: string[];
            baseUriDomains?: string[];
        };
    }

    export interface ToolMeta {
        io_connect_system_tool?: boolean;
        ui?: ToolUIMetadata;
        [key: string]: unknown;
    }
}

export type IoIntelMCPCoreFactoryFunction = (io: IOConnectBrowser.API | IOConnectDesktop.API, config: IoIntelMCPCore.Config) => Promise<IoIntelMCPCore.API>;

export declare const IoIntelMCPCoreFactory: IoIntelMCPCoreFactoryFunction;