gomag-vending/api/app/routers/sync.py

import asyncio
import json
import logging
from datetime import datetime

logger = logging.getLogger(__name__)

from fastapi import APIRouter, HTTPException, Request, BackgroundTasks
from fastapi.templating import Jinja2Templates
from fastapi.responses import HTMLResponse
from pydantic import BaseModel
from pathlib import Path
from typing import Optional

from ..services import sync_service, scheduler_service, sqlite_service, invoice_service, validation_service
from .. import database

router = APIRouter(tags=["sync"])
templates = Jinja2Templates(directory=str(Path(__file__).parent.parent / "templates"))


async def _enrich_items_with_codmat(items: list) -> None:
    """Enrich order items with codmat_details from ARTICOLE_TERTI + NOM_ARTICOLE fallback."""
    skus = {item["sku"] for item in items if item.get("sku")}
    if not skus:
        return
    codmat_map = await asyncio.to_thread(_get_articole_terti_for_skus, skus)
    for item in items:
        sku = item.get("sku")
        if sku and sku in codmat_map:
            item["codmat_details"] = codmat_map[sku]
    remaining_skus = {item["sku"] for item in items
                      if item.get("sku") and not item.get("codmat_details")}
    if remaining_skus:
        nom_map = await asyncio.to_thread(_get_nom_articole_for_direct_skus, remaining_skus)
        for item in items:
            sku = item.get("sku")
            if sku and sku in nom_map and not item.get("codmat_details"):
                item["codmat_details"] = [{"codmat": sku, "cantitate_roa": 1,
                                           "denumire": nom_map[sku], "direct": True}]


async def backfill_price_match():
    """Background task: check prices for all imported orders without cached price_match."""
    try:
        from ..database import get_sqlite
        db = await get_sqlite()
        try:
            cursor = await db.execute("""
                SELECT order_number FROM orders
                WHERE status IN ('IMPORTED', 'ALREADY_IMPORTED')
                  AND price_match IS NULL
                ORDER BY order_date DESC
            """)
            rows = [r["order_number"] for r in await cursor.fetchall()]
        finally:
            await db.close()

        if not rows:
            logger.info("backfill_price_match: no unchecked orders")
            return

        logger.info(f"backfill_price_match: checking {len(rows)} orders...")
        app_settings = await sqlite_service.get_app_settings()
        checked = 0

        for order_number in rows:
            try:
                detail = await sqlite_service.get_order_detail(order_number)
                if not detail:
                    continue
                items = detail.get("items", [])
                await _enrich_items_with_codmat(items)
                price_data = await asyncio.to_thread(
                    validation_service.get_prices_for_order, items, app_settings
                )
                summary = price_data.get("summary", {})
                if summary.get("oracle_available") is not False:
                    pm = summary.get("mismatches", 0) == 0
                    await sqlite_service.update_order_price_match(order_number, pm)
                    checked += 1
            except Exception as e:
                logger.debug(f"backfill_price_match: order {order_number} failed: {e}")

        logger.info(f"backfill_price_match: done, {checked}/{len(rows)} updated")
    except Exception as e:
        logger.error(f"backfill_price_match failed: {e}")


class ScheduleConfig(BaseModel):
    enabled: bool
    interval_minutes: int = 5


class AppSettingsUpdate(BaseModel):
    transport_codmat: str = ""
    transport_vat: str = "21"
    discount_codmat: str = ""
    transport_id_pol: str = ""
    discount_vat: str = "21"
    discount_id_pol: str = ""
    id_pol: str = ""
    id_pol_productie: str = ""
    id_sectie: str = ""
    id_gestiune: str = ""
    split_discount_vat: str = ""
    gomag_api_key: str = ""
    gomag_api_shop: str = ""
    gomag_order_days_back: str = "7"
    gomag_limit: str = "100"
    dashboard_poll_seconds: str = "5"
    kit_pricing_mode: str = ""
    kit_discount_codmat: str = ""
    kit_discount_id_pol: str = ""
    price_sync_enabled: str = "1"
    catalog_sync_enabled: str = "0"
    price_sync_schedule: str = ""
    gomag_products_url: str = ""


# API endpoints
@router.post("/api/sync/start")
async def start_sync(background_tasks: BackgroundTasks):
    """Trigger a sync run in the background."""
    result = await sync_service.prepare_sync()
    if result.get("error"):
        return {"error": result["error"], "run_id": result.get("run_id")}

    run_id = result["run_id"]
    background_tasks.add_task(sync_service.run_sync, run_id=run_id)
    return {"message": "Sync started", "run_id": run_id}


@router.post("/api/sync/stop")
async def stop_sync():
    """Stop a running sync."""
    sync_service.stop_sync()
    return {"message": "Stop signal sent"}


