import { test } from "node:test";
import assert from "node:assert/strict";
import fs from "node:fs";
import path from "node:path";
import { fileURLToPath } from "node:url";
import { parseBobochicProduct, extractBobochicImages, BobochicParseError, parseUrlFragmentAttrs } from "../src/import/bobochic.js";

const fixtureHtml = fs.readFileSync(
  path.join(path.dirname(fileURLToPath(import.meta.url)), "fixtures", "bobochic-product.html"),
  "utf8",
);
const PRODUCT_URL =
  "https://bobochicparis.com/fr/canapes-d-angle-convertibles/18302-canape-d-angle-convertible-fuji-tissu-lisse.html#/7-couleur-beige/244-type_d_angle-angle_droit";

const fixture3AttrHtml = fs.readFileSync(
  path.join(path.dirname(fileURLToPath(import.meta.url)), "fixtures", "bobochic-product-3attr.html"),
  "utf8",
);
const PRODUCT_3ATTR_URL_NO_FRAGMENT =
  "https://bobochicparis.com/fr/canapes-d-angle-convertibles/18789-canape-d-angle-l-convertible-coffre-everest-tissu-chine.html";
const PRODUCT_3ATTR_URL_WITH_FRAGMENT =
  `${PRODUCT_3ATTR_URL_NO_FRAGMENT}#/8-couleur-blanc/244-type_d_angle-angle_droit/864-lot-5_coussins`;

const fixtureColorHtml = fs.readFileSync(
  path.join(path.dirname(fileURLToPath(import.meta.url)), "fixtures", "bobochic-sofa-color.html"),
  "utf8",
);
const SOFA_URL_NO_FRAGMENT =
  "https://bobochicparis.com/fr/canapes-droits-convertibles/17001-canape-droit-convertible-coffre-arsene-tissu-velours.html";

test("bobochic parser: wymiary, cechy, warianty i kolekcja z realnego snapshotu", () => {
  const p = parseBobochicProduct(fixtureHtml, PRODUCT_URL);
  assert.equal(p.collection, "FUJI");
  assert.equal(p.productRef, "18302");
  assert.match(p.name, /FUJI/);
  const par = p.params;
  assert.equal(par.widthCm, 292);
  assert.equal(par.depthCm, 160);
  assert.equal(par.heightCm, 88);
  assert.equal(par.heightWithoutCushionsCm, 79);
  assert.equal(par.sleepWidthCm, 154);
  assert.equal(par.sleepLengthCm, 230);
  assert.equal(par.seatHeightCm, 44);
  assert.equal(par.seatDepthCm, 0); // klucz bez "avec coussins" nie istnieje w cechach
  assert.equal(par.meridianSeatDepthWithCushionsCm, 113);
  assert.equal(par.martindale, 45000);
  assert.equal(par.antiBouloches, true);
  assert.equal(par.deperlant, false);
  assert.equal(par.places, 3);
  assert.equal(par.feetCount, 14);
  assert.equal(par.coffre, true);
  assert.equal(par.convertibleOui, true);
  assert.equal(par.reversible, false);
  assert.equal(p.packages.length, 2);
  assert.deepEqual(p.packages[0], { index: 1, lengthCm: 167, widthCm: 66, heightCm: 89, weightKg: 58 });
  assert.equal(p.gtin, "5905490067180");
  assert.equal(p.priceEur, 1699);
  assert.equal(p.color, "Beige");
  assert.deepEqual(p.sides, ["P", "L"].sort());
});

test("bobochic parser: fragment URL wskazuje wariant; nieznany fragment = guessed", () => {
  const p = parseBobochicProduct(fixtureHtml, PRODUCT_URL);
  assert.equal(p.resolvedVariant?.gtin, "5905490067180");
  assert.equal(p.resolvedVariant?.typeAngle, "Angle droit");
  assert.equal(p.resolvedVariant?.guessed, undefined);
  const other = parseBobochicProduct(fixtureHtml, PRODUCT_URL.split("#")[0]! + "#/9-couleur-gris/245-type_d_angle-angle_gauche");
  assert.equal(other.resolvedVariant?.guessed, true);
  assert.equal(other.resolvedVariant?.gtin, "5905490067180");
  assert.deepEqual(parseUrlFragmentAttrs(PRODUCT_URL), { couleur: "beige", type_d_angle: "angle_droit" });
});

test("bobochic parser: brak danych produktu i kategoria nietapicerowana to błąd, nie fallback", () => {
  assert.throws(
    () => parseBobochicProduct("<!doctype html><html><body>sklep, ale bez produktu</body></html>", PRODUCT_URL),
    (e: unknown) => e instanceof BobochicParseError && e.code === "no_product_data",
  );
  assert.throws(
    () => parseBobochicProduct(fixtureHtml, "https://bobochicparis.com/fr/tapis/999-tapis-deco.html"),
    (e: unknown) => e instanceof BobochicParseError && e.code === "unsupported_category",
  );
  assert.throws(() => parseBobochicProduct("", PRODUCT_URL), BobochicParseError);
});

