/* ============================================================
   LF CONCEITO — Importação em lote de produtos (painel admin)
   Usa só os caminhos normais do painel: uploadImage (Edge Function
   upload-image, exige sessão de admin) e os inserts do DB.* sob RLS.
   Todo produto importado nasce INATIVO, com preço e estoque provisórios.
   ============================================================ */

const IMPORT_CACHE_PREFIX = "lf_import_v1:";
const IMPORT_MAX_PHOTOS = 5; // mesmo limite do formulário

// Valida o manifesto e decide o que pode ser importado. Pura (testável).
// manifest: { version, provisional:{price,stock}, products:[...] }
// fileNames: nomes dos arquivos de imagem selecionados.
// Retorna { errors: [...], items: [{ p, status: "ready"|"pending"|"invalid", reasons }] }
function planImport(manifest, categorySlugs, fileNames) {
  const errors = [];
  if (!manifest || manifest.version !== 1 || !Array.isArray(manifest.products))
    return { errors: ["Manifesto inválido (esperado version 1 com a lista products)."], items: [] };
  const price = Number(manifest.provisional && manifest.provisional.price);
  const stock = Number(manifest.provisional && manifest.provisional.stock);
  if (!(price > 0)) errors.push("Preço provisório inválido no manifesto.");
  if (!Number.isInteger(stock) || stock < 0) errors.push("Estoque provisório inválido no manifesto.");
  const files = new Set(fileNames);
  const seenIds = new Set(), seenSkus = new Set();
  const items = manifest.products.map(p => {
    const reasons = [];
    if (!p || typeof p.id !== "string" || !/^[a-z0-9-]{3,80}$/.test(p.id)) reasons.push("id inválido");
    if (!p.sku) reasons.push("SKU ausente");
    if (seenIds.has(p.id)) reasons.push("id repetido no manifesto");
    if (seenSkus.has(p.sku)) reasons.push("SKU repetido no manifesto");
    seenIds.add(p.id); seenSkus.add(p.sku);
    if (p.eligible !== true)
      return { p, status: "pending", reasons: reasons.concat(p.pending_reasons || ["não liberado para importação"]) };
    if (!p.name || !String(p.name).trim()) reasons.push("nome ausente");
    if (!categorySlugs.includes(p.cat)) reasons.push(`categoria desconhecida: ${p.cat}`);
    const imgs = Array.isArray(p.images) ? p.images : [];
    if (imgs.length === 0) reasons.push("sem fotos");
    if (imgs.length > IMPORT_MAX_PHOTOS) reasons.push(`mais de ${IMPORT_MAX_PHOTOS} fotos`);
    // Produto sem cor (ex.: perfume): nenhuma foto tem cor. Misturar fotos com e sem cor é erro.
    const colored = imgs.filter(im => im.color).length;
    if (colored > 0 && colored < imgs.length) reasons.push("há fotos sem cor neste produto");
    imgs.forEach(im => {
      if (!im.file || !files.has(im.file)) reasons.push(`foto não selecionada: ${im.file}`);
    });
    (p.variants || []).forEach(v => {
      if (!v.color || !v.size) reasons.push("variante sem cor ou tamanho");
      if (!imgs.some(im => im.color === v.color)) reasons.push(`variante sem foto da cor: ${v.color}`);
    });
    return { p, status: reasons.length ? "invalid" : "ready", reasons };
  });
  return { errors, items };
}

// Monta o produto no formato do DB.* -- sempre inativo, preço/estoque do
// manifesto e a marca de cadastro provisório no campo Linha (bloqueia ativar).
function buildImportProduct(p, urls, provisional, provisionalLine) {
  const images = p.images.map((im, i) => ({ url: urls[i], color: im.color || "", sizes: im.sizes || [] }));
  return {
    id: p.id, sku: p.sku, name: p.name, cat: p.cat, sub: p.sub || "",
    brandline: provisionalLine, tag: "", featured: false,
    active: false,
    price: Number(provisional.price), compareAt: 0,
    sizes: p.sizes || [],
    colors: [...new Set(p.images.map(im => im.color).filter(Boolean))],
    stock: Number(provisional.stock),
    images, image_url: images[0].url,
    description: p.description || "", composition: p.composition || "",
    rating: null, reviewsCount: null,
  };
}

