import express from 'express';
import fs from 'fs/promises';
import path from 'path';
import { fileURLToPath } from 'url';
import { GoogleGenAI, Type } from '@google/genai';
import * as store from './store.ts';
import type { TestQuestion, TestRecord } from './store.ts';

const __dirname = path.dirname(fileURLToPath(import.meta.url));

const API_KEY = process.env.GEMINI_API_KEY;
if (!API_KEY) {
    console.error(
        'GEMINI_API_KEY 가 설정되지 않았습니다. LG/.env 파일에 GEMINI_API_KEY=... 를 추가하세요.\n' +
            '키 발급: https://aistudio.google.com/apikey'
    );
    process.exit(1);
}

const ai = new GoogleGenAI({ apiKey: API_KEY });
const MODEL = process.env.GEMINI_MODEL ?? 'gemini-3.5-flash-lite';

const chapters: Record<string, Record<string, string[]>> = JSON.parse(
    await fs.readFile(path.join(__dirname, 'chapter.json'), 'utf8')
);
await store.load();

const app = express();
app.use(express.json({ limit: '1mb' }));
app.use('/public', express.static(path.join(__dirname, 'public')));

app.get('/', (_req, res) => {
    res.sendFile(path.join(__dirname, 'public', 'index.html'));
});

async function generate(options: {
    prompt?: string;
    contents?: unknown;
    systemInstruction: string;
    schema?: object;
    maxOutputTokens?: number;
    temperature?: number;
}) {
    const response = await ai.models.generateContent({
        model: MODEL,
        contents: (options.contents ?? options.prompt) as never,
        config: {
            systemInstruction: options.systemInstruction,
            temperature: options.temperature ?? 0.8,
            maxOutputTokens: options.maxOutputTokens ?? 2048,
            ...(options.schema
                ? { responseMimeType: 'application/json', responseSchema: options.schema }
                : {}),
        },
    });

    const text = response.text?.trim();
    if (!text) {
        const reason = response.candidates?.[0]?.finishReason ?? 'UNKNOWN';
        console.error('모델이 빈 응답을 반환했습니다.', reason, response.usageMetadata);
        throw new HttpError(502, `AI가 빈 응답을 보냈습니다 (${reason}). 다시 시도해 주세요.`);
    }
    return text;
}

async function generateJson<T>(options: Parameters<typeof generate>[0] & { prompt: string; schema: object }) {
    return JSON.parse(await generate(options)) as T;
}

const route =
    (handler: (req: express.Request) => Promise<unknown>) =>
    async (req: express.Request, res: express.Response) => {
        try {
            res.json(await handler(req));
        } catch (err) {
            if (err instanceof HttpError) {
                res.status(err.status).json({ error: err.message });
                return;
            }
            console.error(err);
            res.status(502).json({
                error: 'AI 응답을 가져오지 못했습니다. 잠시 후 다시 시도해 주세요.',
            });
        }
    };

class HttpError extends Error {
    constructor(readonly status: number, message: string) {
        super(message);
    }
}

const QUESTION_PROPERTIES = {
    question: { type: Type.STRING },
    correct_answer: { type: Type.STRING },
    incorrect_answers: { type: Type.ARRAY, items: { type: Type.STRING } },
};

const QUESTIONS_SCHEMA = {
    type: Type.OBJECT,
    properties: {
        results: {
            type: Type.ARRAY,
            items: {
                type: Type.OBJECT,
                properties: QUESTION_PROPERTIES,
                required: ['question', 'correct_answer', 'incorrect_answers'],
            },
        },
    },
    required: ['results'],
};

const TWIN_SCHEMA = {
    type: Type.OBJECT,
    properties: QUESTION_PROPERTIES,
    required: ['question', 'correct_answer', 'incorrect_answers'],
};

const FEEDBACK_SCHEMA = {
    type: Type.OBJECT,
    properties: {
        summary: { type: Type.STRING },
        detail: { type: Type.STRING },
        recommendation: { type: Type.STRING },
    },
    required: ['summary', 'detail', 'recommendation'],
};

const DIFFICULTY_KO: Record<string, string> = {
    easy: '쉬움 (기본 개념 확인)',
    medium: '보통 (개념 응용)',
    hard: '어려움 (여러 개념의 종합 및 분석)',
};