@router.get("/api/sync/status")
async def sync_status():
    """Get current sync status with progress details and last_run info."""
    status = await sync_service.get_sync_status()

    # Build last_run from most recent completed/failed sync_runs row
    current_run_id = status.get("run_id")
    is_running = status.get("status") == "running"
    last_run = None
    try:
        from ..database import get_sqlite
        db = await get_sqlite()
        try:
            if current_run_id and is_running:
                # Only exclude current run while it's actively running
                cursor = await db.execute("""
                    SELECT * FROM sync_runs
                    WHERE status IN ('completed', 'failed') AND run_id != ?
                    ORDER BY started_at DESC LIMIT 1
                """, (current_run_id,))
            else:
                cursor = await db.execute("""
                    SELECT * FROM sync_runs
                    WHERE status IN ('completed', 'failed')
                    ORDER BY started_at DESC LIMIT 1
                """)
            row = await cursor.fetchone()
            if row:
                row_dict = dict(row)
                duration_seconds = None
                if row_dict.get("started_at") and row_dict.get("finished_at"):
                    try:
                        dt_start = datetime.fromisoformat(row_dict["started_at"])
                        dt_end = datetime.fromisoformat(row_dict["finished_at"])
                        duration_seconds = int((dt_end - dt_start).total_seconds())
                    except (ValueError, TypeError):
                        pass
                last_run = {
                    "run_id": row_dict.get("run_id"),
                    "started_at": row_dict.get("started_at"),
                    "finished_at": row_dict.get("finished_at"),
                    "duration_seconds": duration_seconds,
                    "status": row_dict.get("status"),
                    "imported": row_dict.get("imported", 0),
                    "skipped": row_dict.get("skipped", 0),
                    "errors": row_dict.get("errors", 0),
                    "already_imported": row_dict.get("already_imported", 0),
                    "new_imported": row_dict.get("new_imported", 0),
                }
        finally:
            await db.close()
    except Exception:
        pass

    # Ensure all expected keys are present
    result = {
        "status": status.get("status", "idle"),
        "run_id": status.get("run_id"),
        "started_at": status.get("started_at"),
        "finished_at": status.get("finished_at"),
        "phase": status.get("phase"),
        "phase_text": status.get("phase_text"),
        "progress_current": status.get("progress_current", 0),
        "progress_total": status.get("progress_total", 0),
        "counts": status.get("counts", {"imported": 0, "skipped": 0, "errors": 0}),
        "last_run": last_run,
    }
    return result


@router.get("/api/sync/history")
async def sync_history(page: int = 1, per_page: int = 20):
    """Get sync run history."""
    return await sqlite_service.get_sync_runs(page, per_page)


@router.post("/api/price-sync/start")
async def start_price_sync(background_tasks: BackgroundTasks):
    """Trigger manual catalog price sync."""
    from ..services import price_sync_service
    result = await price_sync_service.prepare_price_sync()
    if result.get("error"):
        return {"error": result["error"]}
    run_id = result["run_id"]
    background_tasks.add_task(price_sync_service.run_catalog_price_sync, run_id=run_id)
    return {"message": "Price sync started", "run_id": run_id}


@router.get("/api/price-sync/status")
async def price_sync_status():
    """Get current price sync status."""
    from ..services import price_sync_service
    return await price_sync_service.get_price_sync_status()


@router.get("/api/price-sync/history")
async def price_sync_history(page: int = 1, per_page: int = 20):
    """Get price sync run history."""
    return await sqlite_service.get_price_sync_runs(page, per_page)


@router.get("/logs", response_class=HTMLResponse)
async def logs_page(request: Request, run: str = None):
    return templates.TemplateResponse("logs.html", {"request": request, "selected_run": run or ""})


@router.get("/api/sync/run/{run_id}")
async def sync_run_detail(run_id: str):
    """Get details for a specific sync run."""
    detail = await sqlite_service.get_sync_run_detail(run_id)
    if not detail:
        return {"error": "Run not found"}
    return detail


@router.get("/api/sync/run/{run_id}/log")
async def sync_run_log(run_id: str):
    """Get detailed log per order for a sync run."""
    detail = await sqlite_service.get_sync_run_detail(run_id)
    if not detail:
        return {"error": "Run not found", "status_code": 404}
    orders = detail.get("orders", [])
    return {
        "run_id": run_id,
        "run": detail.get("run", {}),
        "orders": [
            {
                "order_number": o.get("order_number"),
                "order_date": o.get("order_date"),
                "customer_name": o.get("customer_name"),
                "items_count": o.get("items_count"),
                "status": o.get("status"),
                "id_comanda": o.get("id_comanda"),
                "id_partener": o.get("id_partener"),
                "error_message": o.get("error_message"),
                "missing_skus": o.get("missing_skus"),
                "order_total": o.get("order_total"),
                "factura_numar": o.get("factura_numar"),
                "factura_serie": o.get("factura_serie"),
            }
            for o in orders
        ]
    }


