import { describe, expect, test } from "bun:test";

import { canvasConnectionError } from "../src/lib/canvas/canvas-connection-policy";
import { assertCanvasImageReferenceLimit, buildGenerationConfig, canvasImageReferenceLimitError, resolveCanvasGenerationModel } from "../src/lib/canvas/canvas-project-generation";
import { defaultModelCapabilityConfig } from "../src/lib/model-capabilities";
import { groupModelsByDisplayName, modelCompatibilityError, modelGroupReferenceLimits, resolveCompatibleModel, resolveModelGenerationDefaults } from "../src/lib/model-selection";
import { defaultConfig, type AiConfig, type ModelChannel } from "../src/stores/use-config-store";
import { CanvasNodeType, type CanvasConnection, type CanvasNodeData } from "../src/types/canvas";

function policyConfig(): AiConfig {
    const variants = [
        { model: "cinema-text", operations: ["text_to_video"], maxImages: 0, maxVideos: 0, maxAudios: 0 },
        { model: "cinema-image", operations: ["image_to_video"], maxImages: 1, maxVideos: 0, maxAudios: 0 },
        { model: "cinema-audio", operations: ["audio_to_video"], maxImages: 0, maxVideos: 0, maxAudios: 1 },
    ];
    const channel: ModelChannel = {
        id: "relay",
        name: "中转渠道",
        baseUrl: "https://api.example.com",
        apiKey: "test-key",
        apiFormat: "openai",
        models: variants.map((item) => item.model),
        modelCosts: variants.map((item) => {
            const capabilityConfig = defaultModelCapabilityConfig(undefined, item.model);
            capabilityConfig.video!.operations = item.operations;
            capabilityConfig.video!.references.maxImages = item.maxImages;
            capabilityConfig.video!.references.maxVideos = item.maxVideos;
            capabilityConfig.video!.references.maxAudios = item.maxAudios;
            return {
                model: item.model,
                displayName: "Cinema Pro",
                capability: "video" as const,
                billingMode: "per_second" as const,
                unitPriceMicrocredits: 1,
                capabilityConfig,
            };
        }),
    };
    const models = variants.map((item) => `relay::${item.model}`);
    return { ...defaultConfig, channels: [channel], models, videoModels: models, model: models[0], videoModel: models[0] };
}

function node(id: string, type: CanvasNodeType, generationMode?: "image" | "video"): CanvasNodeData {
    return {
        id,
        type,
        title: id,
        position: { x: 0, y: 0 },
        width: 100,
        height: 100,
        metadata: generationMode ? { generationMode } : undefined,
    };
}

describe("逻辑模型选择", () => {
    test("图片逻辑模型忽略全局视频时长，不应显示为不支持当前时长", () => {
        const model = "platform::gpt-image-2";
        const channel: ModelChannel = {
            id: "platform",
            name: "平台模型",
            baseUrl: "/api",
            apiKey: "system",
            apiFormat: "openai",
            scope: "system",
            enabled: true,
            models: ["gpt-image-2"],
            modelCosts: [{
                model: "gpt-image-2",
                displayName: "GPT Image 2",
                capability: "image",
                billingMode: "fixed_request",
                unitPriceMicrocredits: 1,
                logicalCapabilitySpec: {
                    version: 1,
                    capability: "image",
                    options: { size: { values: ["1:1", "3:2"] } },
                },
            }],
        };
        const config: AiConfig = {
            ...defaultConfig,
            channels: [channel],
            models: [model],
            imageModels: [model],
            imageModel: model,
            model,
        };

        expect(modelCompatibilityError(config, model, {
            capability: "image",
            input: { textCount: 1, imageCount: 0, videoCount: 0, audioCount: 0, characterCount: 0 },
            videoSeconds: "6",
            imageSize: "3:2",
            options: { size: "3:2" },
        })).toBe("");
    });

    test("后台图片默认比例优先于旧的全局 1:1 配置", () => {
        const model = "platform::managed-image";
        const profile = defaultModelCapabilityConfig(undefined, "managed-image");
        profile.image!.size = { parameter: "size", values: ["1:1", "16:9"], default: "16:9", allowCustom: false };
        const config: AiConfig = {
            ...defaultConfig,
            size: "1:1",
            channels: [{ id: "platform", name: "平台模型", baseUrl: "/api", apiKey: "system", apiFormat: "openai", scope: "system", models: ["managed-image"], modelCosts: [{ model: "managed-image", capability: "image", billingMode: "fixed_request", unitPriceMicrocredits: 1, logicalModelId: "managed-image", logicalCapabilitySpec: { version: 1, capability: "image" }, capabilityConfig: profile }] }],
            models: [model],
            imageModels: [model],
            imageModel: model,
            model,
        };

        expect(resolveModelGenerationDefaults(config, model, "image", {}, { size: "1:1" }).size).toBe("16:9");
    });

    test("后台视频默认时长优先于旧的全局 6 秒配置", () => {
        const model = "platform::managed-video";
        const profile = defaultModelCapabilityConfig(undefined, "managed-video");
        profile.video!.duration = { selection: "enum", values: [6, 15], default: 15 };
        const config: AiConfig = {
            ...defaultConfig,
            videoSeconds: "6",
            channels: [{ id: "platform", name: "平台模型", baseUrl: "/api", apiKey: "system", apiFormat: "openai", scope: "system", models: ["managed-video"], modelCosts: [{ model: "managed-video", capability: "video", billingMode: "per_second", unitPriceMicrocredits: 1, logicalModelId: "managed-video", logicalCapabilitySpec: { version: 1, capability: "video" }, capabilityConfig: profile }] }],
            models: [model],
            videoModels: [model],
            videoModel: model,
            model,
        };

        expect(resolveModelGenerationDefaults(config, model, "video", {}, { videoSeconds: "6" }).videoSeconds).toBe("15");
    });

    test("后台标注的视频模型不因内部标识缺少视频关键词而回退", () => {
        const config = policyConfig();
        const selectedModel = config.videoModels[0]!;
        const videoNode = { ...node("video", CanvasNodeType.Video), metadata: { model: selectedModel } };

        expect(resolveCanvasGenerationModel(config, selectedModel, "video")).toBe(selectedModel);
        expect(buildGenerationConfig(config, videoNode, "video").model).toBe(selectedModel);
    });

    test("同渠道同显示名称合并为一个逻辑模型", () => {
        const config = policyConfig();
        const groups = groupModelsByDisplayName(config, config.videoModels);
        expect(groups).toHaveLength(1);
        expect(groups[0]?.models).toHaveLength(3);
    });

    test("根据参考图自动切换到图生视频细分模型", () => {
        const config = policyConfig();
        const resolved = resolveCompatibleModel(config, "relay::cinema-text", {
            capability: "video",
            input: { textCount: 1, imageCount: 1, videoCount: 0, audioCount: 0, characterCount: 0 },
            videoOperation: "text_to_video",
            videoSeconds: "6",
        });
        expect(resolved).toBe("relay::cinema-image");
    });

    test("音频输入只匹配支持音频的细分模型", () => {
        const config = policyConfig();
        const requirements = {
            capability: "video" as const,
            input: { textCount: 1, imageCount: 0, videoCount: 0, audioCount: 1, characterCount: 0 },
            videoSeconds: "6",
        };
        expect(resolveCompatibleModel(config, "relay::cinema-text", requirements)).toBe("relay::cinema-audio");
        expect(modelCompatibilityError(config, "relay::cinema-image", requirements)).toContain("参考音频");
    });

    test("逻辑模型容量使用同名细分模型的最大值", () => {
        const config = policyConfig();
        expect(modelGroupReferenceLimits(config, "relay::cinema-text", "video")).toEqual({ maxImages: 1, maxVideos: 0, maxAudios: 1 });
    });
});