interface GeneratedQuestion {
    question: string;
    correct_answer: string;
    incorrect_answers: string[];
}

const isUsable = (q: GeneratedQuestion) =>
    Boolean(q?.question && q?.correct_answer && q?.incorrect_answers?.length);

app.get('/api/chapters', (_req, res) => res.json(chapters));

app.post(
    '/api/questions',
    route(async (req) => {
        const school = String(req.body?.school ?? '');
        const subject = String(req.body?.subject ?? '');
        const chapter = String(req.body?.chapter ?? '');
        if (!chapters[school]?.[subject]?.includes(chapter)) {
            throw new HttpError(400, '학교 종류·과목·단원을 다시 선택해 주세요.');
        }
        const difficulty = String(req.body?.difficulty ?? 'medium');
        const amount = Math.min(Math.max(Number(req.body?.amount) || 5, 1), 20);

        const { results = [] } = await generateJson<{ results?: GeneratedQuestion[] }>({
            systemInstruction:
                '당신은 학생의 메타인지 학습을 돕는 한국 중·고등학교 교사입니다. ' +
                '교육과정에 맞는 정확한 4지선다 객관식 문제를 출제합니다. ' +
                '정답은 반드시 하나이며, 오답도 그럴듯해야 합니다. 모든 텍스트는 한국어로 작성합니다.',
            prompt:
                `학교: ${school}\n과목: ${subject}\n단원: ${chapter}\n` +
                `난이도: ${DIFFICULTY_KO[difficulty] ?? DIFFICULTY_KO.medium}\n` +
                `문항 수: ${amount}\n\n` +
                '위 조건으로 서로 겹치지 않는 4지선다 문제를 만들어 주세요. ' +
                '단원 안에서도 세부 개념이 골고루 나오게 하고, ' +
                'incorrect_answers 에는 오답 3개만 넣고, 보기 앞에 번호나 기호를 붙이지 마세요.',
            schema: QUESTIONS_SCHEMA,
            temperature: 1.0,
            maxOutputTokens: 8192,
        });

        const usable = results.filter(isUsable).slice(0, amount);
        if (!usable.length) throw new Error('빈 문항 응답');
        return { results: usable };
    })
);

app.post(
    '/api/tests',
    route(async (req) => {
        const body = req.body ?? {};
        const questions: TestQuestion[] = (body.questions ?? []).map((q: any) => ({
            question: String(q.question ?? ''),
            correct_answer: String(q.correct_answer ?? ''),
            incorrect_answers: (q.incorrect_answers ?? []).map(String),
            user_answer: q.user_answer ?? null,
            confidence: q.confidence ?? null,
            is_correct: q.user_answer === q.correct_answer,
            explanation: null,
            conversation: [],
            children: [],
        }));

        if (!questions.length) throw new HttpError(400, '저장할 문항이 없습니다.');

        const correct = questions.filter((q) => q.is_correct).length;
        const record: TestRecord = {
            id: `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`,
            createdAt: new Date().toISOString(),
            student: String(body.student || '학생').slice(0, 30),
            school: String(body.school ?? ''),
            subject: String(body.subject ?? ''),
            chapter: String(body.chapter ?? ''),
            difficulty: String(body.difficulty ?? 'medium'),
            score: {
                total: questions.length,
                correct,
                percent: Math.round((correct / questions.length) * 100),
                overconfident: questions.filter((q) => q.confidence === 'sure' && !q.is_correct)
                    .length,
                lucky: questions.filter((q) => q.confidence !== 'sure' && q.is_correct).length,
                solid: questions.filter((q) => q.confidence === 'sure' && q.is_correct).length,
            },
            feedback: null,
            questions,
        };

        await store.save(record);
        return record;
    })
);

app.get('/api/tests', (_req, res) => res.json({ tests: store.listSummaries() }));

app.get('/api/tests/:id', (req, res) => {
    const record = store.get(req.params.id);
    if (!record) {
        res.status(404).json({ error: '기록을 찾을 수 없습니다.' });
        return;
    }
    res.json(record);
});

function findQuestion(req: express.Request) {
    const record = store.get(String(req.params.id));
    const index = Number(req.params.index);
    const question = record?.questions[index];
    if (!record || !question) throw new HttpError(404, '문항을 찾을 수 없습니다.');
    return { record, index, question };
}