def _format_text_log_from_detail(detail: dict) -> str:
    """Build a text log from SQLite stored data for completed runs."""
    run = detail.get("run", {})
    orders = detail.get("orders", [])

    run_id = run.get("run_id", "?")
    started = run.get("started_at", "")

    lines = [f"=== Sync Run {run_id} ==="]
    if started:
        try:
            dt = datetime.fromisoformat(started)
            lines.append(f"Inceput: {dt.strftime('%d.%m.%Y %H:%M:%S')}")
        except (ValueError, TypeError):
            lines.append(f"Inceput: {started}")
    lines.append("")

    for o in orders:
        status = (o.get("status") or "").upper()
        number = o.get("order_number", "?")
        customer = o.get("customer_name", "?")
        order_date = o.get("order_date") or "?"

        if status == "IMPORTED":
            id_cmd = o.get("id_comanda", "?")
            lines.append(f"#{number} [{order_date}] {customer} → IMPORTAT (ID: {id_cmd})")
        elif status == "ALREADY_IMPORTED":
            id_cmd = o.get("id_comanda", "?")
            lines.append(f"#{number} [{order_date}] {customer} → DEJA IMPORTAT (ID: {id_cmd})")
        elif status == "SKIPPED":
            missing = o.get("missing_skus", "")
            if isinstance(missing, str):
                try:
                    missing = json.loads(missing)
                except (json.JSONDecodeError, TypeError):
                    missing = [missing] if missing else []
            skus_str = ", ".join(missing) if isinstance(missing, list) else str(missing)
            lines.append(f"#{number} [{order_date}] {customer} → OMIS (lipsa: {skus_str})")
        elif status == "ERROR":
            err = o.get("error_message", "necunoscuta")
            lines.append(f"#{number} [{order_date}] {customer} → EROARE: {err}")

    # Summary line
    lines.append("")
    total = run.get("total_orders", 0)
    imported = run.get("imported", 0)
    skipped = run.get("skipped", 0)
    errors = run.get("errors", 0)

    duration_str = ""
    finished = run.get("finished_at", "")
    if started and finished:
        try:
            dt_start = datetime.fromisoformat(started)
            dt_end = datetime.fromisoformat(finished)
            secs = int((dt_end - dt_start).total_seconds())
            duration_str = f" | Durata: {secs}s"
        except (ValueError, TypeError):
            pass

    already = run.get("already_imported", 0)
    new_imp = run.get("new_imported", 0)
    if already:
        lines.append(f"Finalizat: {new_imp} importate, {already} deja importate, {skipped} nemapate, {errors} erori din {total} comenzi{duration_str}")
    else:
        lines.append(f"Finalizat: {imported} importate, {skipped} nemapate, {errors} erori din {total} comenzi{duration_str}")

    return "\n".join(lines)


@router.get("/api/sync/run/{run_id}/text-log")
async def sync_run_text_log(run_id: str):
    """Get text log for a sync run - live from memory or reconstructed from SQLite."""
    # Check in-memory first (active/recent runs)
    live_log = sync_service.get_run_text_log(run_id)
    if live_log is not None:
        status = "running"
        current = await sync_service.get_sync_status()
        if current.get("run_id") != run_id or current.get("status") != "running":
            status = "completed"
        return {"text": live_log, "status": status, "finished": status != "running"}

    # Fall back to SQLite for historical runs
    detail = await sqlite_service.get_sync_run_detail(run_id)
    if not detail:
        return {"error": "Run not found", "text": "", "status": "unknown", "finished": True}

    run = detail.get("run", {})
    text = _format_text_log_from_detail(detail)
    status = run.get("status", "completed")
    return {"text": text, "status": status, "finished": True}


@router.get("/api/sync/run/{run_id}/orders")
async def sync_run_orders(run_id: str, status: str = "all", page: int = 1, per_page: int = 50,
                          sort_by: str = "order_date", sort_dir: str = "desc"):
    """Get filtered, paginated orders for a sync run (R1)."""
    return await sqlite_service.get_run_orders_filtered(run_id, status, page, per_page,
                                                         sort_by=sort_by, sort_dir=sort_dir)


def _get_articole_terti_for_skus(skus: set) -> dict:
    """Query ARTICOLE_TERTI for all active codmat/cantitate per SKU."""
    from .. import database
    result = {}
    sku_list = list(skus)
    conn = database.get_oracle_connection()
    try:
        with conn.cursor() as cur:
            for i in range(0, len(sku_list), 500):
                batch = sku_list[i:i+500]
                placeholders = ",".join([f":s{j}" for j in range(len(batch))])
                params = {f"s{j}": sku for j, sku in enumerate(batch)}
                cur.execute(f"""
                    SELECT at.sku, at.codmat, at.cantitate_roa,
                           na.denumire
                    FROM ARTICOLE_TERTI at
                    LEFT JOIN NOM_ARTICOLE na ON na.codmat = at.codmat AND na.sters = 0 AND na.inactiv = 0
                    WHERE at.sku IN ({placeholders}) AND at.activ = 1 AND at.sters = 0
                    ORDER BY at.sku, at.codmat
                """, params)
                for row in cur:
                    sku = row[0]
                    if sku not in result:
                        result[sku] = []
                    result[sku].append({
                        "codmat": row[1],
                        "cantitate_roa": float(row[2]) if row[2] else 1,
                        "denumire": row[3] or ""
                    })
    finally:
        database.pool.release(conn)
    return result


def _get_nom_articole_for_direct_skus(skus: set) -> dict:
    """Query NOM_ARTICOLE for SKUs that exist directly as CODMAT (direct mapping)."""
    from .. import database
    result = {}
    sku_list = list(skus)
    conn = database.get_oracle_connection()
    try:
        with conn.cursor() as cur:
            for i in range(0, len(sku_list), 500):
                batch = sku_list[i:i+500]
                placeholders = ",".join([f":s{j}" for j in range(len(batch))])
                params = {f"s{j}": sku for j, sku in enumerate(batch)}
                cur.execute(f"""
                    SELECT codmat, denumire FROM NOM_ARTICOLE
                    WHERE codmat IN ({placeholders}) AND sters = 0 AND inactiv = 0
                """, params)
                for row in cur:
                    result[row[0]] = row[1] or ""
    finally:
        database.pool.release(conn)
    return result


