Fullstack Engineer

{
  "projects": {
    "default": "fatura-saas-maroc"
  },
  "targets": {},
  "etags": {}
}

# Logs
logs
*.log
npm-debug.log*
yarn-debug.log*
yarn-error.log*
pnpm-debug.log*
lerna-debug.log*

node_modules
dist
dist-ssr
*.local

# Editor directories and files
.vscode/*
!.vscode/extensions.json
.idea
.DS_Store
*.suo
*.ntvs*
*.njsproj
*.sln
*.sw?
.env
.env.*
*.docx

# Firebase Functions
functions/lib/
functions/node_modules/

# Compiled Types
src/types/*.js
src/types/*.js.map

import js from '@eslint/js'
import globals from 'globals'
import reactHooks from 'eslint-plugin-react-hooks'
import reactRefresh from 'eslint-plugin-react-refresh'
import tseslint from 'typescript-eslint'
import { defineConfig, globalIgnores } from 'eslint/config'

export default defineConfig([
  globalIgnores(['dist']),
  {
    files: ['**/*.{ts,tsx}'],
    extends: [
      js.configs.recommended,
      tseslint.configs.recommended,
      reactHooks.configs.flat.recommended,
      reactRefresh.configs.vite,
    ],
    languageOptions: {
      ecmaVersion: 2020,
      globals: globals.browser,
    },
  },
])

{
  "functions": {
    "source": "functions",
    "runtime": "nodejs20",
    "codebase": "default"
  },
  "firestore": {
    "database": "(default)",
    "location": "eur3",
    "rules": "firestore.rules",
    "indexes": "firestore.indexes.json"
  },
  "storage": {
    "rules": "storage.rules"
  },
  "hosting": {
    "public": "dist",
    "ignore": [
      "firebase.json",
      "**/.*",
      "**/node_modules/**"
    ],
    "rewrites": [
      {
        "source": "**",
        "destination": "/index.html"
      }
    ]
  },
  "auth": {
    "providers": {
      "anonymous": false,
      "emailPassword": false
    }
  }
}

{
  "indexes": [
    {
      "collectionGroup": "whatsappSessions",
      "queryScope": "COLLECTION",
      "fields": [
        { "fieldPath": "businessId", "order": "ASCENDING" },
        { "fieldPath": "state", "order": "ASCENDING" },
        { "fieldPath": "expiresAt", "order": "ASCENDING" }
      ]
    },
    {
      "collectionGroup": "whatsappSessions",
      "queryScope": "COLLECTION",
      "fields": [
        { "fieldPath": "businessId", "order": "ASCENDING" },
        { "fieldPath": "waId", "order": "ASCENDING" },
        { "fieldPath": "state", "order": "ASCENDING" }
      ]
    },
    {
      "collectionGroup": "whatsappSessions",
      "queryScope": "COLLECTION",
      "fields": [
        { "fieldPath": "waId", "order": "ASCENDING" },
        { "fieldPath": "createdAt", "order": "DESCENDING" }
      ]
    }
  ],
  "fieldOverrides": []
}

rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    match /whatsappLinks/{waId} {
      allow read, update, delete: if request.auth != null && request.auth.uid == resource.data.ownerId;
      allow create: if request.auth != null && request.auth.uid == request.resource.data.ownerId;
    }
    
    match /{document=**} {
      allow read, write: if request.auth != null;
    }
  }
}

{
  "name": "fatura-functions",
  "private": true,
  "scripts": {
    "build": "tsc",
    "build:watch": "tsc --watch",
    "serve": "npm run build && firebase emulators:start --only functions",
    "shell": "npm run build && firebase functions:shell",
    "start": "npm run shell",
    "deploy": "firebase deploy --only functions",
    "logs": "firebase functions:log"
  },
  "engines": {
    "node": "20"
  },
  "main": "lib/functions/src/index.js",
  "dependencies": {
    "@google/generative-ai": "^0.24.1",
    "firebase-admin": "^12.0.0",
    "firebase-functions": "^5.0.0",
    "pdfkit": "^0.15.0",
    "twilio": "^6.0.0"
  },
  "devDependencies": {
    "@types/jest": "^30.0.0",
    "@types/pdfkit": "^0.13.4",
    "jest": "^30.3.0",
    "ts-jest": "^29.4.9",
    "typescript": "^5.4.0"
  }
}

/**
 * Fatura — Firebase Cloud Functions
 *
 * All money values are in centimes (integer). 1 MAD = 100 centimes.
 * Region: europe-west1
 *
 * Functions:
 *   1. onInvoiceCreated — Firestore trigger: auto-generate PDF + log
 *   2. onInvoiceStatusChanged — Firestore trigger: handle status transitions
 *   3. sendInvoiceReminder — callable: WhatsApp deep-link builder
 *   4. generateTVAReport — callable: SIMPL-TVA quarter report
 *   5. validateICE — callable: ICE format validator
 *   6. scheduledOverdueCheck — scheduled daily 8am Africa/Casablanca
 */

import * as functions from "firebase-functions";
import * as admin from "firebase-admin";
import PDFDocument from "pdfkit";

admin.initializeApp();

const db = admin.firestore();
const bucket = admin.storage().bucket();

const REGION = "europe-west1";
const fn = functions.region(REGION);

// =============================================================================
// HELPERS
// =============================================================================

/** Convert centimes integer to MAD display string */
function centimesToMAD(centimes: number): string {
  const val = centimes / 100;
  return val.toLocaleString("fr-MA", {minimumFractionDigits: 2, maximumFractionDigits: 2}) + " MAD";
}

/** Format Firestore Timestamp or epoch to YYYY-MM-DD */
function formatDate(ts: admin.firestore.Timestamp | {_seconds: number}): string {
  const d = ts instanceof admin.firestore.Timestamp
    ? ts.toDate()
    : new Date((ts as any)._seconds * 1000);
  return d.toISOString().slice(0, 10);
}

/** Log an activity entry */
export async function logActivity(
  businessId: string,
  userId: string,
  action: string,
  entityType: string,
  entityId: string,
  details: Record<string, unknown> = {}
): Promise<void> {
  await db
    .collection("businesses").doc(businessId)
    .collection("activity").add({
      businessId,
      userId: userId || "system",
      action,
      entityType,
      entityId,
      details,
      timestamp: admin.firestore.FieldValue.serverTimestamp(),
    });
}

// =============================================================================
// 1. onInvoiceCreated — Generate PDF on invoice creation
// =============================================================================

export const onInvoiceCreated = fn.firestore
  .document("businesses/{businessId}/invoices/{invoiceId}")
  .onCreate(async (snap, context) => {
    const {businessId, invoiceId} = context.params;
    const invoice = snap.data();
    if (!invoice) return;

    try {
      // Fetch business data for PDF header
      const businessDoc = await db.collection("businesses").doc(businessId).get();
      const business = businessDoc.data();
      if (!business) {
        functions.logger.error("Business not found", {businessId});
        return;
      }

      // Fetch client data
      const clientDoc = await db
        .collection("businesses").doc(businessId)
        .collection("clients").doc(invoice.clientId)
        .get();
      const client = clientDoc.data();

      // -----------------------------------------------------------------------
      // Generate PDF with PDFKit
      // -----------------------------------------------------------------------
      const pdfBuffer = await generateInvoicePDF(invoice, business, client, invoiceId);

      // Upload to Storage
      const filePath = `invoices/${businessId}/${invoiceId}.pdf`;
      const file = bucket.file(filePath);
      await file.save(pdfBuffer, {
        metadata: {
          contentType: "application/pdf",
          metadata: {
            invoiceNumber: invoice.number || invoiceId,
            businessId,
          },
        },
      });

      // Make file publicly accessible (or use signed URL)
      await file.makePublic();
      const pdfUrl = `https://storage.googleapis.com/${bucket.name}/${filePath}`;

      // Update invoice with PDF URL
      await snap.ref.update({pdfUrl, updatedAt: admin.firestore.FieldValue.serverTimestamp()});

      // Log activity
      await logActivity(
        businessId,
        invoice.createdBy || business.ownerId || "system",
        "Facture créée",
        "invoice",
        invoiceId,
        {number: invoice.number, totalTTC: invoice.totals?.totalTTC}
      );

      functions.logger.info("Invoice PDF generated", {businessId, invoiceId, filePath});
    } catch (err) {
      functions.logger.error("onInvoiceCreated failed", {businessId, invoiceId, error: err});
    }
  });

/**
 * Generate a professional invoice PDF using PDFKit.
 */
