const express = require('express');
const http = require('http');
const https = require('https');
const { URL } = require('url');
const router = express.Router();
const db = require('../db');
const logger = require('../utils/logger');
const { verifyToken } = require('../middleware/auth');

const normalizePositiveInt = (value, fallback, min = 1, max = Number.MAX_SAFE_INTEGER) => {
    const n = Number(value);
    if (!Number.isFinite(n)) return fallback;
    const intValue = Math.trunc(n);
    if (intValue < min) return min;
    if (intValue > max) return max;
    return intValue;
};

const AI_TIMEOUT_MS = Number(process.env.AI_TIMEOUT_MS || 45000);
const AI_MAX_TOKENS = normalizePositiveInt(process.env.AI_MAX_TOKENS, 4096, 256, 8192);
const AI_DEFAULT_PROVIDER = String(process.env.AI_DEFAULT_PROVIDER || 'deepseek').trim().toLowerCase();
const AI_PROVIDER_PRIORITY = String(process.env.AI_PROVIDER_PRIORITY || 'deepseek').trim();
const AI_NAME_MAX_ITEMS_DEFAULT = normalizePositiveInt(process.env.AI_NAME_MAX_ITEMS_DEFAULT, 100, 20, 500);
const AI_NAME_MAX_ITEMS_HARD_LIMIT = normalizePositiveInt(process.env.AI_NAME_MAX_ITEMS_HARD_LIMIT, 300, 50, 1000);

const ADMIN_ROLES = new Set(['admin', 'super_admin', 'senior_user', 'intermediate_user']);
const SUPPORTED_PROVIDERS = new Set(['auto', 'deepseek']);
const SUPPORTED_MODES = new Set(['standard', 'deep']);
const SUPPORTED_NAME_STRATEGIES = new Set(['latest', 'balanced']);
const TYPE_LABEL_MAP = {
    paper: 'Paper',
    project: 'Project',
    award: 'Award',
    standard: 'Standard',
    monograph: 'Monograph',
    report: 'Technical Report',
    plan: 'Plan',
    patent: 'Patent',
    transformation: 'Transformation',
    software: 'Software Copyright'
};
const STATUS_LABEL_MAP = {
    pending: 'Pending',
    approved: 'Approved',
    rejected: 'Rejected'
};

const clampText = (value, maxLen = 600) => {
    return String(value || '').trim().slice(0, maxLen);
};

const normalizeFilter = (value) => {
    if (value === undefined || value === null) return null;
    const s = String(value).trim();
    if (!s || s.toLowerCase() === 'all') return null;
    return s;
};

const toSafeInt = (value, fallback = null) => {
    const n = Number(value);
    if (!Number.isFinite(n)) return fallback;
    return Math.trunc(n);
};

const normalizeProvider = (value) => {
    const provider = String(value || '').trim().toLowerCase();
    if (!provider) return 'auto';
    if (!SUPPORTED_PROVIDERS.has(provider)) return 'auto';
    return provider;
};

const normalizeMode = (value) => {
    const mode = String(value || '').trim().toLowerCase();
    if (!mode || !SUPPORTED_MODES.has(mode)) return 'standard';
    return mode;
};

const normalizeNameStrategy = (value) => {
    const strategy = String(value || '').trim().toLowerCase();
    if (!strategy || !SUPPORTED_NAME_STRATEGIES.has(strategy)) return 'latest';
    return strategy;
};

const normalizeNameLimit = (value) => {
    return normalizePositiveInt(value, AI_NAME_MAX_ITEMS_DEFAULT, 20, AI_NAME_MAX_ITEMS_HARD_LIMIT);
};

const toIsoDate = (value) => {
    if (!value) return null;
    const date = value instanceof Date ? value : new Date(value);
    if (!Number.isFinite(date.getTime())) return null;
    return date.toISOString().slice(0, 10);
};

const getProviderConfigs = () => {
    return {
        deepseek: {
            baseUrl: String(process.env.DEEPSEEK_API_BASE_URL || '').trim(),
            apiKey: String(process.env.DEEPSEEK_API_KEY || '').trim(),
            model: String(process.env.DEEPSEEK_MODEL || 'deepseek-chat').trim() || 'deepseek-chat'
        }
    };
};