test("bobochic galeria: zdjęcia rozstrzygniętego wariantu — oryginał CDN + fallback thickbox", () => {
  const p = parseBobochicProduct(fixtureHtml, PRODUCT_URL);
  const g = extractBobochicImages(fixtureHtml, p);
  assert.equal(g.scope, "combination");
  assert.equal(g.combinationId, "47876");
  assert.deepEqual(g.images.map((i) => i.imageId), ["287998", "287999", "288000"]);
  assert.deepEqual(g.images.map((i) => i.position), [1, 2, 3]);
  assert.equal(g.images[0]!.url, "https://cdn.bobochicparis.com/287998/canape-d-angle-convertible-fuji-tissu-lisse.jpg");
  assert.equal(g.images[0]!.fallbackUrl, "https://cdn.bobochicparis.com/287998-thickbox_default/canape-d-angle-convertible-fuji-tissu-lisse.jpg");

  // inny wariant (angle_gauche) → inna kombinacja i inna galeria
  const p2 = parseBobochicProduct(fixtureHtml, PRODUCT_URL.split("#")[0]! + "#/7-couleur-beige/245-type_d_angle-angle_gauche");
  const g2 = extractBobochicImages(fixtureHtml, p2);
  assert.equal(g2.combinationId, "47877");
  assert.deepEqual(g2.images.map((i) => i.imageId), ["288020", "288021"]);
});

test("bobochic galeria: brak mapy kombinacji → fallback na okładki strony", () => {
  const p = parseBobochicProduct(fixtureHtml, PRODUCT_URL);
  const noJs = fixtureHtml.replace(/<script>[\s\S]*?<\/script>/g, "").replace(/<div class="gallery-link"[\s\S]*?<\/div>\n?/g, "").replace(/<span class="alternate_image_url">[^<]*<\/span>\n?/g, "");
  const g = extractBobochicImages(noJs, p);
  assert.equal(g.scope, "page");
  assert.equal(g.combinationId, null);
  assert.ok(g.images.length >= 2);
  assert.ok(g.images.every((i) => i.url.startsWith("https://")));
});

