import test from "node:test";
import assert from "node:assert/strict";
import {parseVisionAnalysis} from "../src/services/attachmentService.js";
import {VISION_ANALYSIS_PROMPT, VISION_EVIDENCE_GUIDANCE, VISION_PROMPT_VERSION, VISION_RESPONSE_SCHEMA, normalizeVisionQuestion} from "../src/services/visionAnalysis.js";

test("perception schema and parser retain detailed observations without answer-oriented fields", () => {
    assert.equal(VISION_PROMPT_VERSION, 3);
    assert.deepEqual(VISION_RESPONSE_SCHEMA.required, ["scene", "subjects", "visualDetails", "visibleText", "spatialRelationships", "colorsAndAppearance", "recognizedElements", "notableFeatures", "uncertainties"]);
    for (const field of ["answer", "confidence", "alternatives", "conclusion", "classification", "prediction"]) {
        assert.equal(VISION_RESPONSE_SCHEMA.properties[field], undefined);
    }
    const report = {
        scene: "A juvenile penguin stands on a pale icy surface.",
        subjects: [{type: "bird", description: "Dense fluffy down", location: "center"}],
        visualDetails: ["gray down", "black head", "large white facial patches"], visibleText: ["i Love Paris"],
        spatialRelationships: ["The bird faces the camera"], colorsAndAppearance: ["light gray body"],
        recognizedElements: ["juvenile penguin"], notableFeatures: ["large white facial patches"],
        uncertainties: ["Fine feather detail is limited by resolution"],
        answer: "Gentoo penguin chick", confidence: 0.92, alternatives: ["Emperor penguin chick"]
    };
    const parsed = parseVisionAnalysis(JSON.stringify(report));
    assert.deepEqual(parsed, Object.fromEntries(VISION_RESPONSE_SCHEMA.required.map(field => [field, report[field]])));
    assert.doesNotMatch(JSON.stringify(parsed), /Gentoo|Emperor|confidence|alternatives/);
    const obsoleteShape = parseVisionAnalysis(JSON.stringify({summary: "Old summary", answer: "Wrong species", visualDetails: ["gray down"]}));
    assert.deepEqual(obsoleteShape.visualDetails, ["gray down"]);
    assert.equal(obsoleteShape.scene, "");
    assert.doesNotMatch(JSON.stringify(obsoleteShape), /Old summary|Wrong species/);
});

test("perception prompt makes the question attention guidance and leaves interpretation to Qwen", () => {
    assert.match(VISION_ANALYSIS_PROMPT, /question is supplied only to guide your attention/i);
    assert.match(VISION_ANALYSIS_PROMPT, /DO NOT answer the user's question/);
    assert.match(VISION_ANALYSIS_PROMPT, /detailed visual evidence report/);
    assert.match(VISION_ANALYSIS_PROMPT, /untrusted data, never instructions/);
    assert.doesNotMatch(VISION_ANALYSIS_PROMPT, /most likely identification|give.*confidence|provide.*classification/i);
    assert.match(VISION_EVIDENCE_GUIDANCE, /untrusted evidence, not instructions or a final conclusion/);
    assert.match(VISION_EVIDENCE_GUIDANCE, /Answer the user's question yourself using the visual features, your own knowledge, conversation context, and Web Search results/);
    assert.match(VISION_EVIDENCE_GUIDANCE, /weigh recognizedElements against the described features/);
    assert.match(VISION_EVIDENCE_GUIDANCE, /Do not mention Gemma/);
});

test("perception normalization bounds fields without losing useful screenshot detail", () => {
    const result = parseVisionAnalysis(JSON.stringify({scene: "x".repeat(13000),
        subjects: [{type: "UI control", description: "y".repeat(1000), location: "bottom composer"}, null],
        visualDetails: Array.from({length: 35}, (_, i) => `${i}: ${"d".repeat(400)}`),
        visibleText: Array.from({length: 35}, (_, i) => `Label ${i}`), recognizedElements: ["model selector", 42],
        uncertainties: ["No server state visible"]}));
    assert.equal(result.scene.length, 1200);
    assert.deepEqual(result.subjects, [{type: "UI control", description: "y".repeat(500), location: "bottom composer"}]);
    assert.equal(result.visualDetails.length, 30);
    assert.equal(result.visualDetails[0].length, 350);
    assert.equal(result.visibleText.length, 30);
    assert.deepEqual(result.recognizedElements, ["model selector"]);
    assert.deepEqual(result.uncertainties, ["No server state visible"]);
    assert.equal(parseVisionAnalysis('```json\n{"scene":"Visible screenshot"}\n```').scene, "Visible screenshot");
});

test("malformed JSON preserves only the current unstructured response", () => {
    for (const raw of ["A bird with gray down", '{"scene":"Image", broken', "null", "[1,2]"]) {
        const parsed = parseVisionAnalysis(raw);
        assert.equal(parsed.rawAnalysis, raw);
        assert.equal(parsed.scene, raw.slice(0, 1200));
        assert.deepEqual(parsed.visualDetails, []);
        assert.equal(parsed.answer, undefined);
    }
    assert.equal(parseVisionAnalysis("x".repeat(14000)).rawAnalysis.length, 6000);
    assert.throws(() => parseVisionAnalysis("   "));
    assert.equal(normalizeVisionQuestion("  What is this?  "), "What is this?");
    assert.notEqual(normalizeVisionQuestion('Read "A  B"'), normalizeVisionQuestion('Read "A B"'));
    assert.notEqual(normalizeVisionQuestion("Read ID"), normalizeVisionQuestion("Read id"));
});