async function generateInvoicePDF(
  invoice: FirebaseFirestore.DocumentData,
  business: FirebaseFirestore.DocumentData,
  client: FirebaseFirestore.DocumentData | undefined,
  invoiceId: string
): Promise<Buffer> {
  return new Promise((resolve, reject) => {
    const doc = new PDFDocument({size: "A4", margin: 50, bufferPages: true});
    const chunks: Buffer[] = [];

    doc.on("data", (chunk: Buffer) => chunks.push(chunk));
    doc.on("end", () => resolve(Buffer.concat(chunks)));
    doc.on("error", reject);

    const brandColor = business.brandColor || "#1B4965";

    // --- Header bar ---
    doc.rect(0, 0, 595.28, 8).fill(brandColor);

    // --- Business Info (top-left) ---
    doc.fontSize(14).fillColor(brandColor).text(business.legalName || "Entreprise", 50, 30);
    doc.fontSize(8).fillColor("#666666");
    if (business.tradeName) doc.text(business.tradeName);
    if (business.address) {
      doc.text(`${business.address.street || ""}, ${business.address.postalCode || ""} ${business.address.city || ""}`);
    }
    if (business.phone) doc.text(`Tél: ${business.phone}`);
    if (business.email) doc.text(`Email: ${business.email}`);
    doc.moveDown(0.3);
    doc.fontSize(7).fillColor("#999999");
    if (business.ice) doc.text(`ICE: ${business.ice}`);
    if (business.identifiantFiscal) doc.text(`IF: ${business.identifiantFiscal}`);
    if (business.registreCommerce) doc.text(`RC: ${business.registreCommerce}`);

    // --- Invoice Title (top-right) ---
    const typeLabel = getInvoiceTypeLabel(invoice.type);
    doc.fontSize(20).fillColor(brandColor).text(typeLabel, 350, 30, {width: 200, align: "right"});
    doc.fontSize(10).fillColor("#333333").text(invoice.number || invoiceId, 350, 55, {width: 200, align: "right"});

    // --- Date block ---
    doc.fontSize(9).fillColor("#666666");
    doc.text(`Date d'émission: ${formatDate(invoice.issueDate)}`, 350, 75, {width: 200, align: "right"});
    if (invoice.dueDate) {
      doc.text(`Date d'échéance: ${formatDate(invoice.dueDate)}`, 350, 88, {width: 200, align: "right"});
    }

    // --- Client block ---
    const clientY = 140;
    doc.roundedRect(350, clientY, 200, 80, 4).fill("#f8fafc").stroke();
    doc.fontSize(7).fillColor("#999999").text("FACTURER À", 360, clientY + 8);
    doc.fontSize(10).fillColor("#333333").text(client?.name || "Client", 360, clientY + 22, {width: 180});
    doc.fontSize(8).fillColor("#666666");
    if (client?.address) {
      doc.text(`${client.address.street || ""}, ${client.address.postalCode || ""} ${client.address.city || ""}`, 360, clientY + 38, {width: 180});
    }
    if (client?.ice) doc.text(`ICE: ${client.ice}`, 360, clientY + 55, {width: 180});
    if (client?.phone) doc.text(`Tél: ${client.phone}`, 360, clientY + 65, {width: 180});

    // --- Line items table ---
    const tableTop = 250;
    const cols = {desc: 50, qty: 310, unit: 360, tva: 420, total: 480};

    // Table header
    doc.rect(50, tableTop, 495.28, 22).fill(brandColor);
    doc.fontSize(8).fillColor("#ffffff");
    doc.text("Description", cols.desc + 8, tableTop + 7);
    doc.text("Qté", cols.qty, tableTop + 7, {width: 40, align: "center"});
    doc.text("P.U. HT", cols.unit, tableTop + 7, {width: 50, align: "right"});
    doc.text("TVA", cols.tva, tableTop + 7, {width: 40, align: "center"});
    doc.text("Total HT", cols.total, tableTop + 7, {width: 60, align: "right"});

    // Table rows
    let y = tableTop + 28;
    const lines: any[] = invoice.lines || [];
    lines.forEach((line: any, i: number) => {
      const bg = i % 2 === 0 ? "#ffffff" : "#f8fafc";
      doc.rect(50, y - 4, 495.28, 20).fill(bg);
      doc.fontSize(8).fillColor("#333333");
      doc.text(line.description || "", cols.desc + 8, y, {width: 250});
      doc.text(String(line.quantity || 0), cols.qty, y, {width: 40, align: "center"});
      doc.text(centimesToMAD(line.unitPrice || 0), cols.unit, y, {width: 50, align: "right"});
      doc.text(`${line.tvaRate || 0}%`, cols.tva, y, {width: 40, align: "center"});
      doc.text(centimesToMAD(line.totalHT || 0), cols.total, y, {width: 60, align: "right"});
      y += 20;
    });

    // Divider
    y += 10;
    doc.moveTo(350, y).lineTo(545, y).strokeColor("#e2e8f0").stroke();
    y += 8;

    // --- Totals ---
    const totals = invoice.totals || {};
    doc.fontSize(9).fillColor("#666666");
    doc.text("Total HT", 360, y, {width: 100});
    doc.text(centimesToMAD(totals.totalHT || 0), 460, y, {width: 80, align: "right"});
    y += 16;

    // TVA breakdown
    const tvaBreakdown: any[] = totals.tvaBreakdown || [];
    tvaBreakdown.forEach((t: any) => {
      doc.text(`TVA ${t.rate}%`, 360, y, {width: 100});
      doc.text(centimesToMAD(t.amount || 0), 460, y, {width: 80, align: "right"});
      y += 14;
    });

    y += 4;
    doc.rect(350, y, 195, 24).fill(brandColor);
    doc.fontSize(11).fillColor("#ffffff");
    doc.text("Total TTC", 360, y + 6, {width: 100});
    doc.text(centimesToMAD(totals.totalTTC || 0), 460, y + 6, {width: 80, align: "right"});

    // --- Notes ---
    if (invoice.notes) {
      const notesY = Math.max(y + 50, 550);
      doc.fontSize(8).fillColor("#999999").text("Notes:", 50, notesY);
      doc.fontSize(8).fillColor("#666666").text(invoice.notes, 50, notesY + 12, {width: 300});
    }

    // --- Bank details (footer) ---
    if (business.bankDetails) {
      const bk = business.bankDetails;
      const bankY = 720;
      doc.fontSize(7).fillColor("#999999");
      doc.text("Coordonnées Bancaires", 50, bankY);
      doc.fontSize(7).fillColor("#666666");
      if (bk.bankName) doc.text(`Banque: ${bk.bankName}`, 50, bankY + 10);
      if (bk.rib) doc.text(`RIB: ${bk.rib}`, 50, bankY + 20);
      if (bk.iban) doc.text(`IBAN: ${bk.iban}`, 250, bankY + 10);
      if (bk.swift) doc.text(`SWIFT: ${bk.swift}`, 250, bankY + 20);
    }

    // --- Footer bar ---
    doc.rect(0, 841.89 - 8, 595.28, 8).fill(brandColor);

    doc.end();
  });
}

function getInvoiceTypeLabel(type: string): string {
  const map: Record<string, string> = {
    facture: "FACTURE",
    avoir: "AVOIR",
    proforma: "FACTURE PROFORMA",
    devis: "DEVIS",
  };
  return map[type] || "FACTURE";
}

// =============================================================================
// 2. onInvoiceStatusChanged — Handle status transitions
// =============================================================================