@router.get("/api/sync/order/{order_number}")
async def order_detail(order_number: str):
    """Get order detail with line items (R9), enriched with ARTICOLE_TERTI data."""
    detail = await sqlite_service.get_order_detail(order_number)
    if not detail:
        return {"error": "Order not found"}

    items = detail.get("items", [])
    await _enrich_items_with_codmat(items)

    # Price comparison against ROA Oracle
    app_settings = await sqlite_service.get_app_settings()
    try:
        price_data = await asyncio.to_thread(
            validation_service.get_prices_for_order, items, app_settings
        )
        price_items = price_data.get("items", {})
        for idx, item in enumerate(items):
            pi = price_items.get(idx)
            if pi:
                item["pret_roa"] = pi.get("pret_roa")
                item["price_match"] = pi.get("match")
                if pi.get("kit"):
                    item["kit"] = True
                if pi.get("quantity_discount"):
                    item["quantity_discount"] = True
                    item["baseprice"] = pi.get("baseprice")
        order_price_check = price_data.get("summary", {})
        # Cache price_match in SQLite if changed
        if order_price_check.get("oracle_available") is not False:
            pm = order_price_check.get("mismatches", 0) == 0
            cached = detail.get("order", {}).get("price_match")
            cached_bool = True if cached == 1 else (False if cached == 0 else None)
            if cached_bool != pm:
                await sqlite_service.update_order_price_match(order_number, pm)
    except Exception as e:
        logger.warning(f"Price comparison failed for order {order_number}: {e}")
        order_price_check = {"mismatches": 0, "checked": 0, "oracle_available": False}

    # Enrich with invoice data
    order = detail.get("order", {})
    order["price_check"] = order_price_check
    if order.get("factura_numar") and order.get("factura_data"):
        order["invoice"] = {
            "facturat": True,
            "serie_act": order.get("factura_serie"),
            "numar_act": order.get("factura_numar"),
            "data_act": order.get("factura_data"),
            "total_fara_tva": order.get("factura_total_fara_tva"),
            "total_tva": order.get("factura_total_tva"),
            "total_cu_tva": order.get("factura_total_cu_tva"),
        }
    elif order.get("id_comanda"):
        # Check Oracle live
        try:
            inv_data = await asyncio.to_thread(
                invoice_service.check_invoices_for_orders, [order["id_comanda"]]
            )
            inv = inv_data.get(order["id_comanda"])
            if inv and inv.get("facturat"):
                order["invoice"] = inv
                await sqlite_service.update_order_invoice(
                    order_number,
                    serie=inv.get("serie_act"),
                    numar=str(inv.get("numar_act", "")),
                    total_fara_tva=inv.get("total_fara_tva"),
                    total_tva=inv.get("total_tva"),
                    total_cu_tva=inv.get("total_cu_tva"),
                    data_act=inv.get("data_act"),
                )
        except Exception:
            pass

    # Invoice reconciliation
    inv = order.get("invoice")
    if inv and inv.get("facturat") and inv.get("total_cu_tva") is not None:
        order_total = float(order.get("order_total") or 0)
        inv_total = float(inv["total_cu_tva"])
        difference = round(inv_total - order_total, 2)
        inv["reconciliation"] = {
            "order_total": order_total,
            "invoice_total": inv_total,
            "difference": difference,
            "match": abs(difference) < 0.01,
        }

    # Parse discount_split JSON string
    if order.get("discount_split"):
        try:
            order["discount_split"] = json.loads(order["discount_split"])
        except (json.JSONDecodeError, TypeError):
            pass

    # Partner info
    order["partner_info"] = {
        "cod_fiscal_gomag": order.get("cod_fiscal_gomag"),
        "cod_fiscal_roa": order.get("cod_fiscal_roa"),
        "denumire_roa": order.get("denumire_roa"),
        "anaf_platitor_tva": order.get("anaf_platitor_tva"),
        "anaf_checked_at": order.get("anaf_checked_at"),
        "anaf_cod_fiscal_adjusted": order.get("anaf_cod_fiscal_adjusted") == 1,
        "anaf_denumire_mismatch": order.get("anaf_denumire_mismatch") == 1,
        "denumire_anaf": order.get("denumire_anaf"),
    }
    # Parse JSON address strings
    for key in ("adresa_livrare_gomag", "adresa_facturare_gomag",
                "adresa_livrare_roa", "adresa_facturare_roa"):
        val = order.get(key)
        if val and isinstance(val, str):
            try:
                order[key] = json.loads(val)
            except (json.JSONDecodeError, TypeError):
                pass
    order["addresses"] = {
        "livrare_gomag": order.get("adresa_livrare_gomag"),
        "facturare_gomag": order.get("adresa_facturare_gomag"),
        "livrare_roa": order.get("adresa_livrare_roa"),
        "facturare_roa": order.get("adresa_facturare_roa"),
    }

    # Add settings for receipt display (app_settings already fetched above)
    order["transport_vat"] = app_settings.get("transport_vat") or "21"
    order["transport_codmat"] = app_settings.get("transport_codmat") or ""
    order["discount_codmat"] = app_settings.get("discount_codmat") or ""

    return detail


@router.post("/api/orders/{order_number}/retry")
async def retry_order(order_number: str):
    """Retry importing a failed/skipped order."""
    from ..services import retry_service

    app_settings = await sqlite_service.get_app_settings()
    result = await retry_service.retry_single_order(order_number, app_settings)
    return result


@router.get("/api/orders/by-sku/{sku}/pending")
async def get_pending_orders_for_sku(sku: str):
    """Get SKIPPED orders that contain the given SKU."""
    order_numbers = await sqlite_service.get_skipped_orders_with_sku(sku)
    return {"sku": sku, "order_numbers": order_numbers, "count": len(order_numbers)}