const getAvailableProviders = (configs) => {
    return Object.keys(configs).filter((provider) => {
        const cfg = configs[provider];
        return !!(cfg && cfg.baseUrl && cfg.apiKey && cfg.model);
    });
};

const parsePriority = () => {
    const tokens = AI_PROVIDER_PRIORITY
        .split(',')
        .map((p) => normalizeProvider(p))
        .filter((p) => p !== 'auto');
    return Array.from(new Set(tokens));
};

const resolveProviderOrder = (requestedProvider, availableProviders) => {
    if (requestedProvider !== 'auto') {
        return availableProviders.includes(requestedProvider) ? [requestedProvider] : [];
    }

    const priority = parsePriority();
    const ordered = [
        ...priority.filter((p) => availableProviders.includes(p)),
        ...availableProviders.filter((p) => !priority.includes(p))
    ];

    const defaultProvider = normalizeProvider(AI_DEFAULT_PROVIDER);
    if (defaultProvider !== 'auto' && ordered.includes(defaultProvider)) {
        return [defaultProvider, ...ordered.filter((p) => p !== defaultProvider)];
    }

    return ordered;
};

const postJson = (urlString, payload, headers = {}, timeoutMs = 30000) => {
    return new Promise((resolve, reject) => {
        const url = new URL(urlString);
        const body = JSON.stringify(payload);
        const requestLib = url.protocol === 'http:' ? http : https;
        const defaultPort = url.protocol === 'http:' ? 80 : 443;

        const req = requestLib.request({
            protocol: url.protocol,
            hostname: url.hostname,
            port: url.port || defaultPort,
            path: `${url.pathname}${url.search}`,
            method: 'POST',
            timeout: timeoutMs,
            headers: {
                'Content-Type': 'application/json',
                'Content-Length': Buffer.byteLength(body),
                ...headers
            }
        }, (res) => {
            let raw = '';
            res.setEncoding('utf8');
            res.on('data', (chunk) => {
                raw += chunk;
            });
            res.on('end', () => {
                const statusCode = res.statusCode || 500;
                let parsed = {};
                try {
                    parsed = raw ? JSON.parse(raw) : {};
                } catch (e) {
                    parsed = { raw };
                }

                if (statusCode >= 200 && statusCode < 300) {
                    resolve(parsed);
                } else {
                    reject(new Error(parsed?.error?.message || parsed?.message || `AI provider error: ${statusCode}`));
                }
            });
        });

        req.on('timeout', () => {
            req.destroy(new Error('AI request timeout'));
        });
        req.on('error', reject);
        req.write(body);
        req.end();
    });
};

const writeSse = (res, event, payload) => {
    if (res.writableEnded) return;
    res.write(`event: ${event}\n`);
    res.write(`data: ${JSON.stringify(payload)}\n\n`);
};

const extractChoiceText = (parsed) => {
    const choice = parsed?.choices?.[0] || {};
    if (typeof choice?.delta?.content === 'string') return choice.delta.content;
    if (typeof choice?.message?.content === 'string') return choice.message.content;
    return '';
};