export const onInvoiceStatusChanged = fn.firestore
  .document("businesses/{businessId}/invoices/{invoiceId}")
  .onUpdate(async (change, context) => {
    const {businessId, invoiceId} = context.params;
    const before = change.before.data();
    const after = change.after.data();

    if (!before || !after) return;
    if (before.status === after.status) return; // No status change

    const newStatus: string = after.status;
    const oldStatus: string = before.status;

    functions.logger.info("Invoice status changed", {
      businessId, invoiceId,
      from: oldStatus, to: newStatus,
    });

    try {
      // --- OVERDUE ---
      if (newStatus === "overdue") {
        await logActivity(
          businessId, "system", "Facture en retard",
          "invoice", invoiceId,
          {number: after.number, dueDate: formatDate(after.dueDate)}
        );
      }

      // --- PAID ---
      if (newStatus === "paid") {
        // Update client's totalPaid denormalized field
        const clientId: string = after.clientId;
        if (clientId) {
          const totalTTC: number = after.totals?.totalTTC || 0;
          const clientRef = db
            .collection("businesses").doc(businessId)
            .collection("clients").doc(clientId);

          await db.runTransaction(async (t) => {
            const clientDoc = await t.get(clientRef);
            if (!clientDoc.exists) return;
            const clientData = clientDoc.data()!;
            const currentPaid: number = clientData.totalPaid || 0;
            const currentInvoiced: number = clientData.totalInvoiced || 0;
            const newPaid = currentPaid + totalTTC;
            t.update(clientRef, {
              totalPaid: newPaid,
              balance: currentInvoiced - newPaid,
              updatedAt: admin.firestore.FieldValue.serverTimestamp(),
            });
          });
        }

        // Update paidAt timestamp
        await change.after.ref.update({
          paidAt: admin.firestore.FieldValue.serverTimestamp(),
          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
        });

        await logActivity(
          businessId, "system", "Facture payée",
          "invoice", invoiceId,
          {number: after.number, totalTTC: after.totals?.totalTTC}
        );
      }

      // --- CANCELLED ---
      if (newStatus === "cancelled") {
        await change.after.ref.update({
          cancelledAt: admin.firestore.FieldValue.serverTimestamp(),
          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
        });

        await logActivity(
          businessId, "system", "Facture annulée",
          "invoice", invoiceId,
          {
            number: after.number,
            reason: after.cancellationReason || "Non spécifié",
            previousStatus: oldStatus,
          }
        );
      }

      // --- SENT ---
      if (newStatus === "sent" && oldStatus === "draft") {
        await change.after.ref.update({
          sentAt: admin.firestore.FieldValue.serverTimestamp(),
          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
        });

        // Update client's totalInvoiced
        const clientId: string = after.clientId;
        if (clientId) {
          const totalTTC: number = after.totals?.totalTTC || 0;
          const clientRef = db
            .collection("businesses").doc(businessId)
            .collection("clients").doc(clientId);

          await db.runTransaction(async (t) => {
            const clientDoc = await t.get(clientRef);
            if (!clientDoc.exists) return;
            const clientData = clientDoc.data()!;
            const currentInvoiced: number = clientData.totalInvoiced || 0;
            const currentPaid: number = clientData.totalPaid || 0;
            const newInvoiced = currentInvoiced + totalTTC;
            t.update(clientRef, {
              totalInvoiced: newInvoiced,
              balance: newInvoiced - currentPaid,
              updatedAt: admin.firestore.FieldValue.serverTimestamp(),
            });
          });
        }

        await logActivity(
          businessId, "system", "Facture envoyée",
          "invoice", invoiceId,
          {number: after.number}
        );
      }
    } catch (err) {
      functions.logger.error("onInvoiceStatusChanged failed", {
        businessId, invoiceId, error: err,
      });
    }
  });

// =============================================================================
// 3. sendInvoiceReminder — WhatsApp deep link builder
// =============================================================================

export const sendInvoiceReminder = fn.https.onCall(async (data, context) => {
  // Auth check
  if (!context.auth) {
    throw new functions.https.HttpsError("unauthenticated", "Authentification requise.");
  }

  const {businessId, invoiceId} = data;

  if (!businessId || typeof businessId !== "string") {
    throw new functions.https.HttpsError("invalid-argument", "businessId requis.");
  }
  if (!invoiceId || typeof invoiceId !== "string") {
    throw new functions.https.HttpsError("invalid-argument", "invoiceId requis.");
  }

  // Fetch invoice
  const invoiceDoc = await db
    .collection("businesses").doc(businessId)
    .collection("invoices").doc(invoiceId)
    .get();
  if (!invoiceDoc.exists) {
    throw new functions.https.HttpsError("not-found", "Facture introuvable.");
  }
  const invoice = invoiceDoc.data()!;

  // Fetch client
  const clientDoc = await db
    .collection("businesses").doc(businessId)
    .collection("clients").doc(invoice.clientId)
    .get();
  const client = clientDoc.data();

  // Fetch business
  const businessDoc = await db.collection("businesses").doc(businessId).get();
  const business = businessDoc.data();

  const clientPhone = client?.phone?.replace(/\s+/g, "").replace(/^0/, "+212") || "";
  const clientName = client?.name || "Client";
  const invoiceNumber = invoice.number || invoiceId;
  const amount = centimesToMAD(invoice.totals?.totalTTC || 0);
  const businessName = business?.legalName || "Votre fournisseur";

  const message = `Bonjour ${clientName}, votre facture ${invoiceNumber} d'un montant de ${amount} est en attente de règlement. Merci de procéder au paiement dans les meilleurs délais. — ${businessName}`;

  const whatsappUrl = `https://wa.me/${clientPhone.replace("+", "")}?text=${encodeURIComponent(message)}`;

  // Log the reminder
  await logActivity(
    businessId,
    context.auth.uid,
    "Rappel envoyé",
    "invoice",
    invoiceId,
    {number: invoiceNumber, via: "whatsapp", clientName}
  );

  return {
    url: whatsappUrl,
    message,
    clientPhone,
    clientName,
  };
});

// =============================================================================
// 4. generateTVAReport — SIMPL-TVA quarter report
// =============================================================================

interface TVALine {
  rate: number;
  baseHT: number; // centimes
  tvaAmount: number; // centimes
  invoiceCount: number;
}

export const generateTVAReport = fn.https.onCall(async (data, context) => {
  if (!context.auth) {
    throw new functions.https.HttpsError("unauthenticated", "Authentification requise.");
  }

  const {businessId, quarter, year} = data;

  if (!businessId || typeof businessId !== "string") {
    throw new functions.https.HttpsError("invalid-argument", "businessId requis.");
  }
  if (!quarter || !["Q1", "Q2", "Q3", "Q4"].includes(quarter)) {
    throw new functions.https.HttpsError("invalid-argument", "quarter invalide (Q1/Q2/Q3/Q4).");
  }
  if (!year || typeof year !== "number" || year < 2020 || year > 2100) {
    throw new functions.https.HttpsError("invalid-argument", "year invalide.");
  }

  // Determine date range for the quarter
  const quarterStartMonth: Record<string, number> = {
    Q1: 0, Q2: 3, Q3: 6, Q4: 9,
  };
  const startMonth = quarterStartMonth[quarter];
  const startDate = new Date(year, startMonth, 1);
  const endDate = new Date(year, startMonth + 3, 0, 23, 59, 59); // last day of quarter

  const startTs = admin.firestore.Timestamp.fromDate(startDate);
  const endTs = admin.firestore.Timestamp.fromDate(endDate);

  // Query invoices in period (only sent, paid, partially_paid — not drafts or cancelled)
  const validStatuses = ["sent", "validated", "paid", "partially_paid", "overdue"];
  const invoicesSnap = await db
    .collection("businesses").doc(businessId)
    .collection("invoices")
    .where("issueDate", ">=", startTs)
    .where("issueDate", "<=", endTs)
    .get();

  const tvaMap = new Map<number, TVALine>();
  let totalHT = 0;
  let totalTVA = 0;
  let totalTTC = 0;
  let invoiceCount = 0;

  invoicesSnap.docs.forEach((doc) => {
    const inv = doc.data();
    // Skip drafts and cancelled
    if (!validStatuses.includes(inv.status)) return;

    invoiceCount++;
    const totals = inv.totals || {};
    totalHT += totals.totalHT || 0;
    totalTVA += totals.totalTVA || 0;
    totalTTC += totals.totalTTC || 0;

    // Aggregate by TVA rate
    const breakdown: any[] = totals.tvaBreakdown || [];
    breakdown.forEach((entry: any) => {
      const rate = entry.rate ?? 0;
      const existing = tvaMap.get(rate) || {rate, baseHT: 0, tvaAmount: 0, invoiceCount: 0};
      existing.baseHT += entry.base || 0;
      existing.tvaAmount += entry.amount || 0;
      existing.invoiceCount += 1;
      tvaMap.set(rate, existing);
    });
  });

  // Build sorted breakdown
  const tvaBreakdown = Array.from(tvaMap.values()).sort((a, b) => a.rate - b.rate);

  return {
    period: {quarter, year},
    dateRange: {
      start: startDate.toISOString().slice(0, 10),
      end: endDate.toISOString().slice(0, 10),
    },
    invoiceCount,
    totalHT,
    totalTVA,
    totalTTC,
    // Formatted for humans
    totalHT_MAD: centimesToMAD(totalHT),
    totalTVA_MAD: centimesToMAD(totalTVA),
    totalTTC_MAD: centimesToMAD(totalTTC),
    tvaBreakdown: tvaBreakdown.map((t) => ({
      rate: t.rate,
      baseHT: t.baseHT,
      tvaAmount: t.tvaAmount,
      invoiceCount: t.invoiceCount,
      baseHT_MAD: centimesToMAD(t.baseHT),
      tvaAmount_MAD: centimesToMAD(t.tvaAmount),
    })),
    // SIMPL-TVA reference
    simplTVA: {
      regime: "Mensuel ou Trimestriel",
      reference: `TVA-${quarter}-${year}`,
      note: "Ce rapport est généré à titre indicatif. Veuillez vérifier les montants avant soumission au portail SIMPL.",
    },
  };
});

// =============================================================================
// 5. validateICE — ICE format validator
// =============================================================================

