import { NextRequest, NextResponse } from 'next/server';
import { adminDb } from '@/lib/firebase-admin';
import { COLLECTIONS } from '@/types/firestore';
import { encrypt, decrypt } from '@/utils/encryption';
import { FieldValue } from 'firebase-admin/firestore';
import { verifyMember } from '@/lib/auth-middleware';

export async function GET(req: NextRequest) {
    // Firebase ID Token 검증
    const authResult = await verifyMember(req);
    if (authResult instanceof NextResponse) return authResult;
    const { uid } = authResult;

    try {
        const userDoc = await adminDb.collection(COLLECTIONS.USERS).doc(uid).get();
        if (!userDoc.exists) {
            return NextResponse.json({ geminiApiKey: null });
        }

        const data = userDoc.data();
        const encryptedKey = data?.aiSettings?.geminiApiKey;
        const selectedModel = data?.aiSettings?.selectedModel || 'models/gemini-1.5-pro';

        if (encryptedKey) {
            try {
                const decryptedKey = decrypt(encryptedKey);

                // Ping to Google Gemini API to get models
                const res = await fetch(`https://generativelanguage.googleapis.com/v1beta/models?key=${decryptedKey}`);

                if (res.ok) {
                    const modelsData = await res.json();

                    // Filter gemini models that support text generation
                    const availableModels = modelsData.models
                        .filter((m: any) => m.name.includes('gemini') && m.supportedGenerationMethods?.includes('generateContent'))
                        .map((m: any) => m.name);

                    return NextResponse.json({
                        hasKey: true,
                        status: 'ok',
                        availableModels,
                        selectedModel
                    });
                } else {
                    return NextResponse.json({
                        hasKey: true,
                        status: 'error',
                        errorDetail: 'Invalid API Key or API Error'
                    });
                }
            } catch (e) {
                console.error("Decryption or Ping failed:", e);
                return NextResponse.json({ hasKey: true, status: 'error', errorDetail: 'Decryption Error' });
            }
        }

        return NextResponse.json({ hasKey: false });
    } catch (error: any) {
        console.error('Get AI Settings Error:', error);
        return NextResponse.json({ error: error.message || '설정 로딩 중 오류가 발생했습니다.' }, { status: 500 });
    }
}

export async function POST(req: NextRequest) {
    try {
        const body = await req.json();
        const { geminiApiKey, selectedModel } = body;

        // Firebase ID Token 검증
        const authResult = await verifyMember(req);
        if (authResult instanceof NextResponse) return authResult;
        const { uid } = authResult;

        const updates: any = {};

        if (selectedModel) {
            updates['aiSettings.selectedModel'] = selectedModel;
        }

        if (geminiApiKey === null || geminiApiKey === "") {
            // 키 삭제
            updates['aiSettings.geminiApiKey'] = FieldValue.delete();
        } else if (geminiApiKey && geminiApiKey !== '****************') {
            // 새 키 암호화
            updates['aiSettings.geminiApiKey'] = encrypt(geminiApiKey);
        }

        updates['aiSettings.updatedAt'] = new Date();

        await adminDb.collection(COLLECTIONS.USERS).doc(uid).update(updates);

        return NextResponse.json({ success: true });
    } catch (error: any) {
        console.error('Save AI Settings Error:', error);
        return NextResponse.json({ error: error.message || '설정 저장 중 오류가 발생했습니다.' }, { status: 500 });
    }
}