#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
analysisAI.py — pobiera dane z MySQL, liczy wyłącznie WSKAZANE preagregaty,
renderuje HTML i (opcjonalnie) dodaje analizę AI — tylko jeśli ją zaznaczysz.

Parametry CLI (z formularza PHP):
  --date-from YYYY-MM-DD
  --date-to   YYYY-MM-DD     (zamieniane wewnętrznie na +1 dzień, bo SQL ma warunek '< date_to')
  --metric    NAZWA          (można podać wiele razy: --metric a --metric b ...)
  --metrics   CSV            (opcjonalnie alternatywnie: --metrics a,b,c)
  --ai        true|false     (czy uruchomić analizę AI — tylko gdy są preagregaty z danymi)

Preagregaty:
  - kpis (aliasy: basic, basic_totals) — podstawowe KPI: sprzedaż, ilość, dokumenty, ASP
  - daily_sales, product_summary, customer_summary, product_daily,
    top10_products_by_sales, top10_customers_by_sales  (z preaggregates.py)
"""

import os, sys, json, math, time, warnings, argparse, traceback, html
from datetime import date, timedelta, datetime

# (1) Wycisza ostrzeżenia urllib3 (LibreSSL / stary OpenSSL)
try:
    from urllib3.exceptions import NotOpenSSLWarning
    warnings.filterwarnings("ignore", category=NotOpenSSLWarning)
except Exception:
    pass

# (2) Importy zewnętrzne
import requests
import mysql.connector
import pandas as pd

LOOKER_URL = "https://lookerstudio.google.com/u/0/reporting/107d4ccc-e7eb-4c38-8dce-00700b44f60e/page/ba1YF"

# ========== KONFIGURACJA KLUCZA AI ==========
API_KEY = "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"
API_KEY_HARDCODE = API_KEY

# === Import preagregatów ===
from preaggregates import serialize_for_ai
import preaggregates as pre  # pre.AGGREGATORS, pre.to_df

# ========== UTILKI ==========

def html_fatal(msg, title="Błąd"):
    sys.stdout.write(
        '<div style="font-family:system-ui,-apple-system,Segoe UI,Roboto,Arial,sans-serif;'
        'max-width:900px;margin:24px auto;padding:16px 20px;border:1px solid #fecaca;'
        'border-radius:12px;background:#fff5f5;color:#991b1b;">'
        f'<h3 style="margin:0 0 8px;font-size:18px;">{html.escape(title)}</h3>'
        f'<pre style="white-space:pre-wrap;margin:0;">{html.escape(msg)}</pre>'
        '</div>'
    )
    sys.exit(1)

def connect_html_or_die(cfg, label="MySQL"):
    try:
        return mysql.connector.connect(**cfg)
    except mysql.connector.Error as e:
        host = cfg.get("host"); port = cfg.get("port"); user = cfg.get("user")
        base = (f"[{label}] Błąd połączenia ({host}:{port} jako '{user}').\n"
                f"errno={getattr(e,'errno',None)} sqlstate={getattr(e,'sqlstate',None)}\n"
                f"msg={getattr(e,'msg',str(e))}")
        if os.environ.get("DEBUG"):
            base += "\n\n" + traceback.format_exc()
        html_fatal(base, title="Błąd połączenia MySQL")

def getenv(k, d=None):
    return os.environ.get(k, d)

def last_full_month_bounds():
    today_first = date.today().replace(day=1)
    to_dt = today_first
    prev_last = today_first - timedelta(days=1)
    from_dt = prev_last.replace(day=1)
    return from_dt.isoformat(), to_dt.isoformat()

def add_one_day(iso_date):
    try:
        return (datetime.strptime(iso_date, "%Y-%m-%d") + timedelta(days=1)).strftime("%Y-%m-%d")
    except Exception:
        return iso_date  # w razie czego oddaj wejście

def safe_num(v, ndigits=None):
    try:
        f = float(v)
        if not math.isfinite(f):
            return None
        return round(f, ndigits) if ndigits is not None else f
    except Exception:
        return None

def safe_date(v):
    if v is None:
        return None
    try:
        if hasattr(v, "date"):
            return str(v.date())
        s = str(v)
        if len(s) >= 10 and s[4] == '-' and s[7] == '-':
            return s[:10]
        return s
    except Exception:
        return None

def fmt_money(v):
    try:
        return "{:,.2f}".format(float(v)).replace(",", " ").replace(".", ",")
    except Exception:
        return str(v)

def compact_table(table, limit=30):
    out = []
    if not table:
        return out
    lim = int(limit)
    for i, row in enumerate(table):
        if i >= lim: break
        new = {}
        for k, v in row.items():
            if isinstance(v, float):
                new[k] = round(v, 6) if math.isfinite(v) else None
            else:
                new[k] = v
        out.append(new)
    return out

def call_openai_chat(api_key, model, system_prompt, user_payload_json,
                     temperature=0.3, connect_timeout=10, read_timeout=90, max_retries=3):
    url = "https://api.openai.com/v1/chat/completions"
    headers = {"Authorization": "Bearer " + api_key, "Content-Type": "application/json"}
    body = {
        "model": model,
        "messages": [
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": "Dane (JSON):\n\n" + user_payload_json},
        ],
        "temperature": temperature,
    }
    last_err = None
    for attempt in range(1, int(max_retries) + 1):
        try:
            r = requests.post(url, headers=headers, json=body, timeout=(connect_timeout, read_timeout))
            if 200 <= r.status_code < 300:
                data = r.json()
                return data.get("choices", [{}])[0].get("message", {}).get("content", "")
            last_err = RuntimeError("OpenAI HTTP {}: {}".format(r.status_code, r.text))
        except requests.exceptions.RequestException as e:
            last_err = e
        time.sleep(min(2 ** attempt, 10))
    raise RuntimeError("OpenAI request failed: {}".format(last_err))

def html_table(records, title=None, max_rows=20):
    if not records:
        return '<div class="empty">Brak danych</div>'
    cols = list(records[0].keys())
    body_rows = records[:max_rows]
    thead = "".join("<th>{}</th>".format(c) for c in cols)
    trs = []
    for r in body_rows:
        tds = []
        for c in cols:
            val = r.get(c, "")
            if isinstance(val, (int, float)):
                if any(x in c.lower() for x in ("sales", "total", "netto", "value", "asp", "qty", "quantity", "share", "change")):
                    tds.append('<td class="num">{}</td>'.format(fmt_money(val) if "sales" in c.lower() or "total" in c.lower() or "netto" in c.lower() else val))
                else:
                    tds.append('<td class="num">{}</td>'.format(val))
            else:
                tds.append('<td>{}</td>'.format(val))
        trs.append("<tr>{}</tr>".format("".join(tds)))
    cap = '<div class="tbl-title">{}</div>'.format(title) if title else ""
    return (
        cap +
        '<div class="tbl-wrap"><table class="tbl">'
        '<thead><tr>{}</tr></thead><tbody>{}</tbody></table></div>'.format(thead, "".join(trs))
    )

def render_report_html(period_label, kpis, parts, ai_section, model_alias):
    css = (
        "font-family:system-ui,-apple-system,Segoe UI,Roboto,Arial,sans-serif;"
        "max-width:1200px;margin:24px auto;padding:16px 20px;border:1px solid #e5e7eb;"
        "border-radius:12px;background:#fff;color:#111827"
    )
    kpi_item = (
        '<div class="kpi"><div class="kpi-label">{label}</div>'
        '<div class="kpi-value">{value}</div></div>'
    )
    kpi_html = "".join(kpi_item.format(label=lbl, value=val) for (lbl, val) in kpis)
    sections_html = "".join(parts)
    if ai_section and not ai_section.lstrip().startswith("<div"):
        ai_section = '<div class="ai-section">{}</div>'.format(ai_section)

    return f"""