export const validateICE = fn.https.onCall(async (data) => {
  const {ice} = data;

  if (!ice || typeof ice !== "string") {
    return {valid: false, error: "ICE requis (chaîne de caractères)."};
  }

  const trimmed = ice.trim();

  // Must be exactly 15 digits
  if (!/^\d{15}$/.test(trimmed)) {
    if (trimmed.length !== 15) {
      return {
        valid: false,
        error: `L'ICE doit contenir exactement 15 chiffres. Longueur actuelle: ${trimmed.length}.`,
      };
    }
    return {
      valid: false,
      error: "L'ICE ne doit contenir que des chiffres (0-9).",
    };
  }

  // Basic checksum/format heuristics (Moroccan ICE structure)
  // First 9 digits = company number, next 4 = establishment, last 2 = control
  const companyPart = trimmed.slice(0, 9);
  const establishmentPart = trimmed.slice(9, 13);
  const controlPart = trimmed.slice(13, 15);

  // Check that company part is not all zeros
  if (/^0+$/.test(companyPart)) {
    return {valid: false, error: "Numéro d'entreprise invalide (tout zéros)."};
  }

  return {
    valid: true,
    structure: {
      companyNumber: companyPart,
      establishmentNumber: establishmentPart,
      controlDigits: controlPart,
    },
    note: "Format valide. La vérification auprès du registre DGI sera disponible prochainement.",
  };
});

// =============================================================================
// 6. scheduledOverdueCheck — Daily 8am Morocco time
// =============================================================================

export const scheduledOverdueCheck = fn.pubsub
  .schedule("0 8 * * *") // 8:00 AM every day
  .timeZone("Africa/Casablanca")
  .onRun(async () => {
    const now = admin.firestore.Timestamp.now();

    functions.logger.info("Running scheduled overdue check", {timestamp: now.toDate().toISOString()});

    try {
      // Get all businesses
      const businessesSnap = await db.collection("businesses").get();

      let totalUpdated = 0;

      for (const businessDoc of businessesSnap.docs) {
        const businessId = businessDoc.id;

        // Query invoices that are "sent" and past due date
        const overdueSnap = await db
          .collection("businesses").doc(businessId)
          .collection("invoices")
          .where("status", "==", "sent")
          .where("dueDate", "<", now)
          .get();

        if (overdueSnap.empty) continue;

        // Batch update
        const batch = db.batch();
        overdueSnap.docs.forEach((invoiceDoc) => {
          batch.update(invoiceDoc.ref, {
            status: "overdue",
            updatedAt: admin.firestore.FieldValue.serverTimestamp(),
          });
        });

        await batch.commit();
        totalUpdated += overdueSnap.size;

        functions.logger.info(`Marked ${overdueSnap.size} invoices as overdue`, {businessId});
      }

      functions.logger.info("Overdue check complete", {totalUpdated});
    } catch (err) {
      functions.logger.error("scheduledOverdueCheck failed", {error: err});
    }
  });

// =============================================================================
// 7. cleanupWhatsAppSessions — Every 15 minutes
// =============================================================================

export const cleanupWhatsAppSessions = fn.pubsub
  .schedule("*/15 * * * *") // Every 15 minutes
  .timeZone("Africa/Casablanca")
  .onRun(async () => {
    const now = admin.firestore.Timestamp.now();

    functions.logger.info("Running WhatsApp session cleanup", {
      timestamp: now.toDate().toISOString(),
    });

    try {
      const businessesSnap = await db.collection("businesses").get();
      let totalCleaned = 0;

      for (const businessDoc of businessesSnap.docs) {
        const businessId = businessDoc.id;

        // Find sessions where expiresAt < now and state is not already 'delivered'
        const expiredSnap = await db
          .collection("businesses")
          .doc(businessId)
          .collection("whatsappSessions")
          .where("expiresAt", "<", now)
          .limit(100) // Batch limit per business
          .get();

        if (expiredSnap.empty) continue;

        const batch = db.batch();
        let count = 0;

        for (const sessionDoc of expiredSnap.docs) {
          const sessionData = sessionDoc.data();
          // Only clean sessions that are not in a terminal state
          if (sessionData.state !== 'delivered') {
            batch.update(sessionDoc.ref, {
              state: "idle",
              intentData: {},
              resolvedData: {},
              pendingField: null,
              updatedAt: admin.firestore.FieldValue.serverTimestamp(),
            });
            count++;
          }
        }

        if (count > 0) {
          await batch.commit();
          totalCleaned += count;
          functions.logger.info(`Cleaned ${count} expired sessions`, { businessId });
        }
      }

      functions.logger.info("WhatsApp session cleanup complete", { totalCleaned });
    } catch (err) {
      functions.logger.error("cleanupWhatsAppSessions failed", { error: err });
    }
  });

// =============================================================================
// 8. WhatsApp Webhook
// =============================================================================

export { whatsappWebhook } from "./whatsapp/webhook";

// =============================================================================
// 9. WhatsApp Link / Unlink — Callable Functions
// =============================================================================

/**
 * linkWhatsApp — Links a WhatsApp phone number to the current business.
 * Creates a whatsappLinks document and stores preferences on the business.
 */
export const linkWhatsApp = fn.https.onCall(async (data, context) => {
  if (!context.auth) {
    throw new functions.https.HttpsError("unauthenticated", "Vous devez être connecté.");
  }

  const { phoneNumber, preferences } = data as {
    phoneNumber: string;
    preferences?: {
      defaultTvaRate?: number;
      autoConfirm?: boolean;
      language?: "fr" | "ar";
      notifyOnGeneration?: boolean;
    };
  };

  if (!phoneNumber || typeof phoneNumber !== "string") {
    throw new functions.https.HttpsError("invalid-argument", "Numéro de téléphone requis.");
  }

  // Normalize: strip all non-digits, ensure starts with country code
  const waId = phoneNumber.replace(/\D/g, "");
  if (waId.length < 10 || waId.length > 15) {
    throw new functions.https.HttpsError(
      "invalid-argument",
      "Numéro de téléphone invalide. Utilisez le format international (ex: 212600000000)."
    );
  }

  // Get the user's business
  const uid = context.auth.uid;
  const businessSnap = await db.collection("businesses")
    .where("ownerId", "==", uid)
    .limit(1)
    .get();

  if (businessSnap.empty) {
    throw new functions.https.HttpsError("not-found", "Entreprise non trouvée.");
  }

  const businessDoc = businessSnap.docs[0];
  const businessId = businessDoc.id;

  // Check if this phone is already linked to another business
  const existingLink = await db.collection("whatsappLinks").doc(waId).get();
  if (existingLink.exists) {
    const linkData = existingLink.data();
    if (linkData?.isActive && linkData?.businessId !== businessId) {
      throw new functions.https.HttpsError(
        "already-exists",
        "Ce numéro est déjà lié à une autre entreprise."
      );
    }
  }

  const now = admin.firestore.FieldValue.serverTimestamp();

  // Create or update the whatsappLinks document
  await db.collection("whatsappLinks").doc(waId).set({
    waId,
    businessId,
    ownerId: uid,
    isActive: true,
    linkedAt: now,
    lastMessageAt: now,
  });

  await logActivity(businessId, uid, "WhatsApp: compte lié", "whatsappLinks", waId, { waId, preferences });

  // Store preferences on the business document
  const whatsappPrefs = {
    defaultTvaRate: preferences?.defaultTvaRate ?? 20,
    autoConfirm: preferences?.autoConfirm ?? false,
    language: preferences?.language ?? "fr",
    notifyOnGeneration: preferences?.notifyOnGeneration ?? true,
  };

  await businessDoc.ref.update({
    whatsappLinkedPhone: waId,
    whatsappPreferences: whatsappPrefs,
    updatedAt: now,
  });

  // Send welcome message (fire-and-forget)
  try {
    const { sendWelcomeMessage } = await import("./whatsapp/messenger");
    await sendWelcomeMessage(waId);
  } catch (e) {
    functions.logger.warn("Failed to send WhatsApp welcome message", { error: e });
  }

  functions.logger.info("WhatsApp linked successfully", { waId, businessId });

  return {
    success: true,
    waId,
    message: "WhatsApp lié avec succès !",
  };
});

/**
 * unlinkWhatsApp — Unlinks a WhatsApp phone number from the current business.
 */
