// scripts/updateJamboxChannels.js
import Database from "better-sqlite3";
import { XMLParser } from "fast-xml-parser";

const DB_PATH =
  process.env.FUZ_DB_PATH || "./src/data/ServicesRange.db";

const JAMBOX_NUMBERS_URL = "https://www.jambox.pl/xml/jamboxwliczbach.xml";

/**
 * Prosty helper do pobrania XML-a
 */
async function fetchXml(url) {
  const res = await fetch(url);
  if (!res.ok) {
    throw new Error(
      `Błąd pobierania XML z ${url}: ${res.status} ${res.statusText}`
    );
  }
  return await res.text();
}

/**
 * Parsowanie XML -> pojedynczy node z licznikami
 */
function parseCountsNode(xmlText) {
  const parser = new XMLParser({
    ignoreAttributes: false,
    attributeNamePrefix: "@_",
  });

  const json = parser.parse(xmlText);

  // dokładnie jak w podglądzie: <xml><node>...</node></xml>
  const node = json.xml?.node ?? json.node ?? null;

  if (!node) {
    throw new Error("Nie znaleziono <node> w jamboxwliczbach.xml");
  }

  return node;
}

function getInt(node, key) {
  const raw = node[key];
  const n = Number(raw);
  if (!Number.isFinite(n)) {
    console.warn(`⚠ Pole ${key} ma dziwną wartość:`, raw);
    return 0;
  }
  return n;
}

/**
 * Pobierz ID cech "Liczba Kanałów" i "Liczba Kanałów HD"
 * żeby nie polegać na tym, że to zawsze 7 i 8.
 */
function getChannelFeatureIds(db) {
  const rows = db
    .prepare(
      `
      SELECT id, label
      FROM internet_features
      WHERE label IN ('Liczba Kanałów', 'Liczba Kanałów HD');
    `
    )
    .all();

  let channelsId = null;
  let channelsHdId = null;

  for (const row of rows) {
    if (row.label === "Liczba Kanałów") channelsId = row.id;
    if (row.label === "Liczba Kanałów HD") channelsHdId = row.id;
  }

  if (!channelsId || !channelsHdId) {
    throw new Error(
      `Brak wymaganych cech w internet_features (Liczba Kanałów / Liczba Kanałów HD).`
    );
  }

  console.log(
    `ℹ Feature IDs: "Liczba Kanałów" = ${channelsId}, "Liczba Kanałów HD" = ${channelsHdId}`
  );

  return { channelsId, channelsHdId };
}

/**
 * Zwraca mapę (source, slug) -> package_id z jambox_base_packages
 */
function getPackageIdLookup(db) {
  const rows = db
    .prepare(
      `
      SELECT id, source, slug
      FROM jambox_base_packages;
    `
    )
    .all();

  const map = new Map();

  for (const row of rows) {
    if (!row.source || !row.slug) continue;
    const key = `${row.source}::${row.slug}`;
    map.set(key, row.id);
  }

  return map;
}

/**
 * Aktualizacja rekordów w jambox_package_feature_values
 * dla "Liczba Kanałów" i "Liczba Kanałów HD"
 */
function updateChannelFeatureValues(db, packages, featureIds, packageIdMap) {
  const { channelsId, channelsHdId } = featureIds;

  const upsertStmt = db.prepare(`
    INSERT INTO jambox_package_feature_values (package_id, feature_id, value)
    VALUES (@package_id, @feature_id, @value)
    ON CONFLICT(package_id, feature_id) DO UPDATE SET
      value = excluded.value;
  `);

  const tx = db.transaction((rows) => {
    let total = 0;

    for (const pkg of rows) {
      const key = `${pkg.source}::${pkg.slug}`;
      const packageId = packageIdMap.get(key);

      if (!packageId) {
        console.warn(
          `⚠ Brak pakietu w jambox_base_packages dla: source=${pkg.source}, slug="${pkg.slug}"`
        );
        continue;
      }

      // Liczba Kanałów
      upsertStmt.run({
        package_id: packageId,
        feature_id: channelsId,
        value: String(pkg.canals),
      });

      // Liczba Kanałów HD
      upsertStmt.run({
        package_id: packageId,
        feature_id: channelsHdId,
        value: String(pkg.canalshd),
      });

      total += 2;
    }

    console.log(
      `✅ Zaktualizowano / wstawiono ${total} wartości cech w jambox_package_feature_values.`
    );
  });

  tx(packages);
}

async function main() {
  console.log(`Używam bazy: ${DB_PATH}`);
  const db = new Database(DB_PATH); // tu normalne R/W połączenie

  console.log(`\n=== Pobieram JAMBOX "w liczbach" ===`);
  const xml = await fetchXml(JAMBOX_NUMBERS_URL);
  const node = parseCountsNode(xml);

  // 🔗 Ręczne mapowanie z ich XML-a na nasze pakiety (source + slug)
  const packages = [
    // EVIO
    {
      source: "EVIO",
      slug: "smart",
      canals: getInt(node, "ilosc_kanalow_eviosmart"),
      canalshd: getInt(node, "ilosc_kanalow_hd_eviosmart"),
    },
    {
      source: "EVIO",
      slug: "optimum",
      canals: getInt(node, "ilosc_kanalow_eviooptimum"),
      canalshd: getInt(node, "ilosc_kanalow_hd_eviooptimum"),
    },
    {
      source: "EVIO",
      slug: "platinum",
      canals: getInt(node, "ilosc_kanalow_evioplatinum"),
      canalshd: getInt(node, "ilosc_kanalow_hd_evioplatinum"),
    },

    // PLUS
    {
      source: "PLUS",
      slug: "podstawowy",
      canals: getInt(node, "ilosc_kanalow_podstawowy"),
      canalshd: getInt(node, "ilosc_kanalow_hd_podstawowy"),
    },
    {
      source: "PLUS",
      slug: "korzystny",
      canals: getInt(node, "ilosc_kanalow_korzystny"),
      canalshd: getInt(node, "ilosc_kanalow_hd_korzystny"),
    },
    {
      source: "PLUS",
      slug: "bogaty",
      canals: getInt(node, "ilosc_kanalow_bogaty"),
      canalshd: getInt(node, "ilosc_kanalow_hd_bogaty"),
    },
  ];

  console.log("🧮 Pakiety do aktualizacji:");
  packages.forEach((p) => {
    console.log(
      `  - ${p.source} / ${p.slug}: ${p.canals} kanałów, ${p.canalshd} HD`
    );
  });

  // 🔹 Pobierz ID cech i mapę pakietów
  const featureIds = getChannelFeatureIds(db);
  const packageIdMap = getPackageIdLookup(db);

  // 🔹 Aktualizacja tabeli jambox_package_feature_values
  updateChannelFeatureValues(db, packages, featureIds, packageIdMap);

  db.close();
  console.log("\n🎉 Aktualizacja liczby kanałów zakończona.");
}

main().catch((err) => {
  console.error("❌ Krytyczny błąd:", err);
  process.exit(1);
});