function importCacheGet(id) {
  try { return JSON.parse(localStorage.getItem(IMPORT_CACHE_PREFIX + id) || "{}"); } catch (e) { return {}; }
}
function importCacheSet(id, v) {
  try { localStorage.setItem(IMPORT_CACHE_PREFIX + id, JSON.stringify(v)); } catch (e) {}
}
function importCacheClear(id) {
  try { localStorage.removeItem(IMPORT_CACHE_PREFIX + id); } catch (e) {}
}

// Importa um produto. deps = { uploadImage, createProduct, saveVariants, updateStock,
// provisionalLine, sharedUrls }. Fotos já enviadas numa tentativa anterior (cache
// local) ou por outro produto nesta execução (sharedUrls) não são reenviadas.
async function importOneProduct(p, fileByName, provisional, deps) {
  const cache = importCacheGet(p.id);
  const shared = deps.sharedUrls || {};
  const urls = [];
  for (const im of p.images) {
    if (!cache[im.file]) {
      cache[im.file] = shared[im.file] || await deps.uploadImage(fileByName[im.file]);
      importCacheSet(p.id, cache);
    }
    shared[im.file] = cache[im.file];
    urls.push(cache[im.file]);
  }
  try {
    await deps.createProduct(buildImportProduct(p, urls, provisional, deps.provisionalLine));
  } catch (e) {
    if (e && e.code === "23505") return { status: "skipped", message: "já existe no banco (não alterado)" };
    throw e;
  }
  const variants = (p.variants || []).map(v => ({ color: v.color, size: v.size, stock: Number(provisional.stock) }));
  if (variants.length) {
    await deps.saveVariants(p.id, variants, {});
    await deps.updateStock(p.id, variants.reduce((s, v) => s + v.stock, 0));
  }
  importCacheClear(p.id);
  return { status: "created", message: `${urls.length} foto(s), ${variants.length} variante(s)` };
}