app.post(
    '/api/tests/:id/questions/:index/explain',
    route(async (req) => {
        const { record, index, question } = findQuestion(req);
        if (question.explanation) return { explanation: question.explanation };

        const explanation = await generate({
            systemInstruction:
                'CogMind 는 학생의 메타인지를 돕는 피드백 도우미입니다. 한국어 존댓말로, 250자 내외로 답합니다.\n' +
                '1) 정답의 근거를 한 문장으로 설명합니다.\n' +
                '2) 틀렸다면 학생이 어디서 잘못 생각했는지 짚어 줍니다.\n' +
                '3) 확신했는데 틀렸다면 그 개념을 다시 확인해야 한다고 분명히 말합니다. ' +
                '찍어서 맞혔다면 아직 아는 것이 아니라고 알려 줍니다.\n' +
                '마크다운 기호 없이 자연스러운 문단으로 작성하세요.',
            prompt:
                `단원: ${record.subject} · ${record.chapter}\n` +
                `문제: ${question.question}\n` +
                `정답: ${question.correct_answer}\n` +
                `학생의 답: ${question.user_answer ?? '(무응답)'} (${
                    question.is_correct ? '정답' : '오답'
                })\n` +
                `학생이 밝힌 확신도: ${CONFIDENCE_KO[question.confidence ?? ''] ?? '미응답'}`,
            temperature: 0.6,
            maxOutputTokens: 1024,
        });

        await store.setExplanation(record.id, index, explanation);
        return { explanation };
    })
);

const CONFIDENCE_KO: Record<string, string> = {
    sure: '확실해요',
    unsure: '애매해요',
    guess: '찍었어요',
};

const CHAT_WINDOW = 20;

app.post(
    '/api/tests/:id/questions/:index/ask',
    route(async (req) => {
        const { record, index, question } = findQuestion(req);
        if (!question.explanation) throw new HttpError(400, '먼저 AI 해설을 생성해 주세요.');

        const message = String(req.body?.message ?? '').trim().slice(0, 1000);
        if (!message) throw new HttpError(400, '질문을 입력해 주세요.');

        const contents = [
            ...question.conversation.slice(-CHAT_WINDOW).map((m) => ({
                role: m.role === 'assistant' ? 'model' : 'user',
                parts: [{ text: m.content }],
            })),
            { role: 'user', parts: [{ text: message }] },
        ];

        const answer = await generate({
            systemInstruction:
                'CogMind 는 학생이 방금 푼 문제의 해설에 이어서 질문할 수 있는 1:1 튜터입니다. ' +
                '한국어 존댓말로, 400자 안쪽으로 답합니다. ' +
                '학생이 스스로 이해하도록 개념을 짚어 주고, 필요하면 예시를 듭니다. ' +
                '문제와 관계없는 질문에는 이 문제와 관련해 도울 수 있다고 안내하세요. ' +
                '모르는 것은 아는 척하지 말고 모른다고 말합니다. ' +
                '마크다운 기호 없이 자연스러운 문단으로 작성하세요.\n\n' +
                '--- 학생이 푼 문제 ---\n' +
                `단원: ${record.school} ${record.subject} · ${record.chapter}\n` +
                `문제: ${question.question}\n` +
                `보기: ${[question.correct_answer, ...question.incorrect_answers].join(', ')}\n` +
                `정답: ${question.correct_answer}\n` +
                `학생의 답: ${question.user_answer ?? '(무응답)'} (${
                    question.is_correct ? '정답' : '오답'
                })\n` +
                `학생이 밝힌 확신도: ${CONFIDENCE_KO[question.confidence ?? ''] ?? '미응답'}\n` +
                `학생이 읽은 해설: ${question.explanation}\n`,
            contents,
            temperature: 0.6,
            maxOutputTokens: 4096,
        });

        const now = new Date().toISOString();
        const messages = [
            { role: 'user' as const, content: message, createdAt: now },
            { role: 'assistant' as const, content: answer, createdAt: new Date().toISOString() },
        ];
        await store.addMessages(record.id, index, messages);
        return { messages };
    })
);

