// ─── UTILS ──────────────────────────────────────────────────

import { DEFAULT_ABSENZ_TYPES } from "./constants.js";

// SIA-Honorar-Formel: p = Z1 + Z2 / ∛B
export function calcSIAHours(baukosten, schwierigkeit, phasen) {
  if (!baukosten || baukosten <= 0) return { p: 0, total: 0, phases: [] };
  const cbrtB = Math.cbrt(baukosten);
  const p = 0.062 + 10.58 / cbrtB;
  const results = phasen.map(ph => {
    const items = ph.items.map(it => {
      if (it.enabled === false) return { ...it, hours: 0 };
      const r = it.r ?? 1;
      const hours = baukosten * (p / 100) * schwierigkeit * (it.pct / 100) * r;
      return { ...it, hours: Math.round(hours * 10) / 10 };
    });
    const phaseHours = items.reduce((s, it) => s + it.hours, 0);
    return { ...ph, items, hours: phaseHours };
  });
  const total = results.reduce((s, ph) => s + ph.hours, 0);
  return { p: Math.round(p * 1000) / 1000, cbrtB, total, phases: results };
}

// Manuelle Aufwandschätzung: Stunden pro Rolle × Stundensatz
export function calcManualHours(phases, roles) {
  const results = phases.filter(ph => ph.enabled).map(ph => {
    const roleDetails = (roles || []).map(r => ({
      ...r, hours: ph.hoursByRole?.[r.id] || 0,
    }));
    const totalHours = roleDetails.reduce((s, r) => s + r.hours, 0);
    const totalAmount = roleDetails.reduce((s, r) => s + r.hours * r.rate, 0);
    return { ...ph, roleDetails, totalHours, totalAmount };
  });
  return {
    phases: results,
    totalHours: results.reduce((s, p) => s + p.totalHours, 0),
    totalAmount: results.reduce((s, p) => s + p.totalAmount, 0),
  };
}

// Berechnet Budget aus linkedQuotes-Array (Migration von sourceQuoteId)
export function migrateLinkedQuotes(project) {
  if (project.linkedQuotes) return project.linkedQuotes;
  if (project.sourceQuoteId) return [{ quoteId: project.sourceQuoteId, role: "Hauptofferte" }];
  return [];
}

export function deriveQuoteBudget(linkedQuotes, allQuotes, settingsRoles) {
  const quotes = (linkedQuotes || []).map(lq => allQuotes.find(q => q.id === lq.quoteId)).filter(Boolean);
  let totalHours = 0;
  let totalAmount = 0;
  const phaseMap = {}; // phaseId -> hours (summed)
  const enabledSet = new Set(); // phases enabled in quotes even with 0 hours

  quotes.forEach(q => {
    const roles = q.quoteRoles || settingsRoles || [];
    if (q.mode === "sia") {
      const calc = calcSIAHours(q.sia?.baukosten, q.sia?.schwierigkeit, q.sia?.phases || []);
      totalHours += calc.total || 0;
      totalAmount += (calc.total || 0) * (q.sia?.stundenansatz || 0);
      (calc.phases || []).forEach(ph => {
        if (ph.hours > 0) phaseMap[ph.id] = (phaseMap[ph.id] || 0) + ph.hours;
      });
    } else if (q.mode === "manual") {
      const calc = calcManualHours(q.manualPhases || [], roles);
      totalHours += calc.totalHours || 0;
      totalAmount += calc.totalAmount || 0;
      (q.manualPhases || []).filter(ph => ph.enabled).forEach(ph => {
        enabledSet.add(ph.id);
        const h = roles.reduce((s, r) => s + (ph.hoursByRole?.[r.id] || 0), 0);
        if (h > 0) phaseMap[ph.id] = (phaseMap[ph.id] || 0) + h;
      });
    } else if (q.mode === "free") {
      totalAmount += (q.freeItems || []).reduce((s, it) => s + (it.qty * it.price), 0);
    }
  });

  const phasesBudget = Object.entries(phaseMap).map(([id, hours]) => ({ id, hours: Math.round(hours * 10) / 10 }));
  const enabledPhases = [...new Set([...phasesBudget.map(p => p.id), ...enabledSet])];
  return {
    budgetHours: Math.round(totalHours * 10) / 10,
    budgetAmount: Math.round(totalAmount),
    phasesBudget,
    enabledPhases,
    hasFreeQuotes: quotes.some(q => q.mode === "free"),
    hasHourQuotes: quotes.some(q => q.mode === "sia" || q.mode === "manual"),
  };
}

export function generateId() {
  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
    return crypto.randomUUID();
  }
  // Fallback for very old environments — uses crypto.getRandomValues if available
  if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
    const buf = new Uint8Array(8);
    crypto.getRandomValues(buf);
    return Date.now().toString(36) + "-" + Array.from(buf).map(b => b.toString(16).padStart(2, "0")).join("");
  }
  return Date.now().toString(36) + Math.random().toString(36).slice(2, 10);
}