<div style="{css}">
  <h2 style="margin:0 0 12px;font-size:22px;">Raport sprzedaży — {period_label}</h2>
  <div style="display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:12px;margin:12px 0 20px;">
    {kpi_html}
  </div>
  {sections_html if sections_html.strip() else '<div class="empty">Nie wybrano żadnych preagregatów — brak sekcji do wyświetlenia.</div>'}
  <div style="margin-top:20px;border-top:1px solid #e5e7eb;padding-top:16px;">
    <h3 style="margin:0 0 8px;font-size:18px;">Analiza i rekomendacje{(' (AI · ' + model_alias + ')') if model_alias else ''}</h3>
    {ai_section if ai_section else '<div style="color:#6b7280">Analiza AI wyłączona lub brak danych.</div>'}
  </div>

  <!-- STOPKA z linkiem do Looker Studio -->
  <div style="margin-top:20px;border-top:1px dashed #e5e7eb;padding-top:12px;display:flex;justify-content:flex-end;">
    <a href="{LOOKER_URL}" target="_blank" rel="noopener"
       style="text-decoration:none;padding:8px 12px;border:1px solid #d1d5db;border-radius:8px;
              background:#f9fafb;color:#111827;font-weight:600;">
      → Otwórz pełny raport w Looker Studio
    </a>
  </div>