export const unlinkWhatsApp = fn.https.onCall(async (data, context) => {
  if (!context.auth) {
    throw new functions.https.HttpsError("unauthenticated", "Vous devez être connecté.");
  }

  const uid = context.auth.uid;

  // Get the user's business
  const businessSnap = await db.collection("businesses")
    .where("ownerId", "==", uid)
    .limit(1)
    .get();

  if (businessSnap.empty) {
    throw new functions.https.HttpsError("not-found", "Entreprise non trouvée.");
  }

  const businessDoc = businessSnap.docs[0];
  const businessData = businessDoc.data();
  const waId = businessData?.whatsappLinkedPhone;

  if (!waId) {
    throw new functions.https.HttpsError("not-found", "Aucun numéro WhatsApp lié.");
  }

  // Deactivate the whatsappLinks document
  const linkRef = db.collection("whatsappLinks").doc(waId);
  const linkDoc = await linkRef.get();
  if (linkDoc.exists) {
    await linkRef.update({
      isActive: false,
      deactivatedAt: admin.firestore.FieldValue.serverTimestamp(),
    });
  }

  // Remove WhatsApp fields from business
  await businessDoc.ref.update({
    whatsappLinkedPhone: admin.firestore.FieldValue.delete(),
    whatsappPreferences: admin.firestore.FieldValue.delete(),
    updatedAt: admin.firestore.FieldValue.serverTimestamp(),
  });

  functions.logger.info("WhatsApp unlinked", { waId, businessId: businessDoc.id });

  return { success: true, message: "WhatsApp délié avec succès." };
});

// =============================================================================

/**
 * getWhatsAppStats — Retrieves usage statistics for the WhatsApp integration.
 */
export const getWhatsAppStats = fn.https.onCall(async (data, context) => {
  if (!context.auth) {
    throw new functions.https.HttpsError("unauthenticated", "Vous devez être connecté.");
  }

  const { businessId } = data as { businessId: string };
  if (!businessId) {
    throw new functions.https.HttpsError("invalid-argument", "businessId requis.");
  }

  // Verify ownership
  const businessDoc = await db.collection("businesses").doc(businessId).get();
  if (!businessDoc.exists || businessDoc.data()?.ownerId !== context.auth.uid) {
    throw new functions.https.HttpsError("permission-denied", "Accès refusé.");
  }

  const now = Date.now();
  const thirtyDaysAgo = admin.firestore.Timestamp.fromMillis(now - 30 * 24 * 60 * 60 * 1000);

  // 1. Get recent activity for the last 30 days
  const activitySnap = await db.collection(`businesses/${businessId}/activity`)
    .where("createdAt", ">=", thirtyDaysAgo)
    .orderBy("createdAt", "desc")
    .get();

  let totalSessions = 0;
  let invoicesCreated = 0;
  let errors = 0;
  let pdfSent = 0;
  const recentActivity: any[] = [];

  activitySnap.forEach(doc => {
    const act = doc.data();
    if (typeof act.action === 'string' && act.action.startsWith('WhatsApp:')) {
      if (recentActivity.length < 10) {
        recentActivity.push({ id: doc.id, ...act });
      }

      switch (act.action) {
        case 'WhatsApp: session démarrée':
          totalSessions++;
          break;
        case 'WhatsApp: facture créée':
          invoicesCreated++;
          break;
        case 'WhatsApp: erreur':
          errors++;
          break;
        case 'WhatsApp: PDF envoyé':
          pdfSent++;
          break;
      }
    }
  });

  // 2. Check active link
  const linkQuery = await db.collection("whatsappLinks")
    .where("businessId", "==", businessId)
    .where("isActive", "==", true)
    .limit(1)
    .get();
  
  let activeLink = null;
  if (!linkQuery.empty) {
    const linkDoc = linkQuery.docs[0].data();
    activeLink = {
      waId: linkDoc.waId,
      linkedAt: linkDoc.linkedAt,
      lastMessageAt: linkDoc.lastMessageAt
    };
  }

  return {
    success: true,
    stats: {
      totalSessions,
      invoicesCreated,
      errors,
      pdfSent,
      successRate: totalSessions > 0 ? Math.round((invoicesCreated / totalSessions) * 100) : 0,
      activeLink,
      recentActivity
    }
  };
});

import { parseMoroccanPrice, parseInvoiceIntent } from '../nlp';
import { jaroWinklerSimilarity } from '../matcher';

// Simple mock for GoogleGenerativeAI
jest.mock('@google/generative-ai', () => {
  return {
    GoogleGenerativeAI: jest.fn().mockImplementation(() => ({
      getGenerativeModel: jest.fn().mockImplementation(() => ({
        generateContent: jest.fn().mockResolvedValue({
          response: {
            text: () => JSON.stringify({
              intent: 'create_invoice',
              confidence: 0.9,
              entities: {
                clientName: 'Ahmed',
                productLabel: 'logo design',
                quantity: 1,
                unitPrice: 8500,
                currency: 'MAD',
                tvaOverride: null,
                priceType: 'HT',
                dueDate: null,
                notes: null
              }
            })
          }
        })
      }))
    })),
    SchemaType: { OBJECT: 'OBJECT', STRING: 'STRING', NUMBER: 'NUMBER' },
    Schema: {}
  };
});

// Mock config
jest.mock('../config', () => ({
  whatsappConfig: {
    geminiApiKey: 'MOCK_API_KEY'
  }
}));

// Mock logger
jest.mock('firebase-functions/logger', () => ({
  info: jest.fn(),
  error: jest.fn(),
  warn: jest.fn()
}));

describe('NLP & Matcher Helpers', () => {

  describe('parseMoroccanPrice', () => {
    it('parses basic integer strings', () => {
      expect(parseMoroccanPrice('500')).toBe(50000);
      expect(parseMoroccanPrice('8500')).toBe(850000);
    });

    it('parses strings with suffixes (dh, MAD)', () => {
      expect(parseMoroccanPrice('8500dh')).toBe(850000);
      expect(parseMoroccanPrice('15000 MAD')).toBe(1500000);
      expect(parseMoroccanPrice('8500,50 dh')).toBe(850050);
    });

    it('handles Moroccan dot-for-thousands and comma-for-decimals format', () => {
      expect(parseMoroccanPrice('8.500,00')).toBe(850000);
      expect(parseMoroccanPrice('15.000,50')).toBe(1500050);
    });

    it('handles simple decimals', () => {
      expect(parseMoroccanPrice('8500.50')).toBe(850050);
      expect(parseMoroccanPrice('8500,50')).toBe(850050);
    });
    
    it('handles spaced numbers', () => {
      expect(parseMoroccanPrice('8 500 MAD')).toBe(850000);
    });
  });

  describe('jaroWinklerSimilarity', () => {
    it('returns 1.0 for exact matches', () => {
      expect(jaroWinklerSimilarity('Ahmed', 'Ahmed')).toBe(1.0);
    });

    it('returns high score (> 0.8) for minor typos', () => {
      const score = jaroWinklerSimilarity('Ahmed', 'Ahmad');
      expect(score).toBeGreaterThan(0.8);
    });

    it('returns low score (< 0.5) for completely different words', () => {
      const score = jaroWinklerSimilarity('Ahmed', 'Karim');
      expect(score).toBeLessThan(0.5);
    });

    it('handles case and diacritics', () => {
      const score1 = jaroWinklerSimilarity('Océane', 'oceane');
      expect(score1).toBe(1.0);
    });
  });

  describe('parseInvoiceIntent (Mocked Gemini)', () => {
    it('extracts intent correctly from message', async () => {
      const message = "Facture pour Ahmed, logo design 8500dh";
      const result = await parseInvoiceIntent(message);

      expect(result.intent).toBe('create_invoice');
      expect(result.confidence).toBe(0.9);
      expect(result.entities.clientName).toBe('Ahmed');
      expect(result.entities.productLabel).toBe('logo design');
      expect(result.entities.unitPrice).toBe(850000); // Converted by our wrapper
    });
  });

});

import * as functions from 'firebase-functions';

// We use getters so that the config is read at runtime instead of module load time.
// This is important for Firebase Functions to pick up config changes properly,
// and it provides placeholder fallbacks for when the config isn't fully set yet.
export const whatsappConfig = {
  get twilioAccountSid() { return process.env.TWILIO_ACCOUNT_SID || 'PLACEHOLDER_SID'; },
  get twilioAuthToken() { return process.env.TWILIO_AUTH_TOKEN || 'PLACEHOLDER_TOKEN'; },
  get twilioPhoneNumber() { return process.env.TWILIO_PHONE_NUMBER || 'whatsapp:+14155238886'; }, // Sandbox number
  get geminiApiKey() { return process.env.GEMINI_API_KEY || 'PLACEHOLDER_GEMINI_KEY'; }
};

import * as admin from 'firebase-admin';
import * as logger from 'firebase-functions/logger';
import { WebhookMessage } from './types';
import { WhatsAppSession, InvoiceLine, NlpIntent } from '../../../src/types';
import { parseInvoiceIntent, parseMoroccanPrice } from './nlp';
import { findClientByName, findProductByLabel } from './matcher';
import { sendTextMessage, sendButtonMessage, sendListMessage } from './messenger';
import { calculateLineTotals, calculateInvoiceTotals } from './tva-server';
import { createInvoiceFromWhatsApp } from './invoice-creator';
import { deliverInvoicePDF } from './pdf-delivery';
import { isInvoiceRateLimited, recordInvoiceCreation } from './webhook';
import { logActivity } from '../index';