const streamProviderToClient = ({ req, res, provider, config, systemPrompt, userPrompt, maxTokens = AI_MAX_TOKENS, timeoutMs = 30000 }) => {
    return new Promise((resolve, reject) => {
        const endpoint = `${config.baseUrl.replace(/\/+$/, '')}/chat/completions`;
        const url = new URL(endpoint);
        const requestLib = url.protocol === 'http:' ? http : https;
        const defaultPort = url.protocol === 'http:' ? 80 : 443;
        const payload = JSON.stringify({
            model: config.model,
            temperature: 0.2,
            max_tokens: maxTokens,
            stream: true,
            messages: [
                { role: 'system', content: systemPrompt },
                { role: 'user', content: userPrompt }
            ]
        });

        let settled = false;
        let tokenChars = 0;
        let lineBuffer = '';
        let rawFallbackBuffer = '';
        let metaSent = false;
        const onClientClose = () => {
            if (!upstreamReq.destroyed) {
                upstreamReq.destroy(new Error('client closed connection'));
            }
        };
        const settle = (fn, value) => {
            if (settled) return;
            settled = true;
            req.off('close', onClientClose);
            fn(value);
        };

        const upstreamReq = requestLib.request({
            protocol: url.protocol,
            hostname: url.hostname,
            port: url.port || defaultPort,
            path: `${url.pathname}${url.search}`,
            method: 'POST',
            timeout: timeoutMs,
            headers: {
                'Content-Type': 'application/json',
                'Content-Length': Buffer.byteLength(payload),
                Accept: 'text/event-stream',
                Authorization: `Bearer ${config.apiKey}`
            }
        }, (upstreamRes) => {
            const statusCode = upstreamRes.statusCode || 500;
            upstreamRes.setEncoding('utf8');

            if (statusCode < 200 || statusCode >= 300) {
                let errRaw = '';
                upstreamRes.on('data', (chunk) => {
                    errRaw += chunk;
                });
                upstreamRes.on('end', () => {
                    try {
                        const parsed = errRaw ? JSON.parse(errRaw) : {};
                        settle(reject, new Error(parsed?.error?.message || parsed?.message || `AI provider error: ${statusCode}`));
                    } catch (e) {
                        settle(reject, new Error(`AI provider error: ${statusCode}`));
                    }
                });
                return;
            }

            if (!metaSent) {
                writeSse(res, 'meta', {
                    provider,
                    model: config.model,
                    generatedAt: new Date().toISOString()
                });
                metaSent = true;
            }

            const flushLine = (line) => {
                const trimmed = String(line || '').trim();
                if (!trimmed || trimmed.startsWith(':') || !trimmed.startsWith('data:')) return;
                const data = trimmed.slice(5).trim();
                if (!data || data === '[DONE]') return;
                try {
                    const parsed = JSON.parse(data);
                    const deltaText = extractChoiceText(parsed);
                    if (deltaText) {
                        tokenChars += deltaText.length;
                        writeSse(res, 'token', { content: deltaText });
                    }
                } catch (e) {
                    // Ignore malformed stream chunks.
                }
            };

            upstreamRes.on('data', (chunk) => {
                rawFallbackBuffer += chunk;
                lineBuffer += chunk.replace(/\r/g, '');
                let idx = lineBuffer.indexOf('\n');
                while (idx !== -1) {
                    const line = lineBuffer.slice(0, idx);
                    lineBuffer = lineBuffer.slice(idx + 1);
                    flushLine(line);
                    idx = lineBuffer.indexOf('\n');
                }
            });

            upstreamRes.on('end', () => {
                if (lineBuffer) flushLine(lineBuffer);

                if (tokenChars === 0 && rawFallbackBuffer.trim()) {
                    try {
                        const parsed = JSON.parse(rawFallbackBuffer);
                        const wholeText = extractChoiceText(parsed);
                        if (wholeText) {
                            tokenChars += wholeText.length;
                            writeSse(res, 'token', { content: wholeText });
                        }
                    } catch (e) {
                        // Ignore fallback parse errors.
                    }
                }

                if (tokenChars === 0) {
                    settle(reject, new Error('provider returned empty analysis'));
                    return;
                }
                settle(resolve, { provider, model: config.model, tokenChars });
            });

            upstreamRes.on('error', (err) => {
                settle(reject, err);
            });
        });

        upstreamReq.on('timeout', () => {
            upstreamReq.destroy(new Error('AI request timeout'));
        });

        upstreamReq.on('error', (err) => {
            settle(reject, err);
        });

        req.once('close', onClientClose);

        upstreamReq.write(payload);
        upstreamReq.end();
    });
};