// ─── PASSWORT-HASHING (PBKDF2 via Web Crypto) ──────────────────────────────
// Stored shape on user: { passwordHash, passwordSalt }  (both hex strings)
// Legacy users with plaintext { password } are accepted once and upgraded
// transparently after a successful login.
const PBKDF2_ITERATIONS = 100_000;
const PBKDF2_HASH = "SHA-256";
const PBKDF2_SALT_BYTES = 16;
const PBKDF2_KEY_BITS = 256;

function bytesToHex(bytes) {
  let s = "";
  for (const b of bytes) s += b.toString(16).padStart(2, "0");
  return s;
}
function hexToBytes(hex) {
  const out = new Uint8Array(hex.length / 2);
  for (let i = 0; i < out.length; i++) out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
  return out;
}
export async function hashPassword(password, saltHex) {
  const salt = saltHex
    ? hexToBytes(saltHex)
    : crypto.getRandomValues(new Uint8Array(PBKDF2_SALT_BYTES));
  const baseKey = await crypto.subtle.importKey(
    "raw", new TextEncoder().encode(password ?? ""), "PBKDF2", false, ["deriveBits"]
  );
  const bits = await crypto.subtle.deriveBits(
    { name: "PBKDF2", salt, iterations: PBKDF2_ITERATIONS, hash: PBKDF2_HASH },
    baseKey, PBKDF2_KEY_BITS
  );
  return { hash: bytesToHex(new Uint8Array(bits)), salt: bytesToHex(salt) };
}
// Constant-time string compare to avoid timing leaks
function constantTimeEq(a, b) {
  if (typeof a !== "string" || typeof b !== "string" || a.length !== b.length) return false;
  let r = 0;
  for (let i = 0; i < a.length; i++) r |= a.charCodeAt(i) ^ b.charCodeAt(i);
  return r === 0;
}
export async function verifyPassword(password, user) {
  if (!user) return false;
  if (user.passwordHash && user.passwordSalt) {
    const { hash } = await hashPassword(password, user.passwordSalt);
    return constantTimeEq(hash, user.passwordHash);
  }
  // Legacy plaintext fallback (transitional only)
  if (typeof user.password === "string") {
    return constantTimeEq(password ?? "", user.password);
  }
  return false;
}
// Returns a copy of user with hashed credentials (and the legacy plaintext field stripped).
export async function withHashedPassword(user, password) {
  const { hash, salt } = await hashPassword(password);
  // eslint-disable-next-line no-unused-vars
  const { password: _legacy, ...rest } = user;
  return { ...rest, passwordHash: hash, passwordSalt: salt };
}
// Strips all credential fields from a user-shaped object (for sessionStorage / props)
export function stripCredentials(user) {
  if (!user) return user;
  // eslint-disable-next-line no-unused-vars
  const { password, passwordHash, passwordSalt, ...safe } = user;
  return safe;
}