if (!admin.apps.length) {
  admin.initializeApp();
}

const db = admin.firestore();

// ─────────────────────────────────────────────────────────────
// Constants
// ─────────────────────────────────────────────────────────────
const MAX_CONSECUTIVE_ERRORS = 3;
const MAX_MESSAGE_LENGTH = 1000;

const HELP_MESSAGE = `📋 Comment utiliser Fatura WhatsApp:

Créer une facture:
→ "Facture pour [client], [produit] [prix]dh"
→ "Facture pour Ahmed Benali, consulting 5000 MAD"

Options:
→ "sans TVA" pour une facture sans TVA
→ "TTC" si le prix inclut la TVA
→ "échéance 15 jours" pour changer l'échéance

Commandes:
→ "aide" — afficher ce message
→ "annuler" — annuler la session en cours

Le bot utilise les clients et produits de votre compte Fatura.`;

// ─────────────────────────────────────────────────────────────
// Session Management
// ─────────────────────────────────────────────────────────────
async function getOrCreateSession(businessId: string, waId: string): Promise<WhatsAppSession> {
  const sessionsRef = db.collection(`businesses/${businessId}/whatsappSessions`);
  const snapshot = await sessionsRef
    .where('waId', '==', waId)
    .orderBy('createdAt', 'desc')
    .limit(1)
    .get();

  let session: WhatsAppSession | null = null;
  if (!snapshot.empty) {
    const s = snapshot.docs[0].data() as WhatsAppSession;
    s.id = snapshot.docs[0].id;
    const expiresAt = (s.expiresAt as any).toMillis ? (s.expiresAt as any).toMillis() : s.expiresAt;
    if (expiresAt > Date.now() && s.state !== 'delivered') {
      session = s;
    }
  }

  if (!session) {
    const newRef = sessionsRef.doc();
    const expiresAt = admin.firestore.Timestamp.fromMillis(Date.now() + 30 * 60 * 1000);
    const newSession: any = {
      id: newRef.id,
      businessId,
      waId,
      state: 'idle',
      intentData: {},
      resolvedData: {},
      pendingField: null,
      messageHistory: [],
      invoiceId: null,
      errorCount: 0,
      currentOptions: [],
      expiresAt,
      createdAt: admin.firestore.FieldValue.serverTimestamp(),
      updatedAt: admin.firestore.FieldValue.serverTimestamp(),
    };
    await newRef.set(newSession);
    newSession.expiresAt = expiresAt; 
    session = newSession as WhatsAppSession;
    
    await logActivity(businessId, "system", "WhatsApp: session démarrée", "whatsappSession", newRef.id, { waId });
  }

  return session;
}

async function updateSession(businessId: string, sessionId: string, data: Partial<WhatsAppSession>): Promise<void> {
  const ref = db.collection(`businesses/${businessId}/whatsappSessions`).doc(sessionId);
  await ref.update({
    ...data,
    updatedAt: admin.firestore.FieldValue.serverTimestamp(),
  });
}

async function resetSession(businessId: string, sessionId: string): Promise<void> {
  const ref = db.collection(`businesses/${businessId}/whatsappSessions`).doc(sessionId);
  await ref.update({
    state: 'idle',
    intentData: {},
    resolvedData: {},
    pendingField: null,
    errorCount: 0,
    currentOptions: [],
    updatedAt: admin.firestore.FieldValue.serverTimestamp(),
  });
}

async function incrementErrorCount(businessId: string, session: WhatsAppSession): Promise<number> {
  const newCount = (session.errorCount || 0) + 1;
  await updateSession(businessId, session.id, { errorCount: newCount } as any);
  return newCount;
}

async function addMessageToHistory(businessId: string, sessionId: string, role: 'user' | 'bot', content: string) {
  const ref = db.collection(`businesses/${businessId}/whatsappSessions`).doc(sessionId);
  await db.runTransaction(async (transaction) => {
    const docSnap = await transaction.get(ref);
    if (!docSnap.exists) return;
    const session = docSnap.data() as WhatsAppSession;
    const history = session.messageHistory || [];
    history.push({
      role,
      content,
      timestamp: admin.firestore.Timestamp.now() as any
    });
    if (history.length > 10) {
      history.splice(0, history.length - 10);
    }
    transaction.update(ref, {
      messageHistory: history,
      updatedAt: admin.firestore.FieldValue.serverTimestamp()
    });
  });
}

// ─────────────────────────────────────────────────────────────
// Message Parsing Helpers
// ─────────────────────────────────────────────────────────────

function getReplyId(message: WebhookMessage, session: WhatsAppSession): string | null {
  if (message.type === 'interactive') {
    return message.interactive?.button_reply?.id || message.interactive?.list_reply?.id || null;
  }
  
  if (message.type === 'text') {
    const text = message.text?.body?.trim();
    if (!text) return null;
    
    // Check if it's a number corresponding to an option
    const index = parseInt(text, 10);
    if (!isNaN(index) && session.currentOptions && index > 0 && index <= session.currentOptions.length) {
      return session.currentOptions[index - 1];
    }

    // Also check if the text matches the option ID exactly (for robustness)
    if (session.currentOptions?.includes(text)) {
      return text;
    }
  }
  
  return null;
}

// ─────────────────────────────────────────────────────────────
// Main Entry Point
// ─────────────────────────────────────────────────────────────
export async function processMessage(businessId: string, waId: string, message: WebhookMessage) {
  let session: WhatsAppSession;

  try {
    session = await getOrCreateSession(businessId, waId);
  } catch (err) {
    logger.error('Failed to get/create session', { error: err, businessId, waId });
    await safeSend(waId, "Erreur de base de données. Réessayez dans quelques instants.");
    return;
  }

  try {
    // ── Reject non-text/interactive messages ──
    if (message.type !== 'text' && message.type !== 'interactive') {
      await sendTextMessage(waId, "Je ne comprends que les messages texte pour l'instant. Envoyez votre demande en texte.");
      return;
    }

    // ── Extract text content ──
    const messageText = message.type === 'text' ? message.text?.body : 
      (message.interactive?.button_reply?.title || message.interactive?.list_reply?.title || message.interactive?.list_reply?.id);
      
    if (!messageText || messageText.trim().length === 0) return;

    if (messageText.length > MAX_MESSAGE_LENGTH) {
      await sendTextMessage(waId, "Message trop long. Veuillez raccourcir votre message.");
      return;
    }

    await addMessageToHistory(businessId, session.id, 'user', messageText);

    const lowerText = messageText.toLowerCase().trim();
    
    if (lowerText === 'aide' || lowerText === 'help') {
      await sendTextMessage(waId, HELP_MESSAGE);
      return;
    }

    if (lowerText === 'annuler') {
      if (session.state !== 'idle') {
        await resetSession(businessId, session.id);
        await sendTextMessage(waId, "Session annulée.");
      } else {
        await sendTextMessage(waId, "Rien à annuler.");
      }
      return;
    }

    // ── State machine dispatch ──
    switch (session.state) {
      case 'idle':
      case 'parsing_intent':
        await handleParsingIntent(businessId, waId, session, messageText);
        break;
      case 'awaiting_client':
        await handleAwaitingClient(businessId, waId, session, message);
        break;
      case 'creating_client':
        await handleCreatingClient(businessId, waId, session, messageText);
        break;
      case 'awaiting_product':
        await handleAwaitingProduct(businessId, waId, session, messageText);
        break;
      case 'awaiting_details':
        await handleAwaitingDetails(businessId, waId, session, messageText);
        break;
      case 'confirming':
        await handleConfirming(businessId, waId, session, message);
        break;
      case 'generating':
        await sendTextMessage(waId, "⏳ Votre facture est en cours de génération, veuillez patienter.");
        break;
      case 'delivered':
      case 'error':
        await resetSession(businessId, session.id);
        const freshSession = await getOrCreateSession(businessId, waId);
        await handleParsingIntent(businessId, waId, freshSession, messageText);
        break;
    }

    if ((session.errorCount || 0) > 0) {
      await updateSession(businessId, session.id, { errorCount: 0 } as any);
    }

  } catch (error: any) {
    logger.error('Error processing message', {
      error: error.message,
      stack: error.stack,
      businessId,
      sessionId: session.id,
      state: session.state,
      waId,
    });

    const errorCount = await incrementErrorCount(businessId, session);

    if (errorCount >= MAX_CONSECUTIVE_ERRORS) {
      await resetSession(businessId, session.id);
      await safeSend(waId, "Plusieurs erreurs consécutives se sont produites. Votre session a été réinitialisée. Veuillez réessayer.");
    } else {
      await safeSend(waId, "Désolé, une erreur technique est survenue. Réessayez.");
    }
  }
}