const buildWhereClause = (filters = {}) => {
    const where = ['1=1'];
    const params = [];

    const year = toSafeInt(normalizeFilter(filters.year));
    const type = normalizeFilter(filters.type);
    const status = normalizeFilter(filters.status);
    const department = normalizeFilter(filters.department);

    if (year && year >= 2000 && year <= 2100) {
        where.push(`EXTRACT(YEAR FROM achievement_date) = $${params.length + 1}`);
        params.push(year);
    }
    if (type) {
        where.push(`type = $${params.length + 1}`);
        params.push(type);
    }
    if (status) {
        where.push(`status = $${params.length + 1}`);
        params.push(status);
    }

    return { whereSql: where.join(' AND '), params, department };
};

const toNumberRows = (rows = []) => {
    return rows.map((row) => ({
        ...row,
        count: Number(row.count || 0)
    }));
};

const toPercent = (count, total) => {
    if (!total) return 0;
    return Number(((Number(count || 0) / Number(total || 1)) * 100).toFixed(1));
};

const formatFilterValue = (key, value) => {
    if (!value || value === 'all') return '鍏ㄩ儴';
    if (key === 'type') return TYPE_LABEL_MAP[value] || value;
    if (key === 'status') return STATUS_LABEL_MAP[value] || value;
    return value;
};

const buildPromptDataset = (dataset) => {
    const total = Number(dataset?.overview?.total || 0);
    const rawFilters = dataset?.filters || {};
    const mode = dataset?.mode === 'deep' ? 'deep' : 'standard';
    const rawNameSamples = dataset?.nameSamples || {};

    return {
        mode,
        filters: {
            year: formatFilterValue('year', rawFilters.year),
            type: formatFilterValue('type', rawFilters.type),
            status: formatFilterValue('status', rawFilters.status),
            department: formatFilterValue('department', rawFilters.department)
        },
        overview: { total },
        byType: (dataset?.byType || []).slice(0, 8).map((item) => ({
            type: TYPE_LABEL_MAP[item.type] || item.type,
            count: Number(item.count || 0),
            ratio: toPercent(item.count, total)
        })),
        byStatus: (dataset?.byStatus || []).map((item) => ({
            status: STATUS_LABEL_MAP[item.status] || item.status,
            count: Number(item.count || 0),
            ratio: toPercent(item.count, total)
        })),
        byDepartmentTop: (dataset?.byDepartment || []).slice(0, 10).map((item) => ({
            department: item.department,
            count: Number(item.count || 0),
            ratio: toPercent(item.count, total)
        })),
        monthlyRecent: (dataset?.byMonth || []).slice(-24).map((item) => ({
            month: item.month,
            count: Number(item.count || 0)
        })),
        quality: dataset?.quality || {},
        nameSamples: {
            mode,
            strategy: rawNameSamples?.strategy || 'latest',
            sent: Number(rawNameSamples?.sent || 0),
            total: Number(rawNameSamples?.total || 0),
            truncated: Boolean(rawNameSamples?.truncated),
            items: (rawNameSamples?.items || []).map((item) => ({
                name: clampText(item?.name, 120),
                type: TYPE_LABEL_MAP[item?.type] || item?.type || 'unknown',
                department: item?.department || 'unknown',
                date: item?.date || null
            }))
        }
    };
};