// HTML sanitizer for rich-text content (letter bodies, etc.).
// Allowlist of tags + attributes; strips script, event handlers, javascript: URLs.
const SAFE_TAGS = new Set([
  "P", "BR", "DIV", "SPAN", "B", "STRONG", "I", "EM", "U", "S", "STRIKE",
  "H1", "H2", "H3", "H4", "H5", "H6", "UL", "OL", "LI", "BLOCKQUOTE",
  "FONT", "A", "HR", "SUB", "SUP",
]);
const SAFE_ATTRS = new Set([
  "style", "color", "size", "face", "align", "href", "target", "rel",
]);
function isSafeUrl(url) {
  if (!url) return false;
  const v = String(url).trim().toLowerCase();
  // block javascript:, data:text/html, vbscript:, etc. — allow http(s), mailto, tel, relative
  return !/^(javascript|data|vbscript|file):/i.test(v);
}
export function sanitizeHtml(html) {
  if (typeof html !== "string" || html === "") return "";
  if (typeof DOMParser === "undefined") return ""; // SSR/safe fallback
  const doc = new DOMParser().parseFromString(`<div>${html}</div>`, "text/html");
  const root = doc.body.firstChild;
  if (!root) return "";
  const walk = (node) => {
    // Iterate over a snapshot — children may be removed during walk
    const kids = Array.from(node.childNodes);
    for (const child of kids) {
      if (child.nodeType === 1) {
        const tag = child.tagName;
        if (!SAFE_TAGS.has(tag)) {
          // Replace disallowed tag with its sanitized children (drops <script>, <iframe>, etc.)
          while (child.firstChild) node.insertBefore(child.firstChild, child);
          node.removeChild(child);
          continue;
        }
        // Strip disallowed attributes; sanitize hrefs
        for (const attr of Array.from(child.attributes)) {
          const name = attr.name.toLowerCase();
          if (name.startsWith("on") || !SAFE_ATTRS.has(name)) {
            child.removeAttribute(attr.name);
            continue;
          }
          if (name === "href" && !isSafeUrl(attr.value)) {
            child.removeAttribute(attr.name);
            continue;
          }
          if (name === "style" && /expression\s*\(|javascript:|url\s*\(\s*['"]?\s*javascript:/i.test(attr.value)) {
            child.removeAttribute(attr.name);
          }
        }
        if (tag === "A" && child.getAttribute("target") === "_blank" && !child.getAttribute("rel")) {
          child.setAttribute("rel", "noopener noreferrer");
        }
        walk(child);
      } else if (child.nodeType !== 3 && child.nodeType !== 8) {
        // Drop comments and other node types except text
        node.removeChild(child);
      }
    }
  };
  walk(root);
  return root.innerHTML;
}

export function formatCHF(amount) {
  return new Intl.NumberFormat("de-CH", { style: "currency", currency: "CHF" }).format(amount || 0);
}

export function formatDate(dateStr) {
  if (!dateStr) return "—";
  return new Date(dateStr).toLocaleDateString("de-CH");
}

// Schweizer 5-Rappen-Rundung
export function roundCHF(amount) {
  return Math.round((amount || 0) * 20) / 20;
}

// Absender-Adresse aus strukturierten Feldern bauen; Fallback auf altes Freitext-Feld
export function formatSenderAddress(settings) {
  const parts = [];
  if (settings.street) parts.push(settings.street);
  const line2 = [settings.zip, settings.city].filter(Boolean).join(" ");
  if (line2) parts.push(line2);
  if (parts.length > 0) return parts.join("\n");
  return settings.address || "";
}

// ─── QR-BILL HELPERS ──────────────────────────────────────────

// Prüft ob IBAN eine QR-IBAN ist (IID im Bereich 30000-31999)
export function isQRIban(iban) {
  const clean = (iban || "").replace(/\s/g, "").toUpperCase();
  if (!clean.startsWith("CH") && !clean.startsWith("LI")) return false;
  const iid = parseInt(clean.slice(4, 9));
  return iid >= 30000 && iid <= 31999;
}

// IBAN-Formatierung mit Leerzeichen alle 4 Stellen
export function formatIban(iban) {
  const clean = (iban || "").replace(/\s/g, "").toUpperCase();
  return clean.match(/.{1,4}/g)?.join(" ") || "";
}

// Modulo-10-Rekursiv Prüfziffer (für QR-Referenz)
export function mod10(input) {
  const table = [[0,9,4,6,8,2,7,1,3,5],[9,4,6,8,2,7,1,3,5,0],[4,6,8,2,7,1,3,5,0,9],[6,8,2,7,1,3,5,0,9,4],[8,2,7,1,3,5,0,9,4,6],[2,7,1,3,5,0,9,4,6,8],[7,1,3,5,0,9,4,6,8,2],[1,3,5,0,9,4,6,8,2,7],[3,5,0,9,4,6,8,2,7,1],[5,0,9,4,6,8,2,7,1,3]];
  let carry = 0;
  for (const ch of input) {
    const digit = parseInt(ch);
    if (isNaN(digit)) continue;
    carry = table[carry][digit];
  }
  return ((10 - carry) % 10).toString();
}

// Generiert 27-stellige QR-Referenz aus Rechnungsnummer
export function generateQRReference(invoiceNumber) {
  // Nur Ziffern extrahieren, links mit Nullen auf 26 Stellen auffüllen, dann Prüfziffer
  const digits = (invoiceNumber || "").replace(/\D/g, "").padStart(26, "0").slice(-26);
  return digits + mod10(digits);
}

// Formatiert Referenz in 5er-Blöcken von rechts
export function formatReference(ref) {
  const clean = (ref || "").replace(/\s/g, "");
  const reversed = clean.split("").reverse().join("");
  const blocks = reversed.match(/.{1,5}/g) || [];
  return blocks.map(b => b.split("").reverse().join("")).reverse().join(" ");
}

export function formatHours(minutes) {
  const h = Math.floor((minutes || 0) / 60);
  const m = (minutes || 0) % 60;
  return `${h}h${m > 0 ? " " + m + "m" : ""}`;
}

// Formatiert Projektnummer nach konfigurierbarem Format
// Platzhalter: YYYY=2025, YY=25, NN=01..99
export function applyProjectNumberFormat(fmt, seq) {
  const now = new Date();
  const yyyy = String(now.getFullYear());
  const yy = yyyy.slice(2);
  const nn = String(seq).padStart(2, "0");
  return (fmt || "YYYY/NN").replace(/YYYY/g, yyyy).replace(/YY/g, yy).replace(/NN/g, nn);
}

// Parst die laufende Nummer aus einer gespeicherten Projektnummer anhand des Formats
export function parseSeqFromNumber(num, fmt) {
  if (!num || !fmt) return null;
  const now = new Date();
  const yyyy = String(now.getFullYear());
  const yy = yyyy.slice(2);
  // Escape regex special chars, then replace placeholders with capture groups
  const pattern = (fmt || "YYYY/NN")
    .replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&")
    .replace(/YYYY/g, yyyy)
    .replace(/YY/g, yy)
    .replace(/NN/g, "(\\d+)");
  const match = num.match(new RegExp("^" + pattern + "$"));
  return match ? parseInt(match[1]) : null;
}

export function exportBuchhaltungCSV(data, year = "") {
  const sep = ";";
  const q = (s) => `"${String(s || "").replace(/"/g, '""')}"`;
  const mwstRate = data.settings.mwstRate || 8.1;
  const rows = [];

  // Einnahmen
  rows.push(["EINNAHMEN", "", "", "", "", "", "", ""].map(q).join(sep));
  rows.push(["Datum", "Rechnungs-Nr.", "Kunde", "Beschreibung", "Netto CHF", "MWST-Satz %", "MWST CHF", "Brutto CHF"].map(q).join(sep));
  const paidInvoices = [...data.invoices].filter(i => !year || (i.date || "").startsWith(year)).sort((a, b) => (a.date || "").localeCompare(b.date || ""));
  paidInvoices.forEach(inv => {
    const client = (data.persons||[]).find(c => c.id === inv.clientId);
    const desc = (inv.items || []).map(it => it.desc).filter(Boolean).join(", ");
    const taxRate = inv.mwst ? mwstRate : 0;
    rows.push([inv.date, inv.number, client?.name || "", desc, (inv.sub || 0).toFixed(2), taxRate, (inv.tax || 0).toFixed(2), (inv.total || 0).toFixed(2)].map(q).join(sep));
  });
  const totalNet = paidInvoices.reduce((s, i) => s + (i.sub || 0), 0);
  const totalTax = paidInvoices.reduce((s, i) => s + (i.tax || 0), 0);
  const totalGross = paidInvoices.reduce((s, i) => s + (i.total || 0), 0);
  rows.push(["", "", "", "TOTAL", totalNet.toFixed(2), "", totalTax.toFixed(2), totalGross.toFixed(2)].map(q).join(sep));
  rows.push([""].join(sep));

  // Ausgaben
  rows.push(["SPESEN (MITARBEITERBEZOGEN)", "", "", "", "", "", "", ""].map(q).join(sep));
  rows.push(["Datum", "Kategorie", "Projekt", "Beschreibung", "Netto CHF", "MWST-Satz %", "MWST CHF", "Brutto CHF"].map(q).join(sep));
  const sortedExp = [...(data.expenses || [])].filter(e => !year || (e.date || "").startsWith(year)).sort((a, b) => (a.date || "").localeCompare(b.date || ""));
  sortedExp.forEach(exp => {
    const proj = data.projects.find(p => p.id === exp.projectId);
    const net = exp.inclMwst ? (exp.amount / (1 + (exp.mwstRate || 0) / 100)) : exp.amount;
    const taxAmt = exp.amount - net;
    rows.push([exp.date, exp.category, proj?.name || "", exp.description, net.toFixed(2), exp.mwstRate || 0, taxAmt.toFixed(2), exp.amount.toFixed(2)].map(q).join(sep));
  });
  const expTotal = sortedExp.reduce((s, e) => s + (e.amount || 0), 0);
  const expTax = sortedExp.reduce((s, e) => { const net = e.inclMwst ? (e.amount / (1 + (e.mwstRate || 0) / 100)) : e.amount; return s + (e.amount - net); }, 0);
  rows.push(["", "", "", "TOTAL", (expTotal - expTax).toFixed(2), "", expTax.toFixed(2), expTotal.toFixed(2)].map(q).join(sep));
  rows.push([""].join(sep));

  // Interne Ausgaben
  rows.push(["INTERNE AUSGABEN", "", "", "", "", "", "", ""].map(q).join(sep));
  rows.push(["Datum", "Kategorie", "Beschreibung", "Wiederkehrend", "Netto CHF", "MWST-Satz %", "MWST CHF", "Brutto CHF"].map(q).join(sep));
  const sortedIntExp = [...(data.internalExpenses || [])].filter(e => !year || (e.date || "").startsWith(year)).sort((a, b) => (a.date || "").localeCompare(b.date || ""));
  sortedIntExp.forEach(exp => {
    const net = exp.inclMwst ? (exp.amount / (1 + (exp.mwstRate || 0) / 100)) : exp.amount;
    const taxAmt = exp.amount - net;
    rows.push([exp.date, exp.category, exp.description, exp.recurring ? (exp.recurringInterval || "monatlich") : "", net.toFixed(2), exp.mwstRate || 0, taxAmt.toFixed(2), exp.amount.toFixed(2)].map(q).join(sep));
  });
  const intExpTotal = sortedIntExp.reduce((s, e) => s + (e.amount || 0), 0);
  const intExpTax = sortedIntExp.reduce((s, e) => { const net = e.inclMwst ? (e.amount / (1 + (e.mwstRate || 0) / 100)) : e.amount; return s + (e.amount - net); }, 0);
  rows.push(["", "", "", "TOTAL", (intExpTotal - intExpTax).toFixed(2), "", intExpTax.toFixed(2), intExpTotal.toFixed(2)].map(q).join(sep));
  rows.push([""].join(sep));

  // Personalaufwand (Löhne)
  const sortedLoehne = [...(data.lohnEntries || [])].filter(l => !year || l.monat.startsWith(year)).sort((a, b) => a.monat.localeCompare(b.monat));
  if (sortedLoehne.length > 0) {
    rows.push(["PERSONALAUFWAND / LÖHNE", "", "", "", "", "", "", "", ""].map(q).join(sep));
    rows.push(["Monat", "Mitarbeiter", "Brutto", "Abzüge AN", "Netto", "Spesen", "Auszahlung AN", "PK AG-Anteil", "Gesamtlohnkosten"].map(q).join(sep));
    sortedLoehne.forEach(l => {
      const name = l.empSnapshot?.name || "";
      const bvgAG = l.bvgAG || 0;
      const gesamt = (l.auszahlung || 0) + bvgAG;
      rows.push([l.monat, name, (l.bruttoTotal || 0).toFixed(2), (l.totalAbzuege || 0).toFixed(2), (l.netto || 0).toFixed(2), (l.spesenTotal || 0).toFixed(2), (l.auszahlung || 0).toFixed(2), bvgAG.toFixed(2), gesamt.toFixed(2)].map(q).join(sep));
    });
    const lohnTotal = sortedLoehne.reduce((s, l) => s + (l.auszahlung || 0) + (l.bvgAG || 0), 0);
    rows.push(["", "", "", "", "", "", "", "TOTAL", lohnTotal.toFixed(2)].map(q).join(sep));
    rows.push([""].join(sep));
  }

  // Zusammenfassung
  const lohnTotalAll = sortedLoehne.reduce((s, l) => s + (l.auszahlung || 0) + (l.bvgAG || 0), 0);
  rows.push(["ZUSAMMENFASSUNG", "", "", "", "", "", "", ""].map(q).join(sep));
  rows.push(["", "", "", "Einnahmen (Netto)", totalNet.toFixed(2), "", "", ""].map(q).join(sep));
  rows.push(["", "", "", "Spesen (Netto)", (expTotal - expTax).toFixed(2), "", "", ""].map(q).join(sep));
  rows.push(["", "", "", "Interne Ausgaben (Netto)", (intExpTotal - intExpTax).toFixed(2), "", "", ""].map(q).join(sep));
  rows.push(["", "", "", "Personalaufwand (Löhne)", lohnTotalAll.toFixed(2), "", "", ""].map(q).join(sep));
  rows.push(["", "", "", "Ergebnis (Netto)", (totalNet - (expTotal - expTax) - (intExpTotal - intExpTax) - lohnTotalAll).toFixed(2), "", "", ""].map(q).join(sep));
  rows.push(["", "", "", "MWST auf Einnahmen", "", "", totalTax.toFixed(2), ""].map(q).join(sep));
  rows.push(["", "", "", "Vorsteuer (Spesen + Ausgaben)", "", "", (expTax + intExpTax).toFixed(2), ""].map(q).join(sep));
  rows.push(["", "", "", "MWST-Schuld", "", "", (totalTax - expTax - intExpTax).toFixed(2), ""].map(q).join(sep));

  const bom = "";
  const blob = new Blob([bom + rows.join("\n")], { type: "text/csv;charset=utf-8;" });
  const url = URL.createObjectURL(blob);
  const a = document.createElement("a");
  a.href = url;
  a.download = `buchhaltung-${year || "gesamt"}.csv`;
  a.click();
  URL.revokeObjectURL(url);
}

export function buildReminderLetter(inv, nr, sentDate, clients, settings) {
  const client = clients.find(c => c.id === inv.clientId);
  const existingReminders = inv.reminders || [];
  const daysPast = Math.floor((new Date() - new Date(inv.dueDate)) / 86400000);
  const intro = nr === 1
    ? `Bei einer Überprüfung unserer Buchhaltung stellen wir fest, dass die Rechnung Nr. ${inv.number} vom ${formatDate(inv.date)} über ${formatCHF(inv.total)} seit ${daysPast} Tagen (Fälligkeit: ${formatDate(inv.dueDate)}) noch nicht beglichen ist.\n\nWir bitten Sie höflich, den offenen Betrag innert 10 Tagen zu überweisen.`
    : nr === 2
    ? `Leider mussten wir feststellen, dass unsere Zahlungserinnerung vom ${formatDate(existingReminders[0]?.sentDate || existingReminders[0]?.date)} bezüglich Rechnung Nr. ${inv.number} über ${formatCHF(inv.total)} bisher ohne Reaktion geblieben ist.\n\nWir fordern Sie hiermit auf, den ausstehenden Betrag innert 7 Tagen zu begleichen.`
    : `Trotz unserer Zahlungserinnerungen vom ${existingReminders.map(r => formatDate(r.sentDate || r.date)).join(" und ")} ist die Rechnung Nr. ${inv.number} über ${formatCHF(inv.total)} nach wie vor unbeglichen.\n\nWir sehen uns gezwungen, bei weiterem Ausbleiben der Zahlung innerhalb von 5 Tagen rechtliche Schritte einzuleiten.`;
  const body = `Sehr geehrte/r ${client?.name || "[Kunde]"}\n\n${intro}\n\nIBAN: ${settings.iban}\nReferenz: ${inv.number}\n\nFreundliche Grüsse\n${settings.name}`;
  const subject = nr === 1 ? `Zahlungserinnerung – Rechnung Nr. ${inv.number}` : `${nr}. Mahnung – Rechnung Nr. ${inv.number}`;
  return { client, subject, body };
}

export function getKW(dateStr) {
  if (!dateStr) return "—";
  const d = new Date(dateStr);
  const jan4 = new Date(d.getFullYear(), 0, 4);
  const startOfWeek = new Date(jan4);
  startOfWeek.setDate(jan4.getDate() - ((jan4.getDay() + 6) % 7));
  const kw = Math.ceil(((d - startOfWeek) / 86400000 + 1) / 7);
  return `KW ${kw}`;
}

export function linkedClientForNote(n, data) {
  if (n.clientId) return (data.persons||[]).find(c => c.id === n.clientId) || null;
  return n.clientManual ? { name: n.clientManual, address: n.deliveryAddress || "" } : null;
}

export function getWeekNumber(date) {
  const d = new Date(date);
  d.setHours(0, 0, 0, 0);
  d.setDate(d.getDate() + 3 - ((d.getDay() + 6) % 7));
  const week1 = new Date(d.getFullYear(), 0, 4);
  return Math.round(((d - week1) / 86400000 + ((week1.getDay() + 6) % 7) - 2) / 7) + 1;
}

export function formatKW(dateStr) {
  if (!dateStr) return "—";
  return `KW ${getWeekNumber(dateStr)} / ${new Date(dateStr).getFullYear()}`;
}

// Generiert nächste Protokollnummer (legacy, nicht mehr direkt genutzt)
export function nextProtoNumber(protocols, projectNumber) {
  const prefix = projectNumber ? `${projectNumber}-P` : "P";
  const existing = (protocols || []).map(p => {
    const m = (p.nummer || p.number || "").match(/(\d+)$/);
    return m ? parseInt(m[1]) : 0;
  });
  const max = existing.length ? Math.max(...existing) : 0;
  return `${prefix}${String(max + 1).padStart(2, "0")}`;
}

// Nächste Sequenznummer aus bestehenden Protokollnummern ableiten
// Ignoriert Jahr-artige Zahlen (4-stellig, 2000–2099)
export function nextProtoSeq(protocols) {
  let max = 0;
  (protocols || []).forEach(p => {
    const groups = (p.nummer || "").match(/\d+/g) || [];
    groups.forEach(n => {
      const num = parseInt(n);
      if (n.length <= 3 || !(num >= 2000 && num <= 2099)) {
        if (num > max) max = num;
      }
    });
  });
  return max + 1;
}

// Wendet konfigurierbares Protokollnummer-Format an
// Platzhalter: YYYY YY MM DD PP(Projektnr.) TT(Typkürzel) NN/NNN(Sequenz)
export function applyProtoNumberFormat(fmt, { date, projectNumber, seq, typKuerzel }) {
  const d = date ? new Date(date + "T12:00:00") : new Date();
  const yyyy = String(d.getFullYear());
  const yy = yyyy.slice(2);
  const mm = String(d.getMonth() + 1).padStart(2, "0");
  const dd = String(d.getDate()).padStart(2, "0");
  // Normalize separators in project number, then strip a leading year segment
  // so PP can be combined with YYYY/YY without producing a double year.
  const ppNorm = (projectNumber || "")
    .replace(/[\/\s.]/g, "-")
    .replace(/-+/g, "-")
    .replace(/^-|-$/g, "");
  const pp4 = ppNorm.replace(/^\d{4}-/, "");
  const pp2 = ppNorm.replace(/^\d{2}-/, "");
  const ppStripped = pp4 !== ppNorm ? pp4 : pp2 !== ppNorm ? pp2 : ppNorm;
  const pp = ppStripped || ppNorm || "P";
  const tt = typKuerzel || "SO";
  const tokens = {
    YYYY: yyyy, YY: yy, MM: mm, DD: dd,
    PPP: ppNorm || "P", PP: pp, TT: tt,
    NNN: String(seq).padStart(3, "0"),
    NN: String(seq).padStart(2, "0"),
  };
  return (fmt || "PP-TT-NN").replace(/YYYY|YY|NNN|NN|MM|DD|PPP|PP|TT/g, m => tokens[m] ?? m);
}

// Convert plain text (legacy templates) to HTML
export function textToHtml(text) {
  if (!text) return "";
  if (text.trim().startsWith("<")) return text; // already HTML
  return text
    .split("\n\n")
    .map(para => `<p>${para.replace(/\n/g, "<br>")}</p>`)
    .join("");
}

// Convert HTML back to plain text for print (fallback)
export function htmlToText(html) {
  const div = document.createElement("div");
  div.innerHTML = html;
  return div.innerText || div.textContent || "";
}

export function getFeiertageForYear(feiertage, year) {
  return (feiertage || []).filter(f => {
    if (f.repeatsYearly) return true;
    return f.date.startsWith(String(year));
  }).map(f => {
    if (f.repeatsYearly) return { ...f, date: `${year}-${f.date.slice(5, 10)}` };
    return f;
  });
}

export function getAbsenzTypes(data) {
  const custom = data.absenzTypes || [];
  const overrideMap = new Map(custom.map(t => [t.id, t]));
  const defaultIds = new Set(DEFAULT_ABSENZ_TYPES.map(t => t.id));
  const defaults = DEFAULT_ABSENZ_TYPES
    .map(t => overrideMap.get(t.id) || t)
    .filter(t => !overrideMap.get(t.id)?.deleted);
  const newCustom = custom.filter(t => !defaultIds.has(t.id) && !t.deleted);
  return [...defaults, ...newCustom];
}

export function getWorkdaysInMonth(year, month, feiertage) {
  // month: 0-based; use ISO string to avoid local-midnight timezone offset
  const days = [];
  const monthStr = `${year}-${String(month + 1).padStart(2, "0")}`;
  const d = new Date(`${monthStr}-01`);
  while (d.toISOString().slice(0, 7) === monthStr) {
    const ds = d.toISOString().slice(0, 10);
    const dow = d.getDay();
    if (dow !== 0 && dow !== 6) {
      const ft = (feiertage || []).find(f => f.date === ds);
      days.push({ date: ds, feiertag: ft || null });
    }
    d.setDate(d.getDate() + 1);
  }
  return days;
}

export function getSollStunden(employee, date, feiertage) {
  // Returns Soll-Stunden for a given workday
  const pensum = (employee.pensum || 100) / 100;
  const wochenstunden = (employee.wochenstunden || 35);
  const tagessoll = (wochenstunden * pensum) / 5;
  const ft = (feiertage || []).find(f => f.date === date);
  if (ft) return tagessoll + (ft.stundenDelta || 0); // e.g. -1 for Halbfeiertag, 0 for full
  return tagessoll;
}

// ─── LOHNBERECHNUNG HELPER ──────────────────────────────────────
export function calcLohn(emp, monat, spesen, bonus) {
  const pensumFactor = (emp.pensum || 100) / 100;
  const bruttoBase = emp.monatslohn || 0;
  const brutto = Math.round(bruttoBase * pensumFactor * 100) / 100;
  // 13. Monatslohn: 1/12 pro Monat
  const dreizehnter = emp.dreizehnterLohn ? Math.round(brutto / 12 * 100) / 100 : 0;
  const bonusBetrag = Math.round((bonus || 0) * 100) / 100;
  const bruttoTotal = brutto + dreizehnter + bonusBetrag; // Bonus ist AHV-pflichtig

  const ahv    = Math.round(bruttoTotal * ((emp.ahvSatz  ?? 5.3)  / 100) * 100) / 100;
  const alv    = Math.round(bruttoTotal * ((emp.alvSatz  ?? 1.1)  / 100) * 100) / 100;
  const bvg    = Math.round(bruttoTotal * ((emp.bvgSatz  ?? 8.0)  / 100) * 100) / 100;
  const nbu    = Math.round(bruttoTotal * ((emp.nbuSatz  ?? 1.5)  / 100) * 100) / 100;
  const ktg    = Math.round(bruttoTotal * ((emp.ktgSatz  ?? 0.5)  / 100) * 100) / 100;
  const qst    = emp.quellensteuerPflichtig
    ? Math.round(bruttoTotal * ((emp.quellensteuerSatz ?? 10) / 100) * 100) / 100 : 0;
  const bvgAG  = Math.round(bruttoTotal * ((emp.pkAGSatz ?? 8.0)  / 100) * 100) / 100;

  const totalAbzuege = ahv + alv + bvg + nbu + ktg + qst;
  const netto = Math.round((bruttoTotal - totalAbzuege) * 100) / 100;
  const spesenTotal = Math.round((spesen || []).reduce((s, e) => s + (e.amount || 0), 0) * 100) / 100;
  const auszahlung = Math.round((netto + spesenTotal) * 100) / 100;

  return { brutto, bruttoBase, dreizehnter, bonusBetrag, bruttoTotal, ahv, alv, bvg, nbu, ktg, qst, totalAbzuege, netto, spesenTotal, auszahlung, bvgAG };
}

// ─── Dashboard layout helpers ──────────────────────────────────────────────────

const KPI_IDS = ["kpi-projekte","kpi-stunden","kpi-ausstehend","kpi-umsatz"];
const MID_IDS = ["aktive-projekte","unverrechnete-stunden","umsatz-sparkline","offene-offerten"];
const FULL_IDS = ["warnungen","letzte-zeiteintraege","meine-zeiteintraege"];

export function widgetsToRows(widgetIds) {
  const uid = () => generateId().replace(/-/g, "").slice(0, 8);
  const kpi  = widgetIds.filter(w => KPI_IDS.includes(w));
  const mid  = widgetIds.filter(w => MID_IDS.includes(w));
  const full = widgetIds.filter(w => FULL_IDS.includes(w));
  const rows = [];
  if (kpi.length)  rows.push({ id: uid(), cols: Math.min(4, Math.max(2, kpi.length)), minH: 0, widgets: kpi });
  for (let i = 0; i < mid.length; i += 3) {
    const chunk = mid.slice(i, i + 3);
    rows.push({ id: uid(), cols: Math.max(2, chunk.length), minH: 0, widgets: chunk });
  }
  full.forEach(w => rows.push({ id: uid(), cols: 1, minH: 0, widgets: [w] }));
  return rows;
}

export function migrateDashboardLayout(val) {
  if (!val || !Array.isArray(val) || val.length === 0) return null;
  if (typeof val[0] === "object" && "widgets" in val[0]) return val;
  return widgetsToRows(val);
}

// PDF-Dateiname aus Format und Content ableiten
export function buildPdfName(format, content, settings) {
  const studio = (settings?.name || "RAPPORT").replace(/\s+/g, "-");
  const typeLabels = {
    "invoice": "Rechnung", "invoice+qr": "Rechnung", "qrbill": "QR-Rechnung",
    "quote": "Offerte", "lieferschein": "Lieferschein", "protokoll": "Protokoll",
    "lohn": "Lohnabrechnung", "letter": "Brief", "projectDetail": "Projekt",
    "projectsOverview": "Projekte", "buchhaltung": "Buchhaltung", "studioBudget": "Budget",
  };
  const typ = typeLabels[content?.type] || content?.type || "Dokument";
  let nummer = "";
  let kunde = "";
  let datum = new Date().toISOString().slice(0, 10);
  if (content?.inv) {
    nummer = content.inv.number || "";
    datum = content.inv.date || datum;
    kunde = content.client?.company || content.client?.name || "";
  } else if (content?.quote) {
    nummer = content.quote.number || "";
    datum = content.quote.date || datum;
    kunde = content.client?.company || content.client?.name || "";
  } else if (content?.note) {
    nummer = content.note.number || "";
    kunde = content.client?.company || content.client?.name || "";
  } else if (content?.protokoll) {
    datum = content.protokoll.date || datum;
    nummer = content.protokoll.number || "";
  } else if (content?.emp) {
    kunde = content.emp.name || "";
    nummer = content.monatLabel || "";
  } else if (content?.filterYear) {
    nummer = String(content.filterYear);
  }
  const sanitize = (s) => (s || "").replace(/[^a-zA-Z0-9äöüÄÖÜ_\-\.]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
  const fmt = format || "{studio}_{typ}_{nummer}";
  const result = fmt
    .replace("{studio}", sanitize(studio))
    .replace("{typ}", sanitize(typ))
    .replace("{nummer}", sanitize(nummer))
    .replace("{kunde}", sanitize(kunde))
    .replace("{datum}", sanitize(datum));
  return result.replace(/-+/g, "-").replace(/^-|-$/g, "") || "RAPPORT";
}