@router.post("/api/orders/batch-retry")
async def batch_retry_orders(request: Request):
    """Batch retry multiple orders."""
    from ..services import retry_service
    body = await request.json()
    order_numbers = body.get("order_numbers", [])
    if not order_numbers:
        return {"success": False, "message": "No orders specified"}

    app_settings = await sqlite_service.get_app_settings()
    results = {"imported": 0, "errors": 0, "messages": []}

    for on in order_numbers[:20]:  # Limit to 20 to avoid timeout
        result = await retry_service.retry_single_order(str(on), app_settings)
        if result.get("success"):
            results["imported"] += 1
        else:
            results["errors"] += 1
            results["messages"].append(f"{on}: {result.get('message', 'Error')}")

    return {
        "success": results["imported"] > 0,
        "imported": results["imported"],
        "errors": results["errors"],
        "message": f"{results['imported']} importate, {results['errors']} erori" if results["errors"] else f"{results['imported']} importate cu succes",
        "details": results["messages"][:5],
    }


@router.get("/api/dashboard/orders")
async def dashboard_orders(page: int = 1, per_page: int = 50,
                           search: str = "", status: str = "all",
                           sort_by: str = "order_date", sort_dir: str = "desc",
                           period_days: int = 7,
                           period_start: str = "", period_end: str = ""):
    """Get orders for dashboard, enriched with invoice data.

    period_days=0 with period_start/period_end uses custom date range.
    period_days=0 without dates means all time.
    """
    is_uninvoiced_filter = (status == "UNINVOICED")
    is_invoiced_filter = (status == "INVOICED")

    # For UNINVOICED/INVOICED: fetch all IMPORTED orders, then filter post-invoice-check
    fetch_status = "IMPORTED" if (is_uninvoiced_filter or is_invoiced_filter) else status
    fetch_per_page = 10000 if (is_uninvoiced_filter or is_invoiced_filter) else per_page
    fetch_page = 1 if (is_uninvoiced_filter or is_invoiced_filter) else page

    result = await sqlite_service.get_orders(
        page=fetch_page, per_page=fetch_per_page, search=search,
        status_filter=fetch_status, sort_by=sort_by, sort_dir=sort_dir,
        period_days=period_days,
        period_start=period_start if period_days == 0 else "",
        period_end=period_end if period_days == 0 else "",
    )

    # Enrich orders with invoice data — prefer SQLite cache, fallback to Oracle
    all_orders = result["orders"]
    for o in all_orders:
        # price_match: 1=OK, 0=mismatch, NULL=not checked yet
        pm = o.get("price_match")
        o["price_match"] = True if pm == 1 else (False if pm == 0 else None)
        if o.get("factura_numar") and o.get("factura_data"):
            # Use cached invoice data from SQLite (only if complete)
            o["invoice"] = {
                "facturat": True,
                "serie_act": o.get("factura_serie"),
                "numar_act": o.get("factura_numar"),
                "total_fara_tva": o.get("factura_total_fara_tva"),
                "total_tva": o.get("factura_total_tva"),
                "total_cu_tva": o.get("factura_total_cu_tva"),
                "data_act": o.get("factura_data"),
            }
        else:
            o["invoice"] = None

    # For orders without cached invoice, check Oracle (only uncached imported orders)
    uncached_orders = [o for o in all_orders if o.get("id_comanda") and not o.get("invoice")]
    if uncached_orders:
        try:
            id_comanda_list = [o["id_comanda"] for o in uncached_orders]
            invoice_data = await asyncio.to_thread(
                invoice_service.check_invoices_for_orders, id_comanda_list
            )
            for o in uncached_orders:
                idc = o.get("id_comanda")
                if idc and idc in invoice_data:
                    o["invoice"] = invoice_data[idc]
                    # Update SQLite cache so counts stay accurate
                    inv = invoice_data[idc]
                    if inv.get("facturat"):
                        await sqlite_service.update_order_invoice(
                            o["order_number"],
                            serie=inv.get("serie_act"),
                            numar=str(inv.get("numar_act", "")),
                            total_fara_tva=inv.get("total_fara_tva"),
                            total_tva=inv.get("total_tva"),
                            total_cu_tva=inv.get("total_cu_tva"),
                            data_act=inv.get("data_act"),
                        )
        except Exception:
            pass

        # Add shipping/billing name fields + is_different_person flag
        s_name = o.get("shipping_name") or ""
        b_name = o.get("billing_name") or ""
        o["shipping_name"] = s_name
        o["billing_name"] = b_name
        o["is_different_person"] = bool(s_name and b_name and s_name != b_name)

    # Use counts from sqlite_service (already period-scoped)
    counts = result.get("counts", {})
    # Adjust uninvoiced count for invoices discovered via Oracle during this request
    newly_invoiced = sum(1 for o in uncached_orders if o.get("invoice") and o["invoice"].get("facturat"))
    uninvoiced_base = counts.get("uninvoiced_sqlite", sum(
        1 for o in all_orders
        if o.get("status") in ("IMPORTED", "ALREADY_IMPORTED") and not o.get("invoice")
    ))
    counts["nefacturate"] = max(0, uninvoiced_base - newly_invoiced)
    imported_total = counts.get("imported_all") or counts.get("imported", 0)
    counts["facturate"] = max(0, imported_total - counts["nefacturate"])
    counts.setdefault("total", counts.get("imported", 0) + counts.get("skipped", 0) + counts.get("error", 0))

    # Attention metrics: add unresolved SKUs count
    try:
        stats = await sqlite_service.get_dashboard_stats()
        counts["unresolved_skus"] = stats.get("unresolved_skus", 0)
    except Exception:
        counts["unresolved_skus"] = 0

    # Address quality: count orders with incomplete ROA addresses
    try:
        addr_count = await sqlite_service.get_incomplete_addresses_count()
        if addr_count == -1:  # stale cache — skip
            counts["incomplete_addresses"] = 0
        else:
            counts["incomplete_addresses"] = addr_count
    except Exception:
        counts["incomplete_addresses"] = 0

    # For UNINVOICED filter: apply server-side filtering + pagination
    if is_uninvoiced_filter:
        filtered = [o for o in all_orders if o.get("status") in ("IMPORTED", "ALREADY_IMPORTED") and not o.get("invoice")]
        total = len(filtered)
        offset = (page - 1) * per_page
        result["orders"] = filtered[offset:offset + per_page]
        result["total"] = total
        result["page"] = page
        result["per_page"] = per_page
        result["pages"] = (total + per_page - 1) // per_page if total > 0 else 0
    elif is_invoiced_filter:
        filtered = [o for o in all_orders if o.get("status") in ("IMPORTED", "ALREADY_IMPORTED") and o.get("invoice")]
        total = len(filtered)
        offset = (page - 1) * per_page
        result["orders"] = filtered[offset:offset + per_page]
        result["total"] = total
        result["page"] = page
        result["per_page"] = per_page
        result["pages"] = (total + per_page - 1) // per_page if total > 0 else 0

    # Reshape response
    return {
        "orders": result["orders"],
        "pagination": {
            "page": result.get("page", page),
            "per_page": result.get("per_page", per_page),
            "total_pages": result.get("pages", 0),
        },
        "counts": counts,
    }