const gatherAnalysisDataset = async (filters = {}, options = {}) => {
    const { whereSql, params, department } = buildWhereClause(filters);
    const scopedParams = department ? [...params, department] : params;
    const scopedWhere = department ? `${whereSql} AND owner_department = $${params.length + 1}` : whereSql;

    const mode = normalizeMode(options?.mode);
    const nameStrategy = normalizeNameStrategy(options?.nameStrategy);
    const nameLimit = normalizeNameLimit(options?.nameLimit);

    const ownerAchievementsCte = `
        WITH leader_depts AS (
            SELECT name FROM dict_leader_departments
        ),
        leader_dept_array AS (
            SELECT COALESCE(array_agg(name::text), ARRAY[]::text[]) AS names FROM leader_depts
        ),
        owner_achievements AS (
            SELECT
                a.id,
                a.name,
                a.type,
                a.status,
                a.achievement_date,
                a.contributors,
                a.assigned_departments,
                a.remarks,
                COALESCE(non_leader.dept, first_any.dept) AS owner_department
            FROM achievements a
            CROSS JOIN leader_dept_array lda
            LEFT JOIN LATERAL (
                SELECT u.dept
                FROM unnest(COALESCE(a.assigned_departments::text[], ARRAY[]::text[])) WITH ORDINALITY AS u(dept, ord)
                WHERE u.dept IS NOT NULL
                  AND BTRIM(u.dept) <> ''
                  AND u.dept <> ALL(lda.names)
                ORDER BY u.ord
                LIMIT 1
            ) non_leader ON TRUE
            LEFT JOIN LATERAL (
                SELECT u.dept
                FROM unnest(COALESCE(a.assigned_departments::text[], ARRAY[]::text[])) WITH ORDINALITY AS u(dept, ord)
                WHERE u.dept IS NOT NULL
                  AND BTRIM(u.dept) <> ''
                ORDER BY u.ord
                LIMIT 1
            ) first_any ON TRUE
        )
    `;

    const totalRes = await db.query(
        `${ownerAchievementsCte}
         SELECT COUNT(*)::int AS count
         FROM owner_achievements
         WHERE ${scopedWhere}`,
        scopedParams
    );
    const typeRes = await db.query(
        `${ownerAchievementsCte}
         SELECT type, COUNT(*)::int AS count
         FROM owner_achievements
         WHERE ${scopedWhere}
         GROUP BY type
         ORDER BY count DESC`,
        scopedParams
    );
    const statusRes = await db.query(
        `${ownerAchievementsCte}
         SELECT status, COUNT(*)::int AS count
         FROM owner_achievements
         WHERE ${scopedWhere}
         GROUP BY status
         ORDER BY count DESC`,
        scopedParams
    );
    const deptRes = await db.query(
        `${ownerAchievementsCte},
         department_scope AS (
            SELECT d.name AS department
            FROM departments d, leader_dept_array lda
            WHERE d.name::text <> ALL(lda.names)
         )
         SELECT ds.department, COUNT(oa.id)::int AS count
         FROM department_scope ds
         LEFT JOIN owner_achievements oa
           ON ds.department = oa.owner_department
          AND (${scopedWhere})
         GROUP BY ds.department
         ORDER BY count DESC
         LIMIT 20`,
        scopedParams
    );
    const monthlyRes = await db.query(
        `${ownerAchievementsCte}
         SELECT month, count
         FROM (
           SELECT TO_CHAR(achievement_date, 'YYYY-MM') AS month, COUNT(*)::int AS count
           FROM owner_achievements
           WHERE ${scopedWhere} AND achievement_date IS NOT NULL
           GROUP BY month
           ORDER BY month DESC
           LIMIT 48
         ) t
         ORDER BY month`,
        scopedParams
    );

    const qualityRes = await db.query(
        `${ownerAchievementsCte}
         SELECT
           COUNT(*) FILTER (WHERE contributors IS NULL OR jsonb_array_length(contributors) = 0)::int AS empty_contributors,
           COUNT(*) FILTER (WHERE owner_department IS NULL)::int AS empty_departments,
           COUNT(*) FILTER (WHERE remarks IS NULL OR LENGTH(BTRIM(remarks)) = 0)::int AS empty_remarks
         FROM owner_achievements
         WHERE ${scopedWhere}`,
        scopedParams
    );

    const total = Number(totalRes.rows[0]?.count || 0);
    const byType = toNumberRows(typeRes.rows);
    const byStatus = toNumberRows(statusRes.rows);
    const byDepartment = toNumberRows(deptRes.rows);
    const byMonth = toNumberRows(monthlyRes.rows);

    const quality = {
        emptyContributors: Number(qualityRes.rows[0]?.empty_contributors || 0),
        emptyDepartments: Number(qualityRes.rows[0]?.empty_departments || 0),
        emptyRemarks: Number(qualityRes.rows[0]?.empty_remarks || 0)
    };

    let nameSamples = {
        mode,
        strategy: nameStrategy,
        sent: 0,
        total: 0,
        truncated: false,
        items: []
    };

    if (mode === 'deep') {
        const nameCountRes = await db.query(
            `${ownerAchievementsCte}
             SELECT COUNT(*)::int AS count
             FROM owner_achievements
             WHERE ${scopedWhere}
               AND name IS NOT NULL
               AND LENGTH(BTRIM(name)) > 0`,
            scopedParams
        );

        const totalNameCount = Number(nameCountRes.rows[0]?.count || 0);
        let sampleRows = [];

        if (totalNameCount > 0) {
            if (nameStrategy === 'balanced') {
                const distinctTypeCount = Math.max(byType.filter((item) => !!item.type).length, 1);
                const perTypeCap = Math.max(2, Math.ceil(nameLimit / distinctTypeCount));
                const balancedParams = [...scopedParams, perTypeCap, nameLimit];
                const balancedRes = await db.query(
                    `${ownerAchievementsCte}
                     SELECT id, name, type, owner_department AS department, achievement_date
                     FROM (
                         SELECT
                             id,
                             name,
                             type,
                             owner_department,
                             achievement_date,
                             ROW_NUMBER() OVER (
                                 PARTITION BY COALESCE(type, 'unknown')
                                 ORDER BY achievement_date DESC NULLS LAST, id DESC
                             ) AS rn
                         FROM owner_achievements
                         WHERE ${scopedWhere}
                           AND name IS NOT NULL
                           AND LENGTH(BTRIM(name)) > 0
                     ) t
                     WHERE rn <= $${scopedParams.length + 1}
                     ORDER BY achievement_date DESC NULLS LAST, id DESC
                     LIMIT $${scopedParams.length + 2}`,
                    balancedParams
                );
                sampleRows = balancedRes.rows;
            } else {
                const latestParams = [...scopedParams, nameLimit];
                const latestRes = await db.query(
                    `${ownerAchievementsCte}
                     SELECT id, name, type, owner_department AS department, achievement_date
                     FROM owner_achievements
                     WHERE ${scopedWhere}
                       AND name IS NOT NULL
                       AND LENGTH(BTRIM(name)) > 0
                     ORDER BY achievement_date DESC NULLS LAST, id DESC
                     LIMIT $${scopedParams.length + 1}`,
                    latestParams
                );
                sampleRows = latestRes.rows;
            }
        }

        const items = sampleRows
            .map((row) => ({
                name: clampText(row?.name, 120),
                type: row?.type || null,
                department: row?.department || null,
                date: toIsoDate(row?.achievement_date)
            }))
            .filter((item) => !!item.name);

        nameSamples = {
            mode,
            strategy: nameStrategy,
            sent: items.length,
            total: totalNameCount,
            truncated: items.length < totalNameCount,
            items
        };
    }

    return {
        mode,
        filters: {
            year: normalizeFilter(filters.year) || 'all',
            type: normalizeFilter(filters.type) || 'all',
            status: normalizeFilter(filters.status) || 'all',
            department: normalizeFilter(filters.department) || 'all'
        },
        overview: {
            total
        },
        byType,
        byStatus,
        byDepartment,
        byMonth,
        quality,
        nameSamples,
        protection: {
            attachmentContentSent: false,
            attachmentPathSent: false,
            attachmentFilenameSent: false,
            contributorPhoneSent: false,
            contributorNameSent: false,
            achievementNameSent: mode === 'deep',
            note: mode === 'deep'
                ? 'Deep mode sends aggregated statistics and achievement names only. No personal phone, contributor name, or attachment data is sent.'
                : 'Standard mode sends aggregated statistics only. No names, phones, or attachment data is sent.'
        }
    };
};

const buildPrompt = (question, dataset) => {
    const promptDataset = buildPromptDataset(dataset);
    const mode = dataset?.mode === 'deep' ? 'deep' : 'standard';
    const modeNote = mode === 'deep'
        ? '当前为深度分析模式：会额外提供成果名称样本（不含个人姓名与手机号）。'
        : '当前为标准分析模式：仅提供聚合统计数据，不提供成果名称。';
    const systemPrompt = `
你是科研成果统计分析助手。只能基于输入数据给出结论，不得编造事实。
要求：
1) 明确统计口径与边界；
2) 关键判断尽量给出数量/占比/趋势证据；
3) 证据不足时直接说明“数据不足以支持该结论”；
4) 建议必须可执行、可落地。
请使用中文 Markdown 输出，结构如下：
## 执行摘要
## 关键发现
## 风险与数据质量
## 优先行动（表格）
## 一句话结论
`.trim();

    const userPrompt = `
用户问题：${question || '请给出整体分析、风险和改进建议。'}

模式说明：${modeNote}

隐私口径：
- 不包含附件内容、文件路径、文件名；
- 不包含个人手机号、贡献者姓名；
- 部门统计已排除院领导部门，每条成果仅计入一个归属部门。

请先结论后证据再建议。以下是可用数据 JSON：
${JSON.stringify(promptDataset)}
`.trim();

    return {
        systemPrompt,
        userPrompt
    };
};

const callProvider = async (provider, config, systemPrompt, userPrompt, maxTokens = AI_MAX_TOKENS) => {
    const endpoint = `${config.baseUrl.replace(/\/+$/, '')}/chat/completions`;
    const aiResp = await postJson(
        endpoint,
        {
            model: config.model,
            temperature: 0.2,
            max_tokens: maxTokens,
            messages: [
                { role: 'system', content: systemPrompt },
                { role: 'user', content: userPrompt }
            ]
        },
        {
            Authorization: `Bearer ${config.apiKey}`
        },
        AI_TIMEOUT_MS
    );

    const analysis = aiResp?.choices?.[0]?.message?.content || '';
    if (!analysis) {
        throw new Error('provider returned empty analysis');
    }
    return {
        provider,
        model: config.model,
        analysis
    };
};

router.post('/achievements', verifyToken, async (req, res) => {
    if (!ADMIN_ROLES.has(req.user.role)) {
        return res.status(403).json({ message: 'No permission to use AI analysis.' });
    }

    const requestedProvider = normalizeProvider(req.body?.provider || 'auto');
    const providerConfigs = getProviderConfigs();
    const availableProviders = getAvailableProviders(providerConfigs);
    if (availableProviders.length === 0) {
        return res.status(503).json({ message: 'AI service is not configured. Please configure DeepSeek API settings.' });
    }

    const providerOrder = resolveProviderOrder(requestedProvider, availableProviders);
    if (providerOrder.length === 0) {
        return res.status(503).json({
            message: `Requested provider '${requestedProvider}' is unavailable. Available providers: ${availableProviders.join(', ')}`
        });
    }

    const question = clampText(req.body?.question, 600);
    const filters = req.body?.filters || {};
    const mode = normalizeMode(req.body?.mode);
    const nameLimit = normalizeNameLimit(req.body?.nameLimit);
    const nameStrategy = normalizeNameStrategy(req.body?.nameStrategy);
    const analysisOptions = { mode, nameLimit, nameStrategy };
    const clientIp = req.headers['x-forwarded-for'] || req.socket.remoteAddress;

    try {
        const dataset = await gatherAnalysisDataset(filters, analysisOptions);
        const { systemPrompt, userPrompt } = buildPrompt(question, dataset);
        const triedProviders = [];
        const errors = [];
        let aiResult = null;

        for (const provider of providerOrder) {
            triedProviders.push(provider);
            try {
                aiResult = await callProvider(provider, providerConfigs[provider], systemPrompt, userPrompt, AI_MAX_TOKENS);
                break;
            } catch (providerErr) {
                errors.push(`${provider}: ${providerErr.message}`);
            }
        }

        if (!aiResult) {
            throw new Error(`All AI providers failed: ${errors.join(' | ')}`);
        }

        logger.info(
            `AI analysis generated by user ${req.user.username} (role=${req.user.role}, provider=${aiResult.provider}, ip=${clientIp})`
        );

        res.json({
            provider: aiResult.provider,
            model: aiResult.model,
            generatedAt: new Date().toISOString(),
            analysis: aiResult.analysis,
            triedProviders,
            mode: dataset.mode,
            nameSamples: dataset.nameSamples,
            datasetSummary: {
                filters: dataset.filters,
                total: dataset.overview.total,
                byTypeCount: dataset.byType.length,
                byDepartmentCount: dataset.byDepartment.length,
                byMonthCount: dataset.byMonth.length
            },
            protection: dataset.protection
        });
    } catch (err) {
        logger.error(`AI analysis failed for user ${req.user.username}: ${err.message}`);
        res.status(500).json({ message: `AI analysis failed: ${err.message}` });
    }
});

router.post('/achievements/stream', verifyToken, async (req, res) => {
    if (!ADMIN_ROLES.has(req.user.role)) {
        return res.status(403).json({ message: 'No permission to use AI analysis.' });
    }

    const requestedProvider = normalizeProvider(req.body?.provider || 'auto');
    const providerConfigs = getProviderConfigs();
    const availableProviders = getAvailableProviders(providerConfigs);
    if (availableProviders.length === 0) {
        return res.status(503).json({ message: 'AI service is not configured. Please configure DeepSeek API settings.' });
    }

    const providerOrder = resolveProviderOrder(requestedProvider, availableProviders);
    if (providerOrder.length === 0) {
        return res.status(503).json({
            message: `Requested provider '${requestedProvider}' is unavailable. Available providers: ${availableProviders.join(', ')}`
        });
    }

    const question = clampText(req.body?.question, 600);
    const filters = req.body?.filters || {};
    const mode = normalizeMode(req.body?.mode);
    const nameLimit = normalizeNameLimit(req.body?.nameLimit);
    const nameStrategy = normalizeNameStrategy(req.body?.nameStrategy);
    const analysisOptions = { mode, nameLimit, nameStrategy };
    const clientIp = req.headers['x-forwarded-for'] || req.socket.remoteAddress;

    try {
        const dataset = await gatherAnalysisDataset(filters, analysisOptions);
        const { systemPrompt, userPrompt } = buildPrompt(question, dataset);
        const triedProviders = [];
        const errors = [];

        res.setHeader('Content-Type', 'text/event-stream; charset=utf-8');
        res.setHeader('Cache-Control', 'no-cache, no-transform');
        res.setHeader('Connection', 'keep-alive');
        res.setHeader('X-Accel-Buffering', 'no');
        if (typeof res.flushHeaders === 'function') {
            res.flushHeaders();
        }

        let streamResult = null;
        for (const provider of providerOrder) {
            triedProviders.push(provider);
            try {
                streamResult = await streamProviderToClient({
                    req,
                    res,
                    provider,
                    config: providerConfigs[provider],
                    systemPrompt,
                    userPrompt,
                    maxTokens: AI_MAX_TOKENS,
                    timeoutMs: AI_TIMEOUT_MS
                });
                break;
            } catch (providerErr) {
                errors.push(`${provider}: ${providerErr.message}`);
                writeSse(res, 'provider_error', {
                    provider,
                    message: providerErr.message
                });
            }
        }

        if (!streamResult) {
            writeSse(res, 'error', { message: `All AI providers failed: ${errors.join(' | ')}` });
            writeSse(res, 'done', { success: false, triedProviders });
            res.end();
            return;
        }

        logger.info(
            `AI stream analysis generated by user ${req.user.username} (role=${req.user.role}, provider=${streamResult.provider}, ip=${clientIp})`
        );

        writeSse(res, 'done', {
            success: true,
            provider: streamResult.provider,
            model: streamResult.model,
            generatedAt: new Date().toISOString(),
            triedProviders,
            mode: dataset.mode,
            nameSamples: dataset.nameSamples,
            datasetSummary: {
                filters: dataset.filters,
                total: dataset.overview.total,
                byTypeCount: dataset.byType.length,
                byDepartmentCount: dataset.byDepartment.length,
                byMonthCount: dataset.byMonth.length
            },
            protection: dataset.protection
        });
        res.end();
    } catch (err) {
        logger.error(`AI stream analysis failed for user ${req.user.username}: ${err.message}`);
        if (res.headersSent) {
            writeSse(res, 'error', { message: `AI analysis failed: ${err.message}` });
            writeSse(res, 'done', { success: false });
            res.end();
            return;
        }
        res.status(500).json({ message: `AI analysis failed: ${err.message}` });
    }
});

module.exports = router;