async function safeSend(waId: string, text: string): Promise<void> {
  try {
    await sendTextMessage(waId, text);
  } catch (err) {
    logger.error('safeSend: failed to send error notification', { err, waId });
  }
}

// ─────────────────────────────────────────────────────────────
// State Handlers
// ─────────────────────────────────────────────────────────────

async function handleParsingIntent(businessId: string, waId: string, session: WhatsAppSession, text: string) {
  await sendTextMessage(waId, "⏳ Je m'en occupe ! Un instant...");
  
  let intent: NlpIntent;
  try {
    intent = await parseInvoiceIntent(text, session.messageHistory);
  } catch (err) {
    logger.error('NLP API failure', { error: err, businessId });
    await sendTextMessage(waId, "Désolé, une erreur technique est survenue. Réessayez.");
    return;
  }

  if (intent.confidence < 0.5 && intent.intent === 'create_invoice') {
    await sendTextMessage(waId, "Je n'ai pas bien compris. Essayez par exemple : \"Facture pour Ahmed, consulting 5000dh\"");
    return;
  }

  if (intent.intent === 'create_invoice') {
    await updateSession(businessId, session.id, { 
      state: 'parsing_intent',
      intentData: intent.entities as any
    });

    if (intent.entities.clientName) {
      await sendTextMessage(waId, `🔍 Recherche du client "${intent.entities.clientName}"...`);
      const match = await findClientByName(businessId, intent.entities.clientName);
      if (match.exact) {
        await logActivity(businessId, "system", "WhatsApp: client résolu", "client", match.exact.id, { 
          method: "exact_match",
          name: match.exact.name 
        });
        await updateSession(businessId, session.id, {
          state: 'awaiting_product',
          resolvedData: { ...session.resolvedData, clientId: match.exact.id }
        });
        await processProductPhase(businessId, waId, session.id, intent);
      } else if (match.fuzzy.length > 0) {
        const options = match.fuzzy.slice(0, 5).map(c => `client_${c.id}`);
        await updateSession(businessId, session.id, { state: 'awaiting_client', currentOptions: options });
        
        const sections = [{
          title: "Clients trouvés",
          rows: match.fuzzy.slice(0, 5).map(c => ({ id: `client_${c.id}`, title: c.name, description: '' }))
        }];
        await sendListMessage(waId, `Plusieurs clients correspondent à "${intent.entities.clientName}". Lequel ?`, sections);
      } else {
        const options = ['create_client', 'retry_client'];
        await updateSession(businessId, session.id, { state: 'awaiting_client', currentOptions: options });
        
        await sendButtonMessage(waId, `Client "${intent.entities.clientName}" introuvable. Voulez-vous le créer ?`, [
          { id: 'create_client', title: 'Oui, créer' },
          { id: 'retry_client', title: 'Non, réessayer' }
        ]);
      }
    } else {
      await updateSession(businessId, session.id, { state: 'awaiting_client', currentOptions: [] });
      await sendTextMessage(waId, "Pour quel client voulez-vous créer la facture ?");
    }
  } else if (intent.intent === 'unknown') {
    await sendTextMessage(waId, "Je n'ai pas compris. Essayez \"aide\" pour voir des exemples.");
  }
}

async function handleAwaitingClient(businessId: string, waId: string, session: WhatsAppSession, message: WebhookMessage) {
  const replyId = getReplyId(message, session);
  
  if (replyId) {
    if (replyId === 'create_client') {
      await updateSession(businessId, session.id, { state: 'creating_client', currentOptions: [] });
      await sendTextMessage(waId, "Entrez l'ICE du client (ou tapez \"passer\" pour ignorer) :");
    } else if (replyId === 'retry_client') {
      await updateSession(businessId, session.id, { currentOptions: [] });
      await sendTextMessage(waId, "Quel est le nom du client ?");
    } else if (replyId?.startsWith('client_')) {
      const clientId = replyId.replace('client_', '');
      await logActivity(businessId, "system", "WhatsApp: client résolu", "client", clientId, { 
        method: "list_selection",
        waId 
      });
      await updateSession(businessId, session.id, {
        state: 'awaiting_product',
        currentOptions: [],
        resolvedData: { ...session.resolvedData, clientId }
      });
      await processProductPhase(businessId, waId, session.id, { entities: session.intentData } as any);
    }
  } else if (message.type === 'text') {
    const text = message.text?.body;
    if (!text) return;
    const match = await findClientByName(businessId, text);
    if (match.exact) {
        await logActivity(businessId, "system", "WhatsApp: client résolu", "client", match.exact.id, { 
          method: "exact_match",
          name: match.exact.name 
        });
        await updateSession(businessId, session.id, {
          state: 'awaiting_product',
          currentOptions: [],
          resolvedData: { ...session.resolvedData, clientId: match.exact.id }
        });
        await processProductPhase(businessId, waId, session.id, { entities: session.intentData } as any);
    } else {
      const options = ['create_client', 'retry_client'];
      await updateSession(businessId, session.id, { currentOptions: options });
      await sendButtonMessage(waId, `Client "${text}" introuvable.`, [
          { id: 'create_client', title: 'Créer nouveau' },
          { id: 'retry_client', title: 'Réessayer' }
      ]);
    }
  }
}

async function handleCreatingClient(businessId: string, waId: string, session: WhatsAppSession, text: string) {
  let ice = text.trim();
  if (ice.toLowerCase() === 'passer') {
    ice = '';
  }
  
  const clientName = session.intentData.clientName || 'Nouveau Client';
  const newClientRef = db.collection(`businesses/${businessId}/clients`).doc();
  await newClientRef.set({
    id: newClientRef.id,
    businessId,
    name: clientName,
    ice,
    totalInvoiced: 0,
    totalPaid: 0,
    balance: 0,
    address: { street: '', city: '', postalCode: '', country: 'MA' },
    createdAt: admin.firestore.FieldValue.serverTimestamp(),
    updatedAt: admin.firestore.FieldValue.serverTimestamp()
  });

  await logActivity(businessId, "system", "WhatsApp: client résolu", "client", newClientRef.id, { 
    method: "created",
    name: clientName 
  });

  await updateSession(businessId, session.id, {
    state: 'awaiting_product',
    resolvedData: { ...session.resolvedData, clientId: newClientRef.id }
  });

  await sendTextMessage(waId, `Client "${clientName}" créé avec succès.`);
  await processProductPhase(businessId, waId, session.id, { entities: session.intentData } as any);
}

async function processProductPhase(businessId: string, waId: string, sessionId: string, intent: NlpIntent) {
  const sessionDoc = await db.collection(`businesses/${businessId}/whatsappSessions`).doc(sessionId).get();
  const session = sessionDoc.data() as WhatsAppSession;

  if (intent.entities.productLabel) {
    const match = await findProductByLabel(businessId, intent.entities.productLabel);
    const label = match.exact ? match.exact.label : intent.entities.productLabel;
    
    if (intent.entities.unitPrice !== undefined && intent.entities.unitPrice !== null) {
      const tvaRate = intent.entities.tvaOverride !== null ? intent.entities.tvaOverride : 20;
      const quantity = intent.entities.quantity || 1;
      let unitPrice = intent.entities.unitPrice; 
      
      if (intent.entities.priceType === 'TTC') {
         unitPrice = Math.round((unitPrice * 100) / (100 + tvaRate));
      }

      const line: InvoiceLine = {
        id: "temp_line_id",
        description: label,
        quantity,
        unitPrice,
        tvaRate: tvaRate as any,
        totalHT: 0, totalTVA: 0, totalTTC: 0
      };
      
      const { taxableBase, totalTVA, totalTTC } = calculateLineTotals(unitPrice, quantity, tvaRate, undefined);
      line.totalHT = taxableBase;
      line.totalTVA = totalTVA;
      line.totalTTC = totalTTC;

      const lines = [line];
      const totals = calculateInvoiceTotals(lines);

      await updateSession(businessId, session.id, {
        state: 'confirming',
        resolvedData: { ...session.resolvedData, lines, totals }
      });
      await sendConfirmation(businessId, waId, session.id);
    } else {
      await updateSession(businessId, session.id, {
        state: 'awaiting_details',
        pendingField: 'price'
      });
      await sendTextMessage(waId, `Quel est le prix HT pour "${label}" ? (ex: 5000dh)`);
    }
  } else {
    await updateSession(businessId, session.id, {
      state: 'awaiting_details',
      pendingField: 'product_label'
    });
    await sendTextMessage(waId, "Quelle est la description du produit/service ?");
  }
}

