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

// Schema for updated bucket output
const UpdatedBucketSchema = z.object({
    id: z.string(),
    name: z.string(),
    public: z.boolean(),
    file_size_limit: z.number().nullable(),
    allowed_mime_types: z.array(z.string()).nullable(),
});
const UpdateStorageConfigOutputSchema = z.object({
    success: z.boolean(),
    bucket: UpdatedBucketSchema.nullable(),
    message: z.string(),
});
type UpdateStorageConfigOutput = z.infer<typeof UpdateStorageConfigOutputSchema>;

// Input schema
const UpdateStorageConfigInputSchema = z.object({
    bucket_id: z.string().describe('The bucket ID to update'),
    file_size_limit: z.number().min(0).optional().describe('Maximum file size in bytes (0 or null for no limit)'),
    allowed_mime_types: z.array(z.string()).optional().describe('Array of allowed MIME types (e.g., ["image/png", "image/jpeg"]). Empty array means all types allowed.'),
    public: z.boolean().optional().describe('Whether the bucket is publicly accessible'),
});
type UpdateStorageConfigInput = z.infer<typeof UpdateStorageConfigInputSchema>;

// Static JSON Schema for MCP capabilities
const mcpInputSchema = {
    type: 'object',
    properties: {
        bucket_id: {
            type: 'string',
            description: 'The bucket ID to update',
        },
        file_size_limit: {
            type: 'number',
            minimum: 0,
            description: 'Maximum file size in bytes (0 or null for no limit)',
        },
        allowed_mime_types: {
            type: 'array',
            items: { type: 'string' },
            description: 'Array of allowed MIME types (e.g., ["image/png", "image/jpeg"]). Empty array means all types allowed.',
        },
        public: {
            type: 'boolean',
            description: 'Whether the bucket is publicly accessible',
        },
    },
    required: ['bucket_id'],
};

// Tool definition
export const updateStorageConfigTool = {
    name: 'update_storage_config',
    description: 'Updates storage configuration for a Supabase Storage bucket. Can modify file size limits, allowed MIME types, and public/private status.',
    privilegeLevel: 'privileged' as ToolPrivilegeLevel,
    inputSchema: UpdateStorageConfigInputSchema,
    mcpInputSchema: mcpInputSchema,
    outputSchema: UpdateStorageConfigOutputSchema,
    execute: async (input: UpdateStorageConfigInput, context: ToolContext): Promise<UpdateStorageConfigOutput> => {
        const client = context.selfhostedClient;
        const { bucket_id, file_size_limit, allowed_mime_types, public: isPublic } = input;

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

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

        if (!Array.isArray(schemaCheckResult) || schemaCheckResult.length === 0 || !schemaCheckResult[0]?.exists) {
            return {
                success: false,
                bucket: null,
                message: 'Storage schema not found - Storage may not be configured',
            };
        }

        // Check if bucket exists
        const escapedBucketId = bucket_id.replace(/'/g, "''");
        const checkBucketSql = `
            SELECT EXISTS (
                SELECT 1 FROM storage.buckets WHERE id = '${escapedBucketId}'
            ) AS exists
        `;

        const bucketCheckResult = await executeSqlWithFallback(client, checkBucketSql, true);

        if (!Array.isArray(bucketCheckResult) || bucketCheckResult.length === 0 || !bucketCheckResult[0]?.exists) {
            return {
                success: false,
                bucket: null,
                message: `Bucket '${bucket_id}' not found`,
            };
        }

        // Build update query
        const updates: string[] = [];

        if (file_size_limit !== undefined) {
            updates.push(`file_size_limit = ${file_size_limit === 0 ? 'NULL' : file_size_limit}`);
        }

        if (allowed_mime_types !== undefined) {
            if (allowed_mime_types.length === 0) {
                updates.push('allowed_mime_types = NULL');
            } else {
                const escapedTypes = allowed_mime_types.map((t) => `'${t.replace(/'/g, "''")}'`).join(', ');
                updates.push(`allowed_mime_types = ARRAY[${escapedTypes}]`);
            }
        }

        if (isPublic !== undefined) {
            updates.push(`public = ${isPublic}`);
        }

        if (updates.length === 0) {
            return {
                success: false,
                bucket: null,
                message: 'No updates specified. Provide at least one of: file_size_limit, allowed_mime_types, or public',
            };
        }

        updates.push('updated_at = NOW()');

        const updateSql = `
            UPDATE storage.buckets
            SET ${updates.join(', ')}
            WHERE id = '${escapedBucketId}'
            RETURNING id, name, public, file_size_limit, allowed_mime_types
        `;

        const updateResult = await executeSqlWithFallback(client, updateSql, false);

        if (isSqlErrorResponse(updateResult)) {
            return {
                success: false,
                bucket: null,
                message: `Failed to update bucket: ${updateResult.error.message}`,
            };
        }

        const resultSchema = z.array(
            z.object({
                id: z.string(),
                name: z.string(),
                public: z.boolean(),
                file_size_limit: z.number().nullable(),
                allowed_mime_types: z.array(z.string()).nullable(),
            })
        );

        try {
            const updatedBuckets = handleSqlResponse(updateResult, resultSchema);

            if (updatedBuckets.length === 0) {
                return {
                    success: false,
                    bucket: null,
                    message: 'Update executed but no rows returned',
                };
            }

            return {
                success: true,
                bucket: updatedBuckets[0],
                message: `Successfully updated bucket '${bucket_id}'`,
            };
        } catch (error) {
            return {
                success: false,
                bucket: null,
                message: `Failed to parse update result: ${error}`,
            };
        }
    },
};