@router.post("/api/dashboard/refresh-invoices")
async def refresh_invoices():
    """Force-refresh invoice/order status from Oracle.

    Checks:
    1. Uninvoiced orders → did they get invoiced?
    2. Invoiced orders → was the invoice deleted?
    3. All imported orders → was the order deleted from ROA?
    """
    try:
        invoices_added = 0
        invoices_cleared = 0
        orders_deleted = 0

        # 1. Check uninvoiced → new invoices
        uninvoiced = await sqlite_service.get_uninvoiced_imported_orders()
        if uninvoiced:
            id_comanda_list = [o["id_comanda"] for o in uninvoiced]
            invoice_data = await asyncio.to_thread(
                invoice_service.check_invoices_for_orders, id_comanda_list
            )
            id_to_order = {o["id_comanda"]: o["order_number"] for o in uninvoiced}
            for idc, inv in invoice_data.items():
                order_num = id_to_order.get(idc)
                if order_num and inv.get("facturat"):
                    await sqlite_service.update_order_invoice(
                        order_num,
                        serie=inv.get("serie_act"),
                        numar=str(inv.get("numar_act", "")),
                        total_fara_tva=inv.get("total_fara_tva"),
                        total_tva=inv.get("total_tva"),
                        total_cu_tva=inv.get("total_cu_tva"),
                        data_act=inv.get("data_act"),
                    )
                    invoices_added += 1

        # 2. Check invoiced → deleted invoices
        invoiced = await sqlite_service.get_invoiced_imported_orders()
        if invoiced:
            id_comanda_list = [o["id_comanda"] for o in invoiced]
            invoice_data = await asyncio.to_thread(
                invoice_service.check_invoices_for_orders, id_comanda_list
            )
            for o in invoiced:
                if o["id_comanda"] not in invoice_data:
                    await sqlite_service.clear_order_invoice(o["order_number"])
                    invoices_cleared += 1

        # 3. Check all imported → deleted orders in ROA
        all_imported = await sqlite_service.get_all_imported_orders()
        if all_imported:
            id_comanda_list = [o["id_comanda"] for o in all_imported]
            existing_ids = await asyncio.to_thread(
                invoice_service.check_orders_exist, id_comanda_list
            )
            for o in all_imported:
                if o["id_comanda"] not in existing_ids:
                    await sqlite_service.mark_order_deleted_in_roa(o["order_number"])
                    orders_deleted += 1

        # Cherry-pick A: Batch refresh Oracle addresses for all orders with stored address IDs
        addr_rows = await sqlite_service.get_orders_with_address_ids()
        if addr_rows:
            def _fetch_addresses(rows):
                unique_ids = list(
                    {r["id_adresa_livrare"] for r in rows if r.get("id_adresa_livrare")}
                    | {r["id_adresa_facturare"] for r in rows if r.get("id_adresa_facturare")}
                )
                conn = database.get_oracle_connection()
                try:
                    with conn.cursor() as cur:
                        placeholders = ",".join([f":{i}" for i in range(len(unique_ids))])
                        cur.execute(
                            f"SELECT id_adresa, strada, numar, bloc, scara, apart, etaj, localitate, judet"
                            f" FROM vadrese_parteneri WHERE id_adresa IN ({placeholders})",
                            unique_ids,
                        )
                        return {row[0]: row for row in cur.fetchall()}
                finally:
                    database.pool.release(conn)

            try:
                addr_map = await asyncio.to_thread(_fetch_addresses, addr_rows)

                def _row_to_dict(r):
                    return {"strada": r[1], "numar": r[2], "bloc": r[3], "scara": r[4],
                            "apart": r[5], "etaj": r[6], "localitate": r[7], "judet": r[8]}

                addresses_refreshed = 0
                for row in addr_rows:
                    livr_id = row.get("id_adresa_livrare")
                    fact_id = row.get("id_adresa_facturare")
                    livr_raw = addr_map.get(livr_id)
                    fact_raw = addr_map.get(fact_id) if fact_id and fact_id != livr_id else livr_raw
                    if not livr_raw:
                        continue
                    livr_roa = _row_to_dict(livr_raw)
                    fact_roa = _row_to_dict(fact_raw) if fact_raw else livr_roa
                    mismatch = not sync_service._addr_match(
                        row.get("adresa_livrare_gomag"), json.dumps(livr_roa)
                    )
                    await sqlite_service.update_order_address_cache(
                        row["order_number"], livr_roa, fact_roa, mismatch
                    )
                    addresses_refreshed += 1
                logger.info(f"refresh_invoices: refreshed {addresses_refreshed} order addresses from Oracle")
            except Exception as addr_err:
                logger.warning(f"refresh_invoices: address batch refresh failed: {addr_err}")

        checked = len(uninvoiced) + len(invoiced) + len(all_imported)
        return {
            "checked": checked,
            "invoices_added": invoices_added,
            "invoices_cleared": invoices_cleared,
            "orders_deleted": orders_deleted,
        }
    except Exception as e:
        return {"error": str(e), "invoices_added": 0}