describe("画布连线能力", () => {
    test("超过所有视频模型的参考图上限时拒绝连线", () => {
        const config = policyConfig();
        const nodes = [node("image-a", CanvasNodeType.Image), node("image-b", CanvasNodeType.Image), node("target", CanvasNodeType.Config, "video")];
        const connections: CanvasConnection[] = [{ id: "existing", fromNodeId: "image-a", toNodeId: "target" }];
        expect(canvasConnectionError(config, nodes, connections, { fromNodeId: "image-b", toNodeId: "target" })).toContain("最多支持 1");
    });

    test("存在音频细分模型时允许音频连接视频生成节点", () => {
        const config = policyConfig();
        const nodes = [node("audio", CanvasNodeType.Audio), node("target", CanvasNodeType.Config, "video")];
        expect(canvasConnectionError(config, nodes, [], { fromNodeId: "audio", toNodeId: "target" })).toBe("");
    });

    test("视频结果不能连接到图片生成节点", () => {
        const config = policyConfig();
        const nodes = [node("video", CanvasNodeType.Video), node("target", CanvasNodeType.Image)];
        expect(canvasConnectionError(config, nodes, [], { fromNodeId: "video", toNodeId: "target" })).toContain("不能连接参考视频");
    });

    test("单个角色卡可以连接到音频生成节点", () => {
        const config = policyConfig();
        const character = { ...node("character", CanvasNodeType.Image), metadata: { workflowKind: "character" as const, characterAssetId: "character-asset" } };
        const nodes = [character, node("target", CanvasNodeType.Audio)];
        expect(canvasConnectionError(config, nodes, [], { fromNodeId: "character", toNodeId: "target" })).toBe("");
    });
});

describe("图片参考图上限", () => {
    test("超出当前模型上限时保留全部输入并返回明确错误", () => {
        const config = policyConfig();
        const modelCost = config.channels[0]?.modelCosts?.[0];
        if (!modelCost?.capabilityConfig?.image) throw new Error("缺少图片能力配置");
        modelCost.capabilityConfig.image.references.maxImages = 1;
        const references = [
            { id: "image-a", name: "image-a.png", type: "image/png", dataUrl: "data:image/png;base64,YQ==" },
            { id: "image-b", name: "image-b.png", type: "image/png", dataUrl: "data:image/png;base64,Yg==" },
        ];

        expect(canvasImageReferenceLimitError(config, references)).toContain("最多支持 1 张参考图，当前已连接 2 张");
        expect(() => assertCanvasImageReferenceLimit(config, references)).toThrow("请移除多余连线后重试");
        expect(references).toHaveLength(2);
    });
});