</div>
<style>
  .kpi {{background:#f8fafc;border:1px solid #e5e7eb;border-radius:10px;padding:12px;}}
  .kpi-label {{font-size:12px;color:#6b7280;margin-bottom:4px;}}
  .kpi-value {{font-size:18px;font-weight:700;}}
  .tbl-title {{font-weight:600;margin:16px 0 8px;font-size:15px;}}
  .tbl-wrap {{overflow-x:auto;border:1px solid #e5e7eb;border-radius:8px;}}
  .tbl {{border-collapse:collapse;width:100%;font-size:14px;}}
  .tbl thead th {{text-align:left;background:#f3f4f6;padding:8px;border-bottom:1px solid #e5e7eb;white-space:nowrap;}}
  .tbl tbody td {{padding:8px;border-bottom:1px solid #f3f4f6;vertical-align:top;}}
  .tbl td.num {{text-align:right;white-space:nowrap;}}
  .empty {{color:#6b7280;font-style:italic;margin:8px 0;}}
  .ai-section {{background:#f8fafc;border:1px solid #e5e7eb;border-radius:10px;padding:12px;}}
</style>
"""


# ========== UPSerTY DO REPORTING (jak u Ciebie) ==========

def _ensure_rank_and_share(items, key_sales="sales"):
    if not items: return
    total_sales = sum((x.get(key_sales) or 0) for x in items)
    sorted_items = sorted(
        items,
        key=lambda x: ((x.get(key_sales) or 0), str(x.get("product_code") or x.get("customer_name") or "")),
        reverse=True
    )
    rank_map, rank = {}, 1
    for x in sorted_items:
        key = x.get("product_code") or x.get("customer_name") or ""
        if key not in rank_map:
            rank_map[key] = rank
            rank += 1
    for x in items:
        key = x.get("product_code") or x.get("customer_name") or ""
        if not x.get("rank_in_period"):
            x["rank_in_period"] = rank_map.get(key, 0)
        if "mix_share_sales" not in x:
            x["mix_share_sales"] = ((x.get(key_sales) or 0) / total_sales) if total_sales else 0.0

def upsert_daily_sales(cur, daily):
    if not daily: return 0
    sql = """
    INSERT INTO reporting_daily_sales
      (period_date, qty, sales, docs, asp, sales_rolling7, sales_dod_pct)
    VALUES (%s,%s,%s,%s,%s,%s,%s)
    ON DUPLICATE KEY UPDATE
      qty=VALUES(qty), sales=VALUES(sales), docs=VALUES(docs),
      asp=VALUES(asp), sales_rolling7=VALUES(sales_rolling7), sales_dod_pct=VALUES(sales_dod_pct),
      generated_at=CURRENT_TIMESTAMP
    """
    rows = []
    for r in daily:
        period_date = safe_date(r.get("register_date") or r.get("period_date") or r.get("date"))
        rows.append((
            period_date,
            safe_num(r.get("qty")),
            safe_num(r.get("sales")),
            safe_num(r.get("docs")),
            safe_num(r.get("asp"), 6),
            safe_num(r.get("sales_rolling7"), 6),
            safe_num(r.get("sales_pct_change_dod") or r.get("sales_dod_pct"), 6),
        ))
    cur.executemany(sql, rows)
    return len(rows)

def upsert_product_summary(cur, prod, period_from, period_to):
    if not prod: return 0
    _ensure_rank_and_share(prod, key_sales="sales")
    sql = """
    INSERT INTO reporting_product_summary
      (period_start, period_end, product_code, product_name, qty, sales, docs,
       asp_weighted, mix_share_sales, rank_in_period)
    VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)
    ON DUPLICATE KEY UPDATE
      qty=VALUES(qty), sales=VALUES(sales), docs=VALUES(docs),
      asp_weighted=VALUES(asp_weighted), mix_share_sales=VALUES(mix_share_sales),
      rank_in_period=VALUES(rank_in_period), generated_at=CURRENT_TIMESTAMP
    """
    rows = []
    for r in prod:
        rows.append((
            period_from, period_to,
            r.get("product_code"), r.get("product_name"),
            safe_num(r.get("qty")),
            safe_num(r.get("sales")),
            safe_num(r.get("docs")),
            safe_num(r.get("asp_weighted"), 6),
            safe_num(r.get("mix_share_sales"), 6),
            int(r.get("rank_in_period") or 0),
        ))
    cur.executemany(sql, rows)
    return len(rows)

def upsert_customer_summary(cur, cust, period_from, period_to):
    if not cust: return 0
    _ensure_rank_and_share(cust, key_sales="sales")
    sql = """
    INSERT INTO reporting_customer_summary
      (period_start, period_end, customer_name, qty, sales, docs,
       asp_weighted, mix_share_sales, rank_in_period)
    VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s)
    ON DUPLICATE KEY UPDATE
      qty=VALUES(qty), sales=VALUES(sales), docs=VALUES(docs),
      asp_weighted=VALUES(asp_weighted), mix_share_sales=VALUES(mix_share_sales),
      rank_in_period=VALUES(rank_in_period), generated_at=CURRENT_TIMESTAMP
    """
    rows = []
    for r in cust:
        rows.append((
            period_from, period_to,
            r.get("customer_name"),
            safe_num(r.get("qty")),
            safe_num(r.get("sales")),
            safe_num(r.get("docs")),
            safe_num(r.get("asp_weighted"), 6),
            safe_num(r.get("mix_share_sales"), 6),
            int(r.get("rank_in_period") or 0),
        ))
    cur.executemany(sql, rows)
    return len(rows)

def upsert_product_daily(cur, prod_daily):
    if not prod_daily: return 0
    sql = """
    INSERT INTO reporting_product_daily
      (period_date, product_code, product_name, qty, sales, asp)
    VALUES (%s,%s,%s,%s,%s,%s)
    ON DUPLICATE KEY UPDATE
      qty=VALUES(qty), sales=VALUES(sales), asp=VALUES(asp),
      generated_at=CURRENT_TIMESTAMP
    """
    rows = []
    for r in prod_daily:
        period_date = safe_date(r.get("register_date") or r.get("period_date") or r.get("date"))
        qty = safe_num(r.get("qty"))
        sales = safe_num(r.get("sales"))
        asp = safe_num((sales / qty) if (qty and sales is not None and qty != 0) else r.get("asp"), 6)
        rows.append((
            period_date,
            r.get("product_code"),
            r.get("product_name"),
            qty, sales, asp
        ))
    cur.executemany(sql, rows)
    return len(rows)

# ========== ARGPARSE & LOGIKA WYBORU ==========

def parse_cli_args():
    p = argparse.ArgumentParser()
    p.add_argument('--date-from', dest='date_from', required=False, help='YYYY-MM-DD')
    p.add_argument('--date-to',   dest='date_to',   required=False, help='YYYY-MM-DD (inclusive, we add +1 day internally)')
    # akceptuj obie formy: wielokrotne --metric oraz (opcjonalnie) --metrics CSV
    p.add_argument('--metric',    dest='metric', action='append', default=[], help='Nazwa preagregatu; można podać wiele razy')
    p.add_argument('--metrics',   dest='metrics', action='append', default=[], help='CSV: a,b,c (można podać wiele razy)')
    p.add_argument('--ai',        dest='ai', choices=['true','false'], default='false')
    return p.parse_args()

def collect_metric_names(args):
    names = []
    # z --metric (powtarzalne)
    if args.metric:
        names.extend([s.strip() for s in args.metric if s and s.strip()])
    # z --metrics (może być kilka wystąpień; każde może być CSV)
    for entry in (args.metrics or []):
        if not entry:
            continue
        for part in str(entry).replace(';', ',').replace(' ', ',').split(','):
            part = part.strip()
            if part:
                names.append(part)
    # aliasy dla kpis
    alias_map = {'basic': 'kpis', 'basic_totals': 'kpis'}
    names = [alias_map.get(n, n) for n in names]
    # deduplikacja z zachowaniem kolejności
    seen = set()
    uniq = []
    for n in names:
        if n not in seen:
            seen.add(n)
            uniq.append(n)
    return uniq

def compute_selected_preaggs(rows, names):
    """
    Liczy TYLKO wskazane preagregaty. ZAWSZE zwraca DataFrame'y (nigdy listy).
    Obsługuje pseudo-agregat 'kpis' (podstawowe KPI).
    """
    results = {}
    if not names:
        return results
    df = pre.to_df(rows)

    # kpis — pseudoagregat
    def compute_kpis_df(dfx):
        if dfx is None or dfx.empty:
            return pd.DataFrame([{
                "total_sales": 0.0,
                "total_qty": 0.0,
                "total_docs": 0,
                "asp": None,
            }])
        total_sales = float(dfx["total_netto"].sum())
        total_qty   = float(dfx["quantity"].sum())
        total_docs  = int(dfx["document_no"].nunique())
        asp = (total_sales / total_qty) if total_qty else None
        return pd.DataFrame([{
            "total_sales": total_sales,
            "total_qty": total_qty,
            "total_docs": total_docs,
            "asp": asp,
        }])

    for name in names:
        if name == 'kpis':
            results[name] = compute_kpis_df(df)
            continue

        fn = pre.AGGREGATORS.get(name)
        if not fn:
            results[name] = pd.DataFrame()  # nieznany agregat -> pusty
            continue
        try:
            out = fn(df)
            if out is None:
                results[name] = pd.DataFrame()
            elif hasattr(out, "copy"):
                results[name] = out.copy()
            else:
                results[name] = pd.DataFrame(out)
        except Exception:
            # np. top10_* na pustych danych -> zwróć pusty wynik
            results[name] = pd.DataFrame()

    return results

def sanitize_serialized(serialized_dict):
    """
    Jeśli jakikolwiek agregat zwrócił błąd (np. _error), zamieniamy na pustą listę.
    """
    clean = {}
    for k, records in (serialized_dict or {}).items():
        if not records:
            clean[k] = []
            continue
        if isinstance(records, list) and isinstance(records[0], dict) and ('_error' in records[0]):
            clean[k] = []
        else:
            clean[k] = records
    return clean

def has_any_rows(serialized_dict):
    for records in (serialized_dict or {}).values():
        if records:  # lista niepusta
            return True
    return False

# ========== MAIN ==========

def main():
    # --- CLI ---
    args = parse_cli_args()
    with_ai      = (args.ai == 'true')
    metric_names = collect_metric_names(args)

    # --- Daty: preferuj CLI; 'date_to' inkluzywne (dodajemy +1 dzień dla SQL '<') ---
    if args.date_from and args.date_to:
        period_from, period_to = args.date_from, add_one_day(args.date_to)
        shown_label = "{} .. {}".format(args.date_from, args.date_to)
    else:
        env_from, env_to = getenv("PERIOD_FROM"), getenv("PERIOD_TO")
        if env_from and env_to:
            period_from, period_to = env_from, env_to
            # label dla czytelności: to-1d
            try:
                to_label = (datetime.strptime(period_to, "%Y-%m-%d") - timedelta(days=1)).strftime("%Y-%m-%d")
            except Exception:
                to_label = period_to
            shown_label = "{} .. {}".format(period_from, to_label)
        else:
            period_from, period_to = last_full_month_bounds()
            # label: poprzedni pełny miesiąc
            try:
                to_label = (datetime.strptime(period_to, "%Y-%m-%d") - timedelta(days=1)).strftime("%Y-%m-%d")
            except Exception:
                to_label = period_to
            shown_label = "{} .. {}".format(period_from, to_label)

    # --- DB ---
    cfg = {
        "host": getenv("MYSQL_HOST", "twinpol-mysql56"),
        "user": getenv("MYSQL_USER", "root"),
        "password": getenv("MYSQL_PASSWORD", "rootpassword"),
        "database": getenv("MYSQL_DATABASE", "preDb_0dcc87940d3655fa574b253df04ca1c3"),
        "port": int(getenv("MYSQL_PORT", "3306")),
    }
    invoice_type = getenv("INVOICE_TYPE", "normal")

    # --- SQL -> rows (UWZGLĘDNIJ DATY; typ wg ENV) ---
    try:
        cnx = mysql.connector.connect(**cfg)
        cur = cnx.cursor()
        if invoice_type:
            cur.execute(
                """
                SELECT i.document_no,
                       i.parent_name,
                       DATE(i.register_date) AS register_date,
                       ii.code,
                       ii.name,
                       ii.quantity,
                       ii.total_netto
                FROM ecminvoiceoutitems AS ii
                JOIN ecminvoiceouts      AS i ON i.id = ii.ecminvoiceout_id
                WHERE i.register_date >= %s
                  AND i.register_date <  %s
                  AND i.type = %s
                """,
                (period_from, period_to, invoice_type),
            )
        else:
            cur.execute(
                """
                SELECT i.document_no,
                       i.parent_name,
                       DATE(i.register_date) AS register_date,
                       ii.code,
                       ii.name,
                       ii.quantity,
                       ii.total_netto
                FROM ecminvoiceoutitems AS ii
                JOIN ecminvoiceouts      AS i ON i.id = ii.ecminvoiceout_id
                WHERE i.register_date >= %s
                  AND i.register_date <  %s
                """,
                (period_from, period_to),
            )
        rows = cur.fetchall()
        cur.close()
        cnx.close()
    except Exception as e:
        html_fatal(str(e), title="Błąd połączenia/zapytania MySQL")

    # --- LICZ TYLKO WYBRANE PREAGREGATY (w tym pseudo 'kpis') ---
    results = {}
    serialized = {}
    if metric_names:
        results = compute_selected_preaggs(rows, metric_names)
        serialized = serialize_for_ai(results)
        serialized = sanitize_serialized(serialized)  # usuń ewentualne _error -> traktuj jako puste
    else:
        serialized = {}

    # --- ZAPIS do reporting (tylko to, co faktycznie policzyłeś) ---
    try:
        if serialized:
            rep_cfg = {
                "host": "host.docker.internal",
                "port": 3307,
                "user": "remote",
                "password": os.environ.get("REPORTING_PASSWORD", "areiufh*&^yhdua"),
                "database": "ai",
            }
            if os.environ.get("REPORTING_SSL_CA"):
                rep_cfg["ssl_ca"] = os.environ["REPORTING_SSL_CA"]
            if os.environ.get("REPORTING_SSL_CERT"):
                rep_cfg["ssl_cert"] = os.environ["REPORTING_SSL_CERT"]
            if os.environ.get("REPORTING_SSL_KEY"):
                rep_cfg["ssl_key"]  = os.environ["REPORTING_SSL_KEY"]

            cnx2 = connect_html_or_die(rep_cfg, label="ReportingDB")
            cur2 = cnx2.cursor()

            if "daily_sales" in serialized:
                upsert_daily_sales(cur2, serialized.get("daily_sales") or [])
            if "product_summary" in serialized:
                upsert_product_summary(cur2, serialized.get("product_summary") or [], period_from, period_to)
            if "customer_summary" in serialized:
                upsert_customer_summary(cur2, serialized.get("customer_summary") or [], period_from, period_to)
            if "product_daily" in serialized:
                upsert_product_daily(cur2, serialized.get("product_daily") or [])

            cnx2.commit()
            cur2.close(); cnx2.close()
    except Exception as e:
        sys.stderr.write(f"[reporting] ERROR: {e}\n")

    # --- KPI: jeśli wybrano 'kpis' -> bierz z wyników; w przeciwnym razie spróbuj z daily_sales; inaczej zera ---
    kpis = []
    if "kpis" in results and isinstance(results["kpis"], pd.DataFrame) and not results["kpis"].empty:
        r = results["kpis"].iloc[0]
        total_sales = r.get("total_sales") or 0
        total_qty   = r.get("total_qty") or 0
        total_docs  = r.get("total_docs") or 0
        asp         = r.get("asp")
    else:
        daily = serialized.get("daily_sales") or []
        total_sales = sum((x.get("sales") or 0) for x in daily) if daily else 0
        total_qty   = sum((x.get("qty") or 0) for x in daily) if daily else 0
        total_docs  = sum((x.get("docs") or 0) for x in daily) if daily else 0
        asp = (total_sales / total_qty) if total_qty else None

    kpis = [
        ("Sprzedaż (PLN)", fmt_money(total_sales)),
        ("Ilość (szt.)", "{:,.0f}".format(total_qty).replace(",", " ")),
        ("Dokumenty", "{:,.0f}".format(total_docs).replace(",", " ")),
        ("ASP (PLN/szt.)", fmt_money(asp) if asp is not None else "—"),
    ]

    # --- Sekcje HTML: renderuj tylko te, które policzyłeś ---
    parts = []
    if "top10_products_by_sales" in serialized:
        parts.append(html_table(serialized.get("top10_products_by_sales") or [], title="Top 10 produktów (po sprzedaży)", max_rows=10))
    if "top10_customers_by_sales" in serialized:
        parts.append(html_table(serialized.get("top10_customers_by_sales") or [], title="Top 10 klientów (po sprzedaży)",  max_rows=10))
    if "daily_sales" in serialized:
        parts.append(html_table(serialized.get("daily_sales") or [], title="Sprzedaż dzienna (skrót)", max_rows=30))
    if "product_summary" in serialized:
        parts.append(html_table(serialized.get("product_summary") or [], title="Podsumowanie produktów (skrót)", max_rows=30))
    if "customer_summary" in serialized:
        parts.append(html_table(serialized.get("customer_summary") or [], title="Podsumowanie klientów (skrót)", max_rows=30))
    if "product_daily" in serialized:
        parts.append(html_table(serialized.get("product_daily") or [], title="Produkt × Dzień (próbka)", max_rows=30))

    # --- AI tylko gdy: --ai true ORAZ jest co najmniej jeden rekord w którymś z wybranych agregatów ---
    api_key = API_KEY_HARDCODE or getenv("OPENAI_API_KEY", "")
    model = getenv("OPENAI_MODEL", "gpt-4.1")
    MODEL_ALIAS = {
        "gpt-4.1": "GPT-4.1",
        "gpt-4.1-mini": "GPT-4.1-mini",
        "gpt-4o": "GPT-4o",
        "gpt-4o-mini": "GPT-4o-mini",
    }
    model_alias = MODEL_ALIAS.get(model, model)

    ai_section = ""
    if with_ai and has_any_rows(serialized):
        try:
            ai_data = {"kpis_hint": {"period_label": shown_label}}
            for name, records in serialized.items():
                ai_data[name] = compact_table(records, 100)
            ai_json = json.dumps(ai_data, ensure_ascii=False, separators=(",", ":"), default=str)

            ai_section = call_openai_chat(
                api_key=(api_key or ""),
                model=model,
                system_prompt=("Jesteś analitykiem sprzedaży. Zwróć TYLKO jedną sekcję HTML (bez <html>/<head>/<body>). "
                               "Streszcz kluczowe trendy i daj 3–6 zaleceń. Po polsku."),
                user_payload_json=ai_json,
                temperature=0.3,
                connect_timeout=10,
                read_timeout=90,
                max_retries=3,
            )
        except Exception as e:
            err = str(e)
            if "insufficient_quota" in err or "You exceeded your current quota" in err:
                try:
                    ai_section = call_openai_chat(
                        api_key=(api_key or ""),
                        model="gpt-4.1-mini",
                        system_prompt=("Jesteś analitykiem sprzedaży. Zwróć TYLKO jedną sekcję HTML (bez <html>/<head>/<body>). "
                                       "Streszcz kluczowe trendy i daj 3–6 zaleceń. Po polsku."),
                        user_payload_json=ai_json,
                        temperature=0.3,
                        connect_timeout=10,
                        read_timeout=90,
                        max_retries=2,
                    )
                    model_alias = "GPT-4.1-mini"
                except Exception as ee:
                    ai_section = (
                        '<div style="color:#991b1b;background:#fff5f5;border:1px solid #fecaca;'
                        'padding:10px;border-radius:8px;">Brak dostępnego limitu API. {}</div>'.format(str(ee))
                    )
            else:
                ai_section = (
                    '<div style="color:#991b1b;background:#fff5f5;border:1px solid #fecaca;'
                    'padding:10px;border-radius:8px;">Błąd wywołania AI: {}</div>'.format(err)
                )
    else:
        ai_section = '<div style="color:#6b7280">Analiza AI wyłączona lub brak wybranych danych.</div>'
        model_alias = ""

    # --- Finalny HTML ---
    report_html = render_report_html(
        period_label=shown_label,
        kpis=kpis,
        parts=parts,
        ai_section=ai_section,
        model_alias=(model_alias if (with_ai and has_any_rows(serialized)) else "")
    )
    sys.stdout.write(report_html)

if __name__ == "__main__":
    main()