@router.post("/api/orders/{order_number}/refresh-address")
async def refresh_order_address(order_number: str):
    """Re-fetch ROA address from Oracle for an existing order and update SQLite cache."""
    row = await sqlite_service.get_order_address_ids(order_number)
    if not row:
        raise HTTPException(status_code=404, detail="Order not found")

    id_livr = row.get("id_adresa_livrare")
    id_fact = row.get("id_adresa_facturare")

    if not id_livr and not id_fact:
        raise HTTPException(status_code=422, detail="Order has no Oracle address IDs")

    def _fetch():
        conn = database.get_oracle_connection()
        try:
            with conn.cursor() as cur:
                def fetch_one(id_adresa):
                    if not id_adresa:
                        return None
                    cur.execute(
                        "SELECT strada, numar, bloc, scara, apart, etaj, localitate, judet"
                        " FROM vadrese_parteneri WHERE id_adresa = :1",
                        [id_adresa],
                    )
                    r = cur.fetchone()
                    if not r:
                        return None
                    return {"strada": r[0], "numar": r[1], "bloc": r[2], "scara": r[3],
                            "apart": r[4], "etaj": r[5], "localitate": r[6], "judet": r[7]}

                livr = fetch_one(id_livr)
                fact = fetch_one(id_fact) if id_fact and id_fact != id_livr else livr
                return livr, fact
        finally:
            database.pool.release(conn)

    try:
        livr_roa, fact_roa = await asyncio.to_thread(_fetch)
    except Exception as e:
        raise HTTPException(status_code=503, detail=f"Oracle unavailable: {e}")

    old_livr = row.get("adresa_livrare_roa")
    mismatch = not sync_service._addr_match(
        row.get("adresa_livrare_gomag"), json.dumps(livr_roa)
    ) if livr_roa else True

    if livr_roa:
        old_strada = json.loads(old_livr or "{}").get("strada", "?")
        logger.info(
            f"refresh_address: {order_number} strada {old_strada!r}→{livr_roa['strada']!r} mismatch→{mismatch}"
        )

    await sqlite_service.update_order_address_cache(order_number, livr_roa, fact_roa, mismatch)
    return {"adresa_livrare_roa": livr_roa, "adresa_facturare_roa": fact_roa, "address_mismatch": mismatch}


@router.put("/api/sync/schedule")
async def update_schedule(config: ScheduleConfig):
    """Update scheduler configuration."""
    if config.enabled:
        scheduler_service.start_scheduler(config.interval_minutes)
    else:
        scheduler_service.stop_scheduler()

    # Persist config
    await sqlite_service.set_scheduler_config("enabled", str(config.enabled))
    await sqlite_service.set_scheduler_config("interval_minutes", str(config.interval_minutes))

    return scheduler_service.get_scheduler_status()


@router.get("/api/sync/schedule")
async def get_schedule():
    """Get current scheduler status (falls back to DB for interval)."""
    status = scheduler_service.get_scheduler_status()
    if status["interval_minutes"] is None:
        config = await sqlite_service.get_scheduler_config()
        status["interval_minutes"] = int(config.get("interval_minutes", "10"))
    return status