async function handleAwaitingProduct(businessId: string, waId: string, session: WhatsAppSession, text: string) {
  session.intentData.productLabel = text;
  await updateSession(businessId, session.id, {
    intentData: session.intentData
  });
  await processProductPhase(businessId, waId, session.id, { entities: session.intentData } as any);
}

async function handleAwaitingDetails(businessId: string, waId: string, session: WhatsAppSession, text: string) {
  if (session.pendingField === 'product_label') {
    session.intentData.productLabel = text;
    await updateSession(businessId, session.id, { intentData: session.intentData });
    await processProductPhase(businessId, waId, session.id, { entities: session.intentData } as any);
  } else if (session.pendingField === 'price') {
    const price = parseMoroccanPrice(text);
    if (price <= 0) {
      await sendTextMessage(waId, "Veuillez entrer un prix valide supérieur à 0.");
      return;
    }
    session.intentData.unitPrice = price;
    await updateSession(businessId, session.id, { intentData: session.intentData });
    await processProductPhase(businessId, waId, session.id, { entities: session.intentData } as any);
  }
}

async function sendConfirmation(businessId: string, waId: string, sessionId: string) {
  const sessionDoc = await db.collection(`businesses/${businessId}/whatsappSessions`).doc(sessionId).get();
  const session = sessionDoc.data() as WhatsAppSession;

  const clientDoc = await db.collection(`businesses/${businessId}/clients`).doc(session.resolvedData.clientId!).get();
  const clientName = clientDoc.data()?.name || "Client Inconnu";

  const lines = session.resolvedData.lines || [];
  const totals = session.resolvedData.totals;
  if (lines.length === 0 || !totals) return;

  const line = lines[0];
  const tvaStr = line.tvaRate === 0 ? "Sans TVA" : `TVA ${line.tvaRate}%: ${(totals.totalTVA / 100).toFixed(2)}`;
  const summary = `📋 Facture pour *${clientName}*:\n• ${line.description} — ${line.quantity} x ${(line.unitPrice / 100).toFixed(2)} MAD HT\n• ${tvaStr}\n• *Total TTC: ${(totals.totalTTC / 100).toFixed(2)} MAD*\n\nVoulez-vous la générer ?`;

  const options = ['generate_invoice', 'modify_invoice', 'cancel_invoice'];
  await updateSession(businessId, session.id, { currentOptions: options });

  await sendButtonMessage(waId, summary, [
    { id: 'generate_invoice', title: '✅ Générer' },
    { id: 'modify_invoice', title: '✏️ Modifier' },
    { id: 'cancel_invoice', title: '❌ Annuler' }
  ]);
}

async function handleConfirming(businessId: string, waId: string, session: WhatsAppSession, message: WebhookMessage) {
  const replyId = getReplyId(message, session);
  
  if (replyId) {
    if (replyId === 'cancel_invoice') {
      await logActivity(businessId, "system", "WhatsApp: session annulée", "whatsappSession", session.id, { waId });
      await resetSession(businessId, session.id);
      await sendTextMessage(waId, "Facture annulée.");
    } else if (replyId === 'modify_invoice') {
      await sendModifyOptions(businessId, waId, session.id);
    } else if (replyId === 'generate_invoice') {
      await logActivity(businessId, "system", "WhatsApp: facture confirmée", "whatsappSession", session.id, { waId });
      await generateAndDeliver(businessId, waId, session);
    } else if (replyId?.startsWith('modify_')) {
      await handleModifyField(businessId, waId, session, replyId);
    }
  } else if (message.type === 'text' && session.pendingField) {
    const text = message.text?.body;
    if (!text) return;
    await handleModifyValue(businessId, waId, session, text);
  }
}

async function sendModifyOptions(businessId: string, waId: string, sessionId: string) {
  const options = ['modify_description', 'modify_price', 'modify_quantity', 'modify_tva'];
  await updateSession(businessId, sessionId, { currentOptions: options });

  const sections = [{
    title: "Que voulez-vous modifier ?",
    rows: [
      { id: 'modify_description', title: 'Description', description: 'Changer la description du service' },
      { id: 'modify_price', title: 'Prix unitaire', description: 'Changer le prix HT' },
      { id: 'modify_quantity', title: 'Quantité', description: 'Changer la quantité' },
      { id: 'modify_tva', title: 'TVA', description: 'Changer le taux de TVA' },
    ]
  }];
  await sendListMessage(waId, "Sélectionnez le champ à modifier :", sections);
}

async function handleModifyField(businessId: string, waId: string, session: WhatsAppSession, replyId: string) {
  const fieldMap: Record<string, { field: string; prompt: string }> = {
    'modify_description': { field: 'description', prompt: 'Entrez la nouvelle description :' },
    'modify_price': { field: 'price', prompt: 'Entrez le nouveau prix HT (ex: 5000dh) :' },
    'modify_quantity': { field: 'quantity', prompt: 'Entrez la nouvelle quantité :' },
    'modify_tva': { field: 'tva', prompt: 'Entrez le nouveau taux de TVA (0, 7, 10, 14 ou 20) :' },
  };

  const mapping = fieldMap[replyId];
  if (!mapping) return;

  await updateSession(businessId, session.id, {
    state: 'confirming',
    pendingField: mapping.field,
    currentOptions: [] // Clear options while waiting for text input
  });
  await sendTextMessage(waId, mapping.prompt);
}

async function handleModifyValue(businessId: string, waId: string, session: WhatsAppSession, text: string) {
  const lines = session.resolvedData.lines || [];
  if (lines.length === 0) {
    await sendTextMessage(waId, "Erreur: aucune ligne à modifier.");
    return;
  }

  const line = lines[0];
  const field = session.pendingField;

  if (field === 'description') {
    line.description = text;
  } else if (field === 'price') {
    const price = parseMoroccanPrice(text);
    if (price <= 0) {
      await sendTextMessage(waId, "Prix invalide. Réessayez (ex: 5000dh) :");
      return;
    }
    line.unitPrice = price;
  } else if (field === 'quantity') {
    const qty = parseInt(text, 10);
    if (isNaN(qty) || qty <= 0) {
      await sendTextMessage(waId, "Quantité invalide. Entrez un nombre supérieur à 0 :");
      return;
    }
    line.quantity = qty;
  } else if (field === 'tva') {
    const tva = parseInt(text, 10);
    if (![0, 7, 10, 14, 20].includes(tva)) {
      await sendTextMessage(waId, "Taux de TVA invalide. Valeurs acceptées : 0, 7, 10, 14, 20");
      return;
    }
    line.tvaRate = tva as any;
  }

  const { taxableBase, totalTVA, totalTTC } = calculateLineTotals(
    line.unitPrice, line.quantity, line.tvaRate, undefined
  );
  line.totalHT = taxableBase;
  line.totalTVA = totalTVA;
  line.totalTTC = totalTTC;

  const totals = calculateInvoiceTotals(lines);

  await updateSession(businessId, session.id, {
    state: 'confirming',
    pendingField: null,
    resolvedData: { ...session.resolvedData, lines, totals }
  });

  await sendConfirmation(businessId, waId, session.id);
}

// ─────────────────────────────────────────────────────────────
// Invoice Generation
// ─────────────────────────────────────────────────────────────

async function generateAndDeliver(businessId: string, waId: string, session: WhatsAppSession) {
  if (isInvoiceRateLimited(businessId)) {
    await sendTextMessage(waId, "Vous avez atteint le nombre maximum de factures pour cette heure. Réessayez plus tard.");
    return;
  }

  await updateSession(businessId, session.id, { state: 'generating' });
  
  try {
    const invoice = await createInvoiceFromWhatsApp(businessId, session.resolvedData, session.intentData);
    recordInvoiceCreation(businessId);

    await logActivity(businessId, "system", "WhatsApp: facture créée", "invoice", invoice.id, { 
      invoiceNumber: invoice.number,
      waId
    });

    await updateSession(businessId, session.id, { 
      state: 'generating',
      invoiceId: invoice.id 
    });
    
    await sendTextMessage(waId, `🚀 Facture ${invoice.number} créée ! Je génère maintenant le PDF...`);
    deliverInvoicePDF(businessId, invoice.id, session.id, waId).catch(err => {
      logger.error('Async PDF delivery failed', { error: err, businessId, invoiceId: invoice.id });
    });
    
  } catch (e: any) {
    logger.error('Failed to generate invoice', {
      error: e.message,
      stack: e.stack,
      businessId,
      sessionId: session.id,
    });
    await logActivity(businessId, "system", "WhatsApp: erreur", "whatsappSession", session.id, { 
      error: e.message,
      context: "generateAndDeliver"
    });
    await updateSession(businessId, session.id, { state: 'error' });
    await sendTextMessage(waId, "Erreur lors de la création de la facture. Réessayez.");
  }
}