import { z } from 'zod';
import { handleSqlResponse, executeSqlWithFallback } from './utils.js';
import type { ToolContext } from './types.js';

// Schema for edge function details output
const EdgeFunctionDetailsSchema = z.object({
    id: z.string().uuid(),
    name: z.string(),
    slug: z.string(),
    status: z.string().nullable(),
    version: z.number().nullable(),
    created_at: z.string().nullable(),
    updated_at: z.string().nullable(),
    verify_jwt: z.boolean().nullable(),
    import_map: z.boolean().nullable(),
});
const GetEdgeFunctionDetailsOutputSchema = z.array(EdgeFunctionDetailsSchema);
type GetEdgeFunctionDetailsOutput = z.infer<typeof EdgeFunctionDetailsSchema> | null;

// Input schema
const GetEdgeFunctionDetailsInputSchema = z.object({
    function_identifier: z.string().describe('The function ID (UUID) or slug to look up'),
});
type GetEdgeFunctionDetailsInput = z.infer<typeof GetEdgeFunctionDetailsInputSchema>;

// Static JSON Schema for MCP capabilities
const mcpInputSchema = {
    type: 'object',
    properties: {
        function_identifier: {
            type: 'string',
            description: 'The function ID (UUID) or slug to look up',
        },
    },
    required: ['function_identifier'],
};

// Tool definition
export const getEdgeFunctionDetailsTool = {
    name: 'get_edge_function_details',
    description: 'Gets detailed information about a specific Supabase Edge Function by ID or slug. Returns null if not found or edge functions are not available.',
    inputSchema: GetEdgeFunctionDetailsInputSchema,
    mcpInputSchema: mcpInputSchema,
    outputSchema: EdgeFunctionDetailsSchema.nullable(),
    execute: async (input: GetEdgeFunctionDetailsInput, context: ToolContext): Promise<GetEdgeFunctionDetailsOutput> => {
        const client = context.selfhostedClient;
        const { function_identifier } = input;

        // First check if supabase_functions schema exists
        const checkSchemaSql = `
            SELECT EXISTS (
                SELECT 1 FROM pg_catalog.pg_namespace WHERE nspname = 'supabase_functions'
            ) AS exists
        `;

        const schemaCheckResult = await executeSqlWithFallback(client, checkSchemaSql, true);

        if (Array.isArray(schemaCheckResult) && schemaCheckResult.length > 0) {
            const exists = schemaCheckResult[0]?.exists;
            if (!exists) {
                context.log('supabase_functions schema not found - Edge Functions may not be available in this installation', 'info');
                return null;
            }
        } else {
            context.log('Could not verify supabase_functions schema', 'warn');
            return null;
        }

        // Check if the functions table exists
        const checkTableSql = `
            SELECT EXISTS (
                SELECT 1 FROM pg_catalog.pg_tables
                WHERE schemaname = 'supabase_functions' AND tablename = 'functions'
            ) AS exists
        `;

        const tableCheckResult = await executeSqlWithFallback(client, checkTableSql, true);

        if (Array.isArray(tableCheckResult) && tableCheckResult.length > 0) {
            const exists = tableCheckResult[0]?.exists;
            if (!exists) {
                context.log('supabase_functions.functions table not found', 'info');
                return null;
            }
        } else {
            context.log('Could not verify functions table', 'warn');
            return null;
        }

        // Escape single quotes in the identifier to prevent SQL injection
        const escapedIdentifier = function_identifier.replace(/'/g, "''");

        // Query edge function details - try matching both id and slug
        const getEdgeFunctionDetailsSql = `
            SELECT
                id,
                name,
                slug,
                status,
                version,
                created_at::text,
                updated_at::text,
                verify_jwt,
                import_map
            FROM supabase_functions.functions
            WHERE id::text = '${escapedIdentifier}' OR slug = '${escapedIdentifier}'
            LIMIT 1
        `;

        const result = await executeSqlWithFallback(client, getEdgeFunctionDetailsSql, true);
        const functions = handleSqlResponse(result, GetEdgeFunctionDetailsOutputSchema);

        if (functions.length === 0) {
            context.log(`Edge function not found: ${function_identifier}`, 'info');
            return null;
        }

        return functions[0];
    },
};