@router.get("/api/settings")
async def get_app_settings():
    """Get application settings."""
    from ..config import settings as config_settings
    s = await sqlite_service.get_app_settings()
    return {
        "transport_codmat": s.get("transport_codmat", ""),
        "transport_vat": s.get("transport_vat", "21"),
        "discount_codmat": s.get("discount_codmat", ""),
        "transport_id_pol": s.get("transport_id_pol", ""),
        "discount_vat": s.get("discount_vat", "21"),
        "discount_id_pol": s.get("discount_id_pol", ""),
        "id_pol": s.get("id_pol", ""),
        "id_pol_productie": s.get("id_pol_productie", ""),
        "id_sectie": s.get("id_sectie", ""),
        "id_gestiune": s.get("id_gestiune", ""),
        "split_discount_vat": s.get("split_discount_vat", ""),
        "gomag_api_key": s.get("gomag_api_key", "") or config_settings.GOMAG_API_KEY,
        "gomag_api_shop": s.get("gomag_api_shop", "") or config_settings.GOMAG_API_SHOP,
        "gomag_order_days_back": s.get("gomag_order_days_back", "") or str(config_settings.GOMAG_ORDER_DAYS_BACK),
        "gomag_limit": s.get("gomag_limit", "") or str(config_settings.GOMAG_LIMIT),
        "dashboard_poll_seconds": s.get("dashboard_poll_seconds", "5"),
        "kit_pricing_mode": s.get("kit_pricing_mode", ""),
        "kit_discount_codmat": s.get("kit_discount_codmat", ""),
        "kit_discount_id_pol": s.get("kit_discount_id_pol", ""),
        "price_sync_enabled": s.get("price_sync_enabled", "1"),
        "catalog_sync_enabled": s.get("catalog_sync_enabled", "0"),
        "price_sync_schedule": s.get("price_sync_schedule", ""),
        "gomag_products_url": s.get("gomag_products_url", ""),
    }


@router.put("/api/settings")
async def update_app_settings(config: AppSettingsUpdate):
    """Update application settings."""
    await sqlite_service.set_app_setting("transport_codmat", config.transport_codmat)
    await sqlite_service.set_app_setting("transport_vat", config.transport_vat)
    await sqlite_service.set_app_setting("discount_codmat", config.discount_codmat)
    await sqlite_service.set_app_setting("transport_id_pol", config.transport_id_pol)
    await sqlite_service.set_app_setting("discount_vat", config.discount_vat)
    await sqlite_service.set_app_setting("discount_id_pol", config.discount_id_pol)
    await sqlite_service.set_app_setting("id_pol", config.id_pol)
    await sqlite_service.set_app_setting("id_pol_productie", config.id_pol_productie)
    await sqlite_service.set_app_setting("id_sectie", config.id_sectie)
    await sqlite_service.set_app_setting("id_gestiune", config.id_gestiune)
    await sqlite_service.set_app_setting("split_discount_vat", config.split_discount_vat)
    await sqlite_service.set_app_setting("gomag_api_key", config.gomag_api_key)
    await sqlite_service.set_app_setting("gomag_api_shop", config.gomag_api_shop)
    await sqlite_service.set_app_setting("gomag_order_days_back", config.gomag_order_days_back)
    await sqlite_service.set_app_setting("gomag_limit", config.gomag_limit)
    await sqlite_service.set_app_setting("dashboard_poll_seconds", config.dashboard_poll_seconds)
    await sqlite_service.set_app_setting("kit_pricing_mode", config.kit_pricing_mode)
    await sqlite_service.set_app_setting("kit_discount_codmat", config.kit_discount_codmat)
    await sqlite_service.set_app_setting("kit_discount_id_pol", config.kit_discount_id_pol)
    await sqlite_service.set_app_setting("price_sync_enabled", config.price_sync_enabled)
    await sqlite_service.set_app_setting("catalog_sync_enabled", config.catalog_sync_enabled)
    await sqlite_service.set_app_setting("price_sync_schedule", config.price_sync_schedule)
    await sqlite_service.set_app_setting("gomag_products_url", config.gomag_products_url)
    return {"success": True}


@router.get("/api/settings/gestiuni")
async def get_gestiuni():
    """Get list of warehouses from Oracle for dropdown."""
    def _query():
        conn = database.get_oracle_connection()
        try:
            with conn.cursor() as cur:
                cur.execute(
                    "SELECT id_gestiune, nume_gestiune FROM nom_gestiuni WHERE sters=0 AND inactiv=0 ORDER BY id_gestiune"
                )
                return [{"id": str(row[0]), "label": f"{row[0]} - {row[1]}"} for row in cur]
        finally:
            database.pool.release(conn)
    try:
        return await asyncio.to_thread(_query)
    except Exception as e:
        logger.error(f"get_gestiuni error: {e}")
        return []


@router.get("/api/settings/sectii")
async def get_sectii():
    """Get list of sections from Oracle for dropdown."""
    def _query():
        conn = database.get_oracle_connection()
        try:
            with conn.cursor() as cur:
                cur.execute(
                    "SELECT id_sectie, sectie FROM nom_sectii WHERE sters=0 AND inactiv=0 ORDER BY id_sectie"
                )
                return [{"id": str(row[0]), "label": f"{row[0]} - {row[1]}"} for row in cur]
        finally:
            database.pool.release(conn)
    try:
        return await asyncio.to_thread(_query)
    except Exception as e:
        logger.error(f"get_sectii error: {e}")
        return []


@router.get("/api/settings/politici")
async def get_politici():
    """Get list of price policies from Oracle for dropdown."""
    def _query():
        conn = database.get_oracle_connection()
        try:
            with conn.cursor() as cur:
                cur.execute(
                    "SELECT id_pol, nume_lista_preturi FROM crm_politici_preturi WHERE sters=0 ORDER BY id_pol"
                )
                return [{"id": str(row[0]), "label": f"{row[0]} - {row[1]}"} for row in cur]
        finally:
            database.pool.release(conn)
    try:
        return await asyncio.to_thread(_query)
    except Exception as e:
        logger.error(f"get_politici error: {e}")
        return []