function BatchImport({ onDone }) {
  const { categories } = window.useStore();
  const cats = categories || CATEGORIES;
  const [manifest, setManifest] = useState(null);
  const [files, setFiles] = useState([]);
  const [msg, setMsg] = useState("");
  const [running, setRunning] = useState(false);
  const [results, setResults] = useState({}); // id -> { status, message }

  const plan = manifest ? planImport(manifest, cats.map(c => c.slug), files.map(f => f.name)) : null;
  const ready = plan ? plan.items.filter(it => it.status === "ready") : [];

  async function readManifest(e) {
    const f = e.target.files && e.target.files[0];
    if (!f) return;
    try { setManifest(JSON.parse(await f.text())); setMsg(""); setResults({}); }
    catch (err) { setManifest(null); setMsg("❌ Não foi possível ler o manifesto (JSON inválido)."); }
  }

  async function run() {
    if (!plan || plan.errors.length || !ready.length) return;
    setRunning(true); setMsg("");
    const res = {};
    try {
      const { data: { session } } = await window._sb.auth.getSession();
      if (!session) throw new Error("Sessão expirada. Entre novamente no painel.");
      // Confere sessão/permissão no servidor de imagens antes do primeiro
      // produto (requisição sem corpo: responde rápido e com a causa real).
      await window.checkUploadAccess();
      const existing = await window.DB.findExistingProducts(ready.map(it => it.p.id), ready.map(it => it.p.sku));
      const fileByName = Object.fromEntries(files.map(f => [f.name, f]));
      if (!window.DB.PROVISIONAL_LINE) throw new Error("Painel desatualizado: recarregue a página.");
      const deps = { uploadImage: window.uploadImage, createProduct: window.DB.createProduct,
                     saveVariants: window.DB.saveVariants, updateStock: window.DB.updateStock,
                     provisionalLine: window.DB.PROVISIONAL_LINE, sharedUrls: {} };
      let stopped = null;
      for (const it of ready) {
        const p = it.p;
        if (stopped) { res[p.id] = { status: "stopped", message: "não processado: importação interrompida" }; continue; }
        const clash = Object.entries(existing).find(([id, sku]) => id === p.id || (sku && sku === p.sku));
        if (clash) {
          res[p.id] = { status: "skipped", message: `já existe (${clash[0]}) — não alterado` };
        } else {
          res[p.id] = { status: "running", message: "enviando…" };
          setResults({ ...res });
          try { res[p.id] = await importOneProduct(p, fileByName, manifest.provisional, deps); }
          catch (err) {
            res[p.id] = { status: "error", message: (err && err.message) || "erro" };
            // Falha que vale para todas as fotos (sessão, permissão, conexão): para aqui.
            if (err && err.fatal) stopped = err.message;
          }
        }
        setResults({ ...res });
      }
      await window.refreshProducts?.();
      const n = s => Object.values(res).filter(r => r.status === s).length;
      setMsg((stopped ? `❌ Importação interrompida: ${stopped} ` : "Concluído: ") +
        `${n("created")} criado(s), ${n("skipped")} já existente(s), ${n("error")} com erro, ${n("stopped")} não processado(s). ` +
        "Produtos criados estão INATIVOS. Rode de novo para continuar: o que já foi criado é pulado.");
    } catch (err) {
      setMsg("❌ " + ((err && err.message) || "erro"));
    } finally {
      setRunning(false);
    }
  }

  const label = { ready: "Pronto", pending: "Pendente", invalid: "Com erro",
                  created: "✅ Criado (inativo)", skipped: "Já existe", error: "❌ Erro", running: "Enviando…",
                  stopped: "Não processado" };

  return (
    <div className="card" style={{maxWidth:980}}>
      <div className="card-head">
        <h3>Importar produtos em lote</h3>
        {onDone && <button className="sh-ic" onClick={onDone} disabled={running}><Icon name="x" size={18}/></button>}
      </div>
      <div style={{padding:"0 22px 22px"}}>
        <p className="cell-dim" style={{fontSize:13,marginTop:0}}>
          Todo produto importado é criado <b>inativo</b>, com preço e estoque provisórios do manifesto
          e a marca "CADASTRO PROVISÓRIO" no campo Linha: para ativar, confirme os dados reais e apague essa marca.
          Produtos que já existem (mesmo id ou SKU) não são alterados. Se a importação parar no meio,
          rode de novo com os mesmos arquivos: o que já foi criado é pulado.
        </p>
        <div className="ff-row">
          <div className="ff"><label>1. Manifesto (manifesto_importacao.json)</label>
            <input type="file" accept="application/json,.json" onChange={readManifest} disabled={running}/>
          </div>
          <div className="ff"><label>2. Fotos (pode selecionar em mais de uma pasta)</label>
            <input type="file" accept="image/jpeg,image/png,image/webp" multiple disabled={running}
              onChange={e=>{
                const picked = Array.from(e.target.files||[]);
                setFiles(prev => [...prev.filter(f => !picked.some(n => n.name === f.name)), ...picked]);
                e.target.value = "";
              }}/>
            <small className="cell-dim" style={{fontSize:11,display:"block",marginTop:4}}>
              {files.length} foto(s) selecionada(s)
              {files.length>0 && !running && <> · <a href="#" onClick={e=>{e.preventDefault();setFiles([]);}}>limpar</a></>}
            </small>
          </div>
        </div>
        {plan && plan.errors.map(er => <p key={er} style={{color:"var(--red)",fontSize:13}}>{er}</p>)}
        {plan &&
          <div className="card no-pad" style={{margin:"12px 0"}}>
            <table className="tbl tbl-pad">
              <thead><tr><th>Produto</th><th>SKU</th><th>Fotos</th><th>Situação</th><th>Detalhe</th></tr></thead>
              <tbody>
                {plan.items.map(it => {
                  const r = results[it.p.id];
                  return (
                    <tr key={it.p.id + it.p.sku}>
                      <td><b>{it.p.name}</b><small className="mono cell-dim" style={{display:"block"}}>{it.p.id}</small></td>
                      <td className="mono">{it.p.sku}</td>
                      <td className="ta-c">{(it.p.images||[]).length}</td>
                      <td>{label[r ? r.status : it.status]}</td>
                      <td style={{fontSize:12}}>{r ? r.message : it.reasons.join(" · ")}</td>
                    </tr>);
                })}
              </tbody>
            </table>
          </div>}
        {msg && <div style={{margin:"10px 0",fontSize:13,fontWeight:600}}>{msg}</div>}
        <Btn variant="gold" icon="check" onClick={run}
          disabled={running || !plan || plan.errors.length>0 || ready.length===0}>
          {running ? "Importando…" : `Importar ${ready.length} produto(s) prontos`}
        </Btn>
      </div>
    </div>
  );
}

Object.assign(window, { BatchImport, planImport, buildImportProduct, importOneProduct });