app.post(
    '/api/tests/:id/questions/:index/twin',
    route(async (req) => {
        const { record, index, question } = findQuestion(req);

        const twin = await generateJson<GeneratedQuestion>({
            systemInstruction:
                '당신은 쌍둥이 문제를 만드는 교사입니다. 원본 문제와 같은 개념·난이도를 묻되, ' +
                '소재와 숫자는 다른 새 4지선다 문제를 하나 만듭니다. ' +
                'incorrect_answers 에는 오답 3개만 넣고, 보기 앞에 번호나 기호를 붙이지 마세요. ' +
                '모든 텍스트는 한국어로 작성합니다.',
            prompt:
                `단원: ${record.subject} · ${record.chapter}\n` +
                `원본 문제: ${question.question}\n원본 정답: ${question.correct_answer}\n` +
                `이미 만든 쌍둥이 문제 ${record.questions[index]!.children.length}개와도 겹치지 않게 해주세요.`,
            schema: TWIN_SCHEMA,
            temperature: 1.0,
            maxOutputTokens: 2048,
        });

        if (!isUsable(twin)) throw new Error('빈 쌍둥이 문제 응답');

        const child = { ...twin, createdAt: new Date().toISOString() };
        await store.addChild(record.id, index, child);
        return { twin: child };
    })
);

app.post(
    '/api/tests/:id/feedback',
    route(async (req) => {
        const record = store.get(String(req.params.id));
        if (!record) throw new HttpError(404, '기록을 찾을 수 없습니다.');
        if (record.feedback) return { feedback: record.feedback };

        const lines = record.questions
            .map(
                (q, i) =>
                    `${i + 1}. ${q.question}\n` +
                    `   정답: ${q.correct_answer} / 학생의 답: ${q.user_answer ?? '무응답'} ` +
                    `(${q.is_correct ? 'O' : 'X'}, 확신도: ${CONFIDENCE_KO[q.confidence ?? ''] ?? '미응답'})`
            )
            .join('\n');

        const feedback = await generateJson<TestRecord['feedback']>({
            systemInstruction:
                'CogMind 는 학생의 메타인지를 진단하는 학습 코치입니다. 한국어 존댓말로 작성합니다.\n' +
                'summary: 학생 이름을 넣어 어느 개념이 부족한지 한 문장으로 진단합니다. ' +
                '예) "OO학생은 미분 부분에 부족함이 있습니다."\n' +
                'detail: 무엇은 되고 무엇이 안 되는지 근거를 들어 2~3문장으로 씁니다. ' +
                '특히 확신했는데 틀린 문항은 "안다고 착각한 개념"으로 분명히 짚어 줍니다. ' +
                '찍어서 맞힌 문항은 아직 아는 것이 아니라고 알려 줍니다.\n' +
                'recommendation: 구체적인 교재·단원·학습 방법을 제시하고, ' +
                '마지막에 CogMind 에서 맞춤형 문제를 더 풀어 보라고 권합니다.\n' +
                '마크다운 기호 없이 자연스러운 문장으로 작성하세요.',
            prompt:
                `학생 이름: ${record.student}\n` +
                `범위: ${record.school} ${record.subject} · ${record.chapter} (난이도 ${
                    DIFFICULTY_KO[record.difficulty] ?? record.difficulty
                })\n` +
                `점수: ${record.score.total}문제 중 ${record.score.correct}문제 정답 (${record.score.percent}점)\n` +
                `확신했지만 틀림 ${record.score.overconfident}문제 / 운으로 맞힘 ${record.score.lucky}문제 / ` +
                `확실히 아는 것 ${record.score.solid}문제\n\n` +
                `문항별 결과:\n${lines}`,
            schema: FEEDBACK_SCHEMA,
            temperature: 0.7,
            maxOutputTokens: 2048,
        });

        await store.setFeedback(record.id, feedback);
        return { feedback };
    })
);

app.get('*', (req, res) => {
    if (req.path.startsWith('/api/') || req.path.startsWith('/public/')) {
        res.status(404).json({ error: '찾을 수 없습니다.' });
        return;
    }
    res.sendFile(path.join(__dirname, 'public', 'index.html'));
});

const PORT = Number(process.env.PORT) || 1234;
app.listen(PORT, () => {
    console.log(`CogMind 실행 중 → http://127.0.0.1:${PORT}  (model: ${MODEL})`);
});