import { IResolvers } from 'common/server';
import { extension } from 'mime-types';

export const FileInfoResolver = (): IResolvers => ({
    Node: {
        // eslint-disable-next-line no-underscore-dangle
        __resolveType(src) {
            // return type appended in parent resolver
            // return (src as unknown as { refType: FileRefType }).refType;
            return (src as any).refType;
        },
    },
    FileInfo: {
        extension(src) {
            return extension(src.mimeType);
        },
    },
    Query: {
        async filesInfo(src, args, { fileInfoService }) {
            const data = await fileInfoService.getAll(args as any);
            const totalCount = await fileInfoService.count(args?.criteria);
            return {
                totalCount,
                data,
            } as any;
        },
        fileInfo(src, { id }, { fileInfoService }) {
            return fileInfoService.get(id) as any;
        },
        async createDownloadSignedUrl(src: any, args: any, context: any) {
            const { s3KeyOrUrl, expiresIn, bucketName, projectId, environmentTag } = args;
            const { fileInfoService, keyMgmtSecretService, awsS3Service } = context;

            try {
                // If projectId is provided, fetch AWS credentials from project secrets
                if (projectId && keyMgmtSecretService && awsS3Service) {
                    // Use provided environmentTag or fallback to 'DEVELOPMENT' for backward compatibility
                    const envTag = environmentTag || 'DEVELOPMENT';

                    const [regionResult, accessKeyResult, secretKeyResult] = await Promise.all([
                        keyMgmtSecretService.getSecret(projectId, 'AWS_S3_REGION', envTag),
                        keyMgmtSecretService.getSecret(projectId, 'AWS_S3_ACCESS_KEY_ID', envTag),
                        keyMgmtSecretService.getSecret(projectId, 'AWS_S3_SECRET_ACCESS_KEY', envTag),
                    ]);

                    const awsRegion = regionResult?.value || 'ca-central-1';
                    const awsAccessKeyId = accessKeyResult?.value;
                    const awsSecretAccessKey = secretKeyResult?.value;

                    if (!awsAccessKeyId || !awsSecretAccessKey) {
                        throw new Error('AWS credentials not found in project secrets');
                    }

                    // Create a temporary S3 client with project-specific credentials
                    const { S3Client } = await import('@aws-sdk/client-s3');
                    const { getSignedUrl } = await import('@aws-sdk/s3-request-presigner');
                    const { GetObjectCommand } = await import('@aws-sdk/client-s3');

                    const s3Client = new S3Client({
                        region: awsRegion,
                        credentials: {
                            accessKeyId: awsAccessKeyId,
                            secretAccessKey: awsSecretAccessKey,
                        },
                    });

                    // Parse the S3 URL
                    const parsed = awsS3Service.parseS3Url(s3KeyOrUrl);

                    if (!parsed || !parsed.bucket || !parsed.key) {
                        throw new Error('Invalid S3 URL format');
                    }

                    const presignedUrl = await getSignedUrl(
                        s3Client as any,
                        new GetObjectCommand({
                            Bucket: parsed.bucket,
                            Key: parsed.key,
                        }),
                        {
                            expiresIn: expiresIn || 300,
                        },
                    );

                    return presignedUrl;
                } else {
                    throw new Error('Project ID is required for S3 access');
                }
            } catch (error) {
                throw error;
            }
        },
    },
});