test("bobochic galeria: realny snapshot FUJI z tmp/ (jeśli obecny) — pełna galeria wariantu", () => {
  const real = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../tmp/fuji/fuji.html");
  if (!fs.existsSync(real)) return;
  const html = fs.readFileSync(real, "utf8");
  const p = parseBobochicProduct(html, PRODUCT_URL);
  const g = extractBobochicImages(html, p);
  assert.equal(g.scope, "combination");
  assert.equal(g.images.length, 15);
  assert.deepEqual(g.images[0]!.imageId, "287998");
  assert.ok(g.images.every((i) => /^https:\/\/cdn\.bobochicparis\.com\/\d+\//.test(i.url) && i.fallbackUrl));
});

test("bobochic parser: realny snapshot FUJI z tmp/ (jeśli obecny) daje komplet parametrów", () => {
  const real = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../tmp/fuji/fuji.html");
  if (!fs.existsSync(real)) return;
  const p = parseBobochicProduct(fs.readFileSync(real, "utf8"), PRODUCT_URL);
  assert.equal(p.collection, "FUJI");
  assert.ok(p.params.widthCm > 0 && p.params.depthCm > 0);
  assert.ok(p.variants.length >= 2);
  assert.ok(Object.keys(p.features).length >= 40);
  assert.deepEqual(p.sides, ["L", "P"]);
});

// --- produkt 3-atrybutowy (kolor + kąt + "Lot"/liczba poduszek), jak realny
// Everest — regresja na usterkę zgłoszoną przez operatora: zbyt mało zdjęć
// i kolor niezgodny z zamierzonym wariantem (patrz .devin/STAN.md). ---------

test("bobochic parser 3-atrybutowy: sztywny regex 2-atrybutowy nie gubi kombinacji z dodatkowym atrybutem", () => {
  const p = parseBobochicProduct(fixture3AttrHtml, PRODUCT_3ATTR_URL_WITH_FRAGMENT);
  assert.equal(p.variants.length, 3);
  const blancDroit = p.variants.find((v) => v.couleurSlug === "blanc" && v.angleSlug === "angle_droit");
  assert.ok(blancDroit, "kombinacja Blanc/Angle droit powinna zostać sparsowana mimo atrybutu Lot pomiędzy Type d'angle i prix_ttc");
  assert.equal(blancDroit!.color, "Blanc");
  assert.equal(blancDroit!.typeAngle, "Angle droit");
  assert.equal(blancDroit!.priceEur, 2099);
  assert.deepEqual(blancDroit!.attrIds, [8, 244, 864]);
  const taupeDroit = p.variants.find((v) => v.couleurSlug === "taupe");
  assert.ok(taupeDroit);
  assert.equal(taupeDroit!.color, "Taupe");
});

test("bobochic parser 3-atrybutowy: fragment z konkretnym wariantem rozstrzyga dokładną kombinację (nie guessed)", () => {
  const p = parseBobochicProduct(fixture3AttrHtml, PRODUCT_3ATTR_URL_WITH_FRAGMENT);
  assert.equal(p.resolvedVariant?.guessed, undefined);
  assert.equal(p.resolvedVariant?.color, "Blanc");
  assert.equal(p.resolvedVariant?.typeAngle, "Angle droit");
});

test("bobochic galeria 3-atrybutowa: fragment z 3 atrybutami trafia we właściwą kombinację (nie w pierwszą z brzegu)", () => {
  const p = parseBobochicProduct(fixture3AttrHtml, PRODUCT_3ATTR_URL_WITH_FRAGMENT);
  const g = extractBobochicImages(fixture3AttrHtml, p);
  assert.equal(g.scope, "combination");
  assert.equal(g.combinationId, "60260");
  assert.deepEqual(g.images.map((i) => i.imageId), ["320764", "320765", "320766"]);
});

test("bobochic galeria 3-atrybutowa: URL bez fragmentu i >1 kolor → ambiguous, ZERO zdjęć, lista wariantów do wyboru", () => {
  const p = parseBobochicProduct(fixture3AttrHtml, PRODUCT_3ATTR_URL_NO_FRAGMENT);
  // Bez fragmentu w URL, resolvedVariant jest zgadywany (pierwsza kombinacja).
  assert.equal(p.resolvedVariant?.guessed, true);
  const g = extractBobochicImages(fixture3AttrHtml, p);
  assert.equal(g.scope, "ambiguous");
  assert.deepEqual(g.images, []);
  assert.ok(g.availableVariants && g.availableVariants.length === 3, "lista dostępnych wariantów zamiast domyślnego zgadywania");
  assert.ok(g.availableVariants!.some((v) => v.color === "Blanc" && v.typeAngle === "Angle droit" && v.url.includes("#/")));
  assert.ok(g.availableVariants!.some((v) => v.color === "Taupe"));
});

// --- produkt tylko-kolorystyczny (sofa prosta ARSENE: atrybut couleur,
// bez type_d_angle) — regresja na usterkę operatora: import pobierał
// okładki strony zamiast galerii wybranego koloru. -------------------

test("bobochic parser tylko-kolor: warianty bez type_d_angle nie są odrzucane; brak stron", () => {
  const p = parseBobochicProduct(fixtureColorHtml, SOFA_URL_NO_FRAGMENT + "#/14-couleur-bleu");
  assert.equal(p.variants.length, 2);
  assert.deepEqual(p.sides, []);
  assert.equal(p.resolvedVariant?.guessed, undefined);
  assert.equal(p.resolvedVariant?.color, "Bleu");
  assert.equal(p.resolvedVariant?.gtin, "5905490025654");
  assert.deepEqual(p.resolvedVariant?.attrIds, [14]);
});

test("bobochic galeria tylko-kolor: fragment koloru → kombinacja i pełna galeria wariantu", () => {
  const p = parseBobochicProduct(fixtureColorHtml, SOFA_URL_NO_FRAGMENT + "#/14-couleur-bleu");
  const g = extractBobochicImages(fixtureColorHtml, p);
  assert.equal(g.scope, "combination");
  assert.equal(g.combinationId, "35853");
  assert.deepEqual(g.images.map((i) => i.imageId), ["238889", "238890", "238891"]);
  assert.equal(g.images[0]!.url, "https://cdn.bobochicparis.com/238889/canape-droit-convertible-coffre-arsene-tissu-velours.jpg");
});

test("bobochic galeria tylko-kolor: pusty fragment i >1 kolor → ambiguous z listą wariantów (url bez segmentu kąta)", () => {
  const p = parseBobochicProduct(fixtureColorHtml, SOFA_URL_NO_FRAGMENT + "#");
  assert.equal(p.resolvedVariant?.guessed, true);
  const g = extractBobochicImages(fixtureColorHtml, p);
  assert.equal(g.scope, "ambiguous");
  assert.deepEqual(g.images, []);
  assert.equal(g.availableVariants?.length, 2);
  const bleu = g.availableVariants!.find((v) => v.color === "Bleu")!;
  assert.equal(bleu.url, SOFA_URL_NO_FRAGMENT + "#/14-couleur-bleu");
  assert.ok(!bleu.url.includes("type_d_angle"));
});