import { TRPCError } from "@trpc/server";
import { mediaItemDao } from "@app/dao";
import {
    hasOpenCredentials,
    matchFileName,
    openFetchJson,
    openMatch,
    rankCandidates,
} from "@app/danmaku";
import type { BatchResult, DanmakuMatchOutput } from "@app/types";
import { remoteFileHash } from "./danmaku.service.js";

/** 从文件名提取集数：SxxExx / - NN / EPxx / 第N集·话 / [NN] / Exx */
export function parseEpisodeFromFilename(name: string): number | null {
    const s = name.replace(/\.[a-z0-9]+$/i, "");
    const patterns: RegExp[] = [
        /S\d{1,2}\s*E(\d{1,3})/i,
        /(?:^|[\s\-_[·])EP?(\d{1,4})(?:[\s\-_\]·]|$)/i,
        /第\s*(\d{1,4})\s*[集话話]/,
        /\[(\d{1,3})\]/,
        /\s-\s(\d{2,3})(?:\s|$|v\d)/i,
    ];
    for (const re of patterns) {
        const m = s.match(re);
        if (m?.[1]) {
            const n = Number.parseInt(m[1], 10);
            if (Number.isFinite(n)) return n;
        }
    }
    return null;
}

/** 从文件名剥出作品检索词：去扩展名/字幕组/集数/分辨率等噪声 */
export function buildSearchQuery(filename: string): string {
    let s = filename.replace(/\.[a-z0-9]+$/i, "");
    s = s.replace(/^\[[^\]]*\]\s*/, "");
    s = s.replace(/\[[^\]]*\]/g, " ");
    s = s.replace(/[（(][^）)]*[)）]/g, " ");
    // 集数标记
    s = s.replace(/S\d{1,2}\s*E\d{1,3}/i, " ");
    s = s.replace(/第\s*\d{1,4}\s*[集话話]/, " ");
    s = s.replace(/(?:^|[\s\-_])EP?\d{1,4}(?:[\s\-_]|$)/i, " ");
    s = s.replace(/\s-\s\d{2,3}(?:\s|$|v\d).*$/i, " ");
    // 清晰度/编码/字幕组残留
    s = s.replace(
        /\b(1080p|720p|2160p|4k|x264|x265|hevc|aac|flac|10bit|8bit|bdrip|webrip|web-dl|bluray|aac\d\.?\d?|dual|简体|繁体|中字)\b/gi,
        " ",
    );
    s = s.replace(/[【】[\]（）()]/g, " ");
    return s.replace(/[\s\-_·・.]+/g, " ").trim();
}

/** 归一化标题，便于模糊比对 */
function normalizeTitle(s: string): string {
    return s
        .toLowerCase()
        .replace(/[\s\-_·・.。！!？?：:：、,，'"]/g, "")
        .replace(/[（(][^）)]*[)）]/g, "");
}

/** 候选与检索词的相似度 0–1；借鉴弹弹play「候选列表+择优」而非盲取第一条 */
export function scoreHit(query: string, hit: { name: string; nameCn: string }): number {
    const q = normalizeTitle(query);
    if (!q) return 0;
    const cn = normalizeTitle(hit.nameCn);
    const jp = normalizeTitle(hit.name);
    if (cn === q || jp === q) return 1;
    if (cn && (cn.includes(q) || q.includes(cn))) return 0.82;
    if (jp && (jp.includes(q) || q.includes(jp))) return 0.78;
    // token 重叠
    const qTokens = new Set(query.toLowerCase().split(/\s+/).filter(Boolean));
    const hitTokens = new Set(
        `${hit.nameCn} ${hit.name}`.toLowerCase().split(/\s+/).filter(Boolean),
    );
    if (qTokens.size === 0 || hitTokens.size === 0) return 0.2;
    let overlap = 0;
    for (const tok of qTokens) if (hitTokens.has(tok)) overlap += 1;
    return 0.3 + 0.5 * (overlap / qTokens.size);
}

/** 自动绑定阈值：低于此值留给手动匹配 */
export const AUTO_BIND_THRESHOLD = 0.55;

export type BangumiSearchHit = {
    id: number;
    name: string;
    nameCn: string;
    image: string;
    date: string | null;
    summary: string;
};

type RawDandanEpisode = {
    episodeId?: number | string;
    episodeTitle?: string | null;
    episodeNumber?: string | null;
};

/**
 * bgmtv 桥择集：episodeNumber 数值相等优先，其次按位序取第 N 条。
 * epNumber 越界时不瞎猜返回 null；epNumber 未知时取第 1 条。
 */
export function pickDandanEpisode(
    episodes: RawDandanEpisode[],
    epNumber: number | null,
): { episodeId: number; episodeTitle: string | null } | null {
    const parsed: {
        episodeId: number;
        episodeTitle: string | null;
        episodeNumber: string | null;
    }[] = [];
    for (const e of episodes) {
        const id =
            typeof e.episodeId === "number"
                ? e.episodeId
                : Number.parseInt(String(e.episodeId ?? ""), 10);
        if (Number.isFinite(id)) {
            parsed.push({
                episodeId: id,
                episodeTitle: e.episodeTitle ?? null,
                episodeNumber: e.episodeNumber ?? null,
            });
        }
    }
    if (parsed.length === 0) return null;
    if (epNumber != null) {
        const exact = parsed.find((e) => {
            const n = Number.parseInt(String(e.episodeNumber ?? ""), 10);
            return Number.isFinite(n) && n === epNumber;
        });
        if (exact) return { episodeId: exact.episodeId, episodeTitle: exact.episodeTitle };
        const byIndex = parsed[epNumber - 1];
        if (byIndex) return { episodeId: byIndex.episodeId, episodeTitle: byIndex.episodeTitle };
        return null;
    }
    const first = parsed[0];
    return first ? { episodeId: first.episodeId, episodeTitle: first.episodeTitle } : null;
}

/** Bangumi 绑定 → 弹弹play 剧集（免 hash 桥 /api/v2/bangumi/bgmtv/{subjectId}）；失败/无数据返回 null */
async function bridgeDandanEpisode(
    bangumiId: number,
    epNumber: number | null,
): Promise<{ episodeId: number; episodeTitle: string | null } | null> {
    const res = await openFetchJson(`/api/v2/bangumi/bgmtv/${bangumiId}`);
    if (!res.ok) return null;
    const body = res.json as { bangumi?: { episodes?: RawDandanEpisode[] } };
    return pickDandanEpisode(body.bangumi?.episodes ?? [], epNumber);
}

function apiBase(): string {
    return process.env["BANGUMI_API_BASE"] ?? "https://api.bgm.tv";
}

export async function bangumiSearch(q: string): Promise<BangumiSearchHit[]> {
    const url = `${apiBase()}/search/subject/${encodeURIComponent(q)}?type=2&responseSearch=subjects`;
    const res = await fetch(url, {
        headers: { "User-Agent": "dandanplay-web/0.1" },
    });
    if (!res.ok) throw new Error(`Bangumi HTTP ${res.status}`);
    const data = (await res.json()) as {
        list?: Array<{
            id: number;
            name: string;
            nameCn?: string;
            date?: string | null;
            summary?: string;
            images?: { medium?: string; large?: string };
        }>;
    };
    return (data.list ?? []).slice(0, 12).map((item) => ({
        id: item.id,
        name: item.name,
        nameCn: item.nameCn ?? item.name,
        image: item.images?.large ?? item.images?.medium ?? "",
        date: item.date ?? null,
        summary: item.summary ?? "",
    }));
}

async function fetchSubjectMeta(bangumiId: number): Promise<{
    title: string | null;
    posterUrl: string | null;
}> {
    try {
        const res = await fetch(`${apiBase()}/subject/${bangumiId}`, {
            headers: { "User-Agent": "dandanplay-web/0.1" },
        });
        if (!res.ok) return { title: null, posterUrl: null };
        const subject = (await res.json()) as {
            name?: string;
            name_cn?: string;
            images?: { medium?: string; large?: string };
        };
        return {
            title: subject.name_cn || subject.name || null,
            posterUrl: subject.images?.large ?? subject.images?.medium ?? null,
        };
    } catch {
        return { title: null, posterUrl: null };
    }
}

export const scrapeService = {
    search: bangumiSearch,

    /**
     * 弹弹play 文件识别（刮削 + 弹幕身份）：hash match 优先；
     * 未中且有 Bangumi 绑定时走 bgmtv 桥按集数兜底。写 dandanplayEpisodeId + 元数据。
     */
    async matchDandanplay(userId: string, mediaItemId: string): Promise<DanmakuMatchOutput> {
        const row = await mediaItemDao.getByIdForUser(mediaItemId, userId);
        if (!row) throw new TRPCError({ code: "NOT_FOUND", message: "媒体不存在" });
        if (!hasOpenCredentials()) {
            return {
                ok: false,
                matched: false,
                message:
                    "未配置开放弹幕网络：服务端需设置 OPEN_DANMAKU_APP_ID / OPEN_DANMAKU_APP_SECRET",
                candidates: [],
                highConfidence: false,
            };
        }

        const hash = await remoteFileHash(userId, mediaItemId);
        const outcome = await openMatch(matchFileName(row.path), row.size, hash);
        if (!outcome.ok) {
            return {
                ok: false,
                matched: false,
                message: outcome.errorMessage ?? "弹弹play 识别失败",
                candidates: [],
                highConfidence: false,
            };
        }
        const ranked = rankCandidates(outcome.candidates);
        const best = outcome.candidates[0];
        if (best) {
            await mediaItemDao.updateScrape(mediaItemId, userId, {
                dandanplayEpisodeId: best.episodeId,
                matchedHash: hash,
                scrapeStatus: "ok",
                scrapedAt: new Date(),
                posterUrl: best.imageUrl ?? row.posterUrl,
                title: best.animeTitle ?? row.title,
                epNumber: row.epNumber ?? parseEpisodeFromFilename(row.rawName),
            });
            return {
                ok: true,
                matched: true,
                candidates: ranked.candidates,
                highConfidence: ranked.highConfidence,
            };
        }

        if (row.bangumiId != null) {
            const bridged = await bridgeDandanEpisode(
                row.bangumiId,
                row.epNumber ?? parseEpisodeFromFilename(row.rawName),
            );
            if (bridged) {
                await mediaItemDao.updateScrape(mediaItemId, userId, {
                    dandanplayEpisodeId: bridged.episodeId,
                    matchedHash: hash,
                    scrapeStatus: row.scrapeStatus,
                    scrapedAt: new Date(),
                });
                return {
                    ok: true,
                    matched: true,
                    message: "已通过 Bangumi 绑定桥接到弹弹play 剧集",
                    candidates: [
                        {
                            episodeId: bridged.episodeId,
                            animeId: null,
                            animeTitle: row.title,
                            episodeTitle: bridged.episodeTitle,
                            imageUrl: row.posterUrl,
                        },
                    ],
                    highConfidence: true,
                };
            }
        }
        return {
            ok: true,
            matched: false,
            message: "弹弹play 未识别到该文件",
            candidates: [],
            highConfidence: false,
        };
    },

    /** 手动绑定：指定作品（可覆盖集数），弹弹play 式「用户选定对应关系」 */
    async bind(
        userId: string,
        mediaItemId: string,
        bangumiId: number,
        epNumber?: number | undefined,
    ): Promise<{ success: true }> {
        const row = await mediaItemDao.getByIdForUser(mediaItemId, userId);
        if (!row) throw new Error("媒体不存在");
        const meta = await fetchSubjectMeta(bangumiId);
        await mediaItemDao.updateScrape(mediaItemId, userId, {
            bangumiId,
            scrapeStatus: "ok",
            scrapedAt: new Date(),
            posterUrl: meta.posterUrl ?? row.posterUrl,
            title: meta.title ?? row.title,
            epNumber: epNumber ?? parseEpisodeFromFilename(row.rawName) ?? row.epNumber,
        });
        return { success: true };
    },

    /** 整夹指定作品：前缀下所有条目绑同一 bangumiId，集数从文件名解析 */
    async bindPath(
        userId: string,
        mountId: string,
        path: string,
        bangumiId: number,
    ): Promise<BatchResult> {
        const rows = await mediaItemDao.listByPathPrefix(userId, mountId, path);
        if (rows.length === 0) {
            return { total: 0, bound: 0, skipped: 0, message: "该路径下暂无已入库媒体" };
        }
        const meta = await fetchSubjectMeta(bangumiId);
        let bound = 0;
        for (const row of rows) {
            await mediaItemDao.updateScrape(row.id, userId, {
                bangumiId,
                scrapeStatus: "ok",
                scrapedAt: new Date(),
                posterUrl: meta.posterUrl ?? row.posterUrl,
                title: meta.title ?? row.title,
                epNumber: parseEpisodeFromFilename(row.rawName) ?? row.epNumber,
            });
            bound += 1;
        }
        return {
            total: rows.length,
            bound,
            skipped: 0,
            message: `已将 ${bound} 个条目指定为该作品`,
        };
    },

    /** 扫描后自动刮削：择优候选，低置信留 unmatched */
    async autoScrape(userId: string, mediaItemId: string): Promise<void> {
        const row = await mediaItemDao.getByIdForUser(mediaItemId, userId);
        if (!row || row.scrapeStatus === "ok") return;
        const q = buildSearchQuery(row.rawName);
        if (!q) {
            await mediaItemDao.updateScrape(mediaItemId, userId, {
                scrapeStatus: "unmatched",
                scrapedAt: new Date(),
            });
            return;
        }
        // 只包网络搜索：DB 写失败必须向外抛，避免被误标 failed 后吞掉
        let hits: BangumiSearchHit[];
        try {
            hits = await bangumiSearch(q);
        } catch {
            await mediaItemDao.updateScrape(mediaItemId, userId, {
                scrapeStatus: "failed",
                scrapedAt: new Date(),
            });
            return;
        }
        // 候选打分择优（弹弹play：返回候选列表择优，而非盲取第一条）
        let best: BangumiSearchHit | null = null;
        let bestScore = 0;
        for (const hit of hits) {
            const score = scoreHit(q, hit);
            if (score > bestScore) {
                bestScore = score;
                best = hit;
            }
        }
        if (!best || bestScore < AUTO_BIND_THRESHOLD) {
            await mediaItemDao.updateScrape(mediaItemId, userId, {
                scrapeStatus: "unmatched",
                scrapedAt: new Date(),
            });
            return;
        }
        await mediaItemDao.updateScrape(mediaItemId, userId, {
            bangumiId: best.id,
            scrapeStatus: "ok",
            scrapedAt: new Date(),
            posterUrl: best.image || null,
            title: best.nameCn || best.name,
            epNumber: parseEpisodeFromFilename(row.rawName),
        });
    },

    /** 文件夹级批量重刮（仅处理未 ok 的条目） */
    async rescrapePath(userId: string, mountId: string, path: string): Promise<BatchResult> {
        const rows = await mediaItemDao.listByPathPrefix(userId, mountId, path);
        let bound = 0;
        let skipped = 0;
        for (const row of rows) {
            if (row.scrapeStatus === "ok" && row.bangumiId != null) {
                skipped += 1;
                continue;
            }
            await this.autoScrape(userId, row.id);
            const after = await mediaItemDao.getByIdForUser(row.id, userId);
            if (after?.scrapeStatus === "ok") bound += 1;
        }
        return {
            total: rows.length,
            bound,
            skipped,
            message: `批量刮削完成：成功 ${bound}，跳过已绑定 ${skipped}`,
        };
    },
};