# -*- coding: utf-8 -*-
"""
Marka-szintu eladasi adatok lekerese UNAS + Shoprenter API-bol.

Hasznalat:
  python marka_lekerdezes.py --debug                # Tegnapi nap + API struktura kiirasa (NEM ment DB-be)
  python marka_lekerdezes.py --debug --napi 2026-05-18
  python marka_lekerdezes.py --napi 2026-05-18      # Egy nap mentese
  python marka_lekerdezes.py --backfill 30          # Utolso 30 nap mentese
  python marka_lekerdezes.py --forras unas --debug  # Csak az egyik forras

Uj DB tabla: napi_marka(datum, forras, marka, db, osszeg)
"""
import sys, os, sqlite3, argparse, json, time
from datetime import datetime, timedelta
from collections import defaultdict

try:
    sys.stdout.reconfigure(encoding="utf-8", errors="replace")
except Exception:
    pass

import requests
import xml.etree.ElementTree as ET
import base64

try:
    from config import *
except ImportError:
    print("HIBA: config.py hianyzik!")
    sys.exit(1)

SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
DB_PATH = os.path.join(SCRIPT_DIR, "webshop_adatok.db")
DEBUG_FILE = os.path.join(SCRIPT_DIR, "marka_debug.txt")

# Shoprenter kizart statuszok (mint webshop_auto.py-ben)
KIZART_STATUSZOK = {8, 10, 11, 12, 14, 15}


def get_status_id_from_href(href):
    try:
        b64 = href.rstrip("/").split("/")[-1]
        decoded = base64.b64decode(b64 + "==").decode()
        return int(decoded.split("=")[-1])
    except Exception:
        return None


# ============================================================
# DB
# ============================================================

def init_db():
    con = sqlite3.connect(DB_PATH)
    con.execute("""
        CREATE TABLE IF NOT EXISTS napi_marka (
            datum TEXT NOT NULL,
            forras TEXT NOT NULL,
            marka TEXT NOT NULL,
            db INTEGER NOT NULL DEFAULT 0,
            osszeg REAL NOT NULL DEFAULT 0,
            PRIMARY KEY (datum, forras, marka)
        )
    """)
    # Cache tabla: termek -> marka (Shoprenter product lookup-ok mentese)
    con.execute("""
        CREATE TABLE IF NOT EXISTS termek_marka_cache (
            forras TEXT NOT NULL,
            azonosito TEXT NOT NULL,
            marka TEXT,
            modositva TEXT,
            PRIMARY KEY (forras, azonosito)
        )
    """)
    con.commit()
    return con


def save_brand(con, datum, forras, marka, db, osszeg):
    con.execute(
        "INSERT OR REPLACE INTO napi_marka (datum, forras, marka, db, osszeg) VALUES (?, ?, ?, ?, ?)",
        (datum, forras, marka, int(db), float(osszeg))
    )


def delete_day_brands(con, datum, forras):
    con.execute("DELETE FROM napi_marka WHERE datum=? AND forras=?", (datum, forras))


def cache_get(con, forras, azonosito):
    r = con.execute(
        "SELECT marka FROM termek_marka_cache WHERE forras=? AND azonosito=?",
        (forras, azonosito)
    ).fetchone()
    return r[0] if r else None


def cache_set(con, forras, azonosito, marka):
    con.execute(
        "INSERT OR REPLACE INTO termek_marka_cache (forras, azonosito, marka, modositva) VALUES (?, ?, ?, ?)",
        (forras, azonosito, marka or "", datetime.now().isoformat(timespec="seconds"))
    )


def normalize_brand(s):
    """Markanev normalizalas: trim + title case."""
    if not s:
        return "Ismeretlen"
    s = str(s).strip()
    if not s:
        return "Ismeretlen"
    # Title case, de az osszes nagybetus markat (TISSOT, CASIO) cimes alakra
    if s.isupper() and len(s) > 2:
        s = s.title()
    return s


# ============================================================
# UNAS
# ============================================================

def unas_login():
    payload = f"""<?xml version="1.0" encoding="UTF-8"?>
<Params><ApiKey>{UNAS_API_KEY}</ApiKey></Params>"""
    r = requests.post(
        "https://api.unas.eu/shop/login",
        data=payload.encode(),
        headers={"Content-Type": "application/xml"},
        timeout=30
    )
    token = ET.fromstring(r.text).findtext("Token")
    if not token:
        raise RuntimeError(f"UNAS login hiba: {r.text[:200]}")
    return token


def unas_get_orders_for_day(token, datum):
    """Egy nap rendelesei items adatokkal egyutt (binaris keresessel)."""
    def get_orders(start, num=200):
        # <Contents>full</Contents> es <Items>true</Items> mindkettot probaljuk
        p = f"""<?xml version="1.0" encoding="UTF-8"?>
<Params>
    <StatusGroup>all</StatusGroup>
    <LimitNum>{num}</LimitNum>
    <LimitStart>{start}</LimitStart>
    <Contents>full</Contents>
    <Items>true</Items>
</Params>"""
        r = requests.post(
            "https://api.unas.eu/shop/getOrder",
            data=p.encode(),
            headers={"Content-Type": "application/xml",
                     "Authorization": f"Bearer {token}"},
            timeout=60
        )
        return ET.fromstring(r.text).findall(".//Order")

    # Binaris kereses a datumra
    lo, hi = 0, 20000
    while lo < hi - 200:
        mid = (lo + hi) // 2
        ords = get_orders(mid, 1)
        if not ords:
            hi = mid
            continue
        d = (ords[0].findtext("Date", "") or "")[:10].replace(".", "-")
        if d < datum:
            lo = mid
        else:
            hi = mid

    orders = get_orders(max(0, lo - 100), 400)

    result = []
    for o in orders:
        raw = (o.findtext("Date", "") or "")[:10].replace(".", "-")
        if raw != datum:
            continue
        statusz = (o.findtext("Status") or "").strip()
        if statusz == "Törölve":
            continue
        result.append(o)
    return result


def unas_get_product_brand(token, sku, con):
    """getProduct hivas alapjan a marka kinyerese. Cache-eli SKU szerint.

    Logika: a getProduct valasz <Categories> reszeben van olyan <Category Type=base>,
    aminek a <Name> tartalma 'Márkák|<MARKA>|<TIPUS>' formatumu (pipe-pal elvalasztva).
    Tehat a 2. elem a marka.
    """
    if not sku:
        return None
    # Cache check
    cached = cache_get(con, "unas_product_brand", sku)
    if cached is not None:
        return cached or None

    try:
        payload = f"""<?xml version="1.0" encoding="UTF-8"?>
<Params><Sku>{sku}</Sku><Contents>full</Contents></Params>"""
        r = requests.post(
            "https://api.unas.eu/shop/getProduct",
            data=payload.encode(),
            headers={"Content-Type": "application/xml",
                     "Authorization": f"Bearer {token}"},
            timeout=30
        )
        root = ET.fromstring(r.text)
    except Exception:
        cache_set(con, "unas_product_brand", sku, "")
        return None

    brand = None
    # Categoriak vegigjarasa - keressuk a "Márkák|X|..." formatumut
    for cat in root.iter("Category"):
        ctype = cat.findtext("Type") or ""
        if ctype != "base":
            continue
        name = (cat.findtext("Name") or "").strip()
        if not name:
            continue
        parts = [p.strip() for p in name.split("|") if p.strip()]
        # "Márkák" vagy "Markak" -> elso elem, marka -> 2. elem
        if len(parts) >= 2 and parts[0].lower() in ("márkák", "markak", "márka", "marka", "brands", "brand"):
            brand = parts[1]
            break

    if not brand:
        # Fallback: termek nev elso szava (pl. "Pandora - Szikrazo...")
        name = root.findtext(".//Product/Name") or root.findtext(".//Name")
        if name:
            parts = name.strip().split()
            if parts:
                brand = parts[0]

    cache_set(con, "unas_product_brand", sku, brand or "")
    con.commit()
    return brand


def process_unas_day(con, datum, debug=False, dry_run=False):
    print(f"\n[UNAS] {datum}")
    try:
        token = unas_login()
    except Exception as e:
        print(f"  [!] Login hiba: {e}")
        return False

    orders = unas_get_orders_for_day(token, datum)
    print(f"  {len(orders)} rendeles")

    if debug and orders:
        sample_xml = ET.tostring(orders[0], encoding="unicode")
        print("\n  === DEBUG: elso rendeles UNAS XML (max 3500 byte) ===")
        print(sample_xml[:3500])
        print("  === DEBUG VEGE ===\n")

    brands = defaultdict(lambda: {"db": 0, "osszeg": 0.0})
    items_total = 0
    items_no_brand = 0

    for o in orders:
        items_root = o.find("Items")
        if items_root is None:
            items = o.findall("Item")
        else:
            items = items_root.findall("Item")
        if not items:
            continue
        for item in items:
            sku = item.findtext("Sku") or ""
            # Discount/kupon sorok atugrasa
            if sku in ("discount-percent", "discount-fixed", "shipping") or sku.startswith("discount"):
                continue
            items_total += 1
            try:
                qty = float(item.findtext("Quantity", "1") or 1)
            except Exception:
                qty = 1
            price = 0.0
            for pf in ("PriceGross", "PriceNetGross", "UnitPriceGross", "Price"):
                v = item.findtext(pf)
                if v:
                    try:
                        price = float(v)
                        break
                    except Exception:
                        pass
            line_total = qty * price

            # Marka: getProduct alapjan
            brand_raw = unas_get_product_brand(token, sku, con)
            if brand_raw:
                brand = normalize_brand(brand_raw)
            else:
                items_no_brand += 1
                name = item.findtext("Name", "") or ""
                brand = normalize_brand(name.split()[0]) if name.split() else "Ismeretlen"

            brands[brand]["db"] += int(qty) if qty == int(qty) else 1
            brands[brand]["osszeg"] += line_total

    print(f"  Tetel: {items_total} | Direkt marka nelkuli (nev-fallback hasznalva): {items_no_brand}")
    print(f"  Marka: {len(brands)} kulonbozo")
    if brands:
        top = sorted(brands.items(), key=lambda kv: -kv[1]["osszeg"])[:5]
        for b, v in top:
            print(f"    {b}: {v['db']} db | {v['osszeg']:,.0f} Ft")

    if not dry_run:
        delete_day_brands(con, datum, "unas")
        for marka, v in brands.items():
            save_brand(con, datum, "unas", marka, v["db"], v["osszeg"])
        con.commit()
        print(f"  [OK] DB-be mentve")
    return True


# ============================================================
# Shoprenter
# ============================================================

def shop_get_order_products(order, auth):
    """Egy Shoprenter Order termekei (orderProducts href kovetese)."""
    op_ref = order.get("orderProducts")
    if not isinstance(op_ref, dict) or not op_ref.get("href"):
        return []
    try:
        r = requests.get(op_ref["href"], auth=auth,
                         headers={"Accept": "application/json"},
                         params={"limit": 100, "full": 1}, timeout=30)
        if r.status_code != 200:
            return []
        return r.json().get("items", [])
    except Exception:
        return []


def shop_resolve_manufacturer_name(m_href, auth, con):
    """Manufacturer href -> name (cache-elve)."""
    if not m_href:
        return None
    cached = cache_get(con, "shop_manuf_name", m_href)
    if cached is not None:
        return cached or None
    try:
        r = requests.get(m_href, auth=auth, headers={"Accept": "application/json"}, timeout=15)
        if r.status_code != 200:
            cache_set(con, "shop_manuf_name", m_href, "")
            return None
        name = (r.json().get("name") or "").strip()
    except Exception:
        name = ""
    cache_set(con, "shop_manuf_name", m_href, name)
    con.commit()
    return name or None


def shop_resolve_brand_for_orderproduct(op, auth, con):
    """OrderProduct -> brand (termek + manufacturer kovetessel, cache-elt)."""
    pr = op.get("product")
    p_href = pr.get("href") if isinstance(pr, dict) else None
    if not p_href:
        # Fallback: orderProduct.name elso szava
        n = op.get("name") or ""
        return n.split()[0] if n.split() else None

    # Cache: product_href -> manufacturer_href (vagy "")
    cached_mhref = cache_get(con, "shop_product_manuf", p_href)
    if cached_mhref is not None:
        # Van cachelt erteke (lehet "" ha nincs manufacturer)
        if cached_mhref:
            mname = shop_resolve_manufacturer_name(cached_mhref, auth, con)
            if mname:
                return mname
        # Fallback - nev elso szava
        n = op.get("name") or ""
        return n.split()[0] if n.split() else None

    # Lekerjuk a terméket
    try:
        r = requests.get(p_href, auth=auth, headers={"Accept": "application/json"}, timeout=15)
        if r.status_code != 200:
            cache_set(con, "shop_product_manuf", p_href, "")
            con.commit()
            n = op.get("name") or ""
            return n.split()[0] if n.split() else None
        pdata = r.json()
    except Exception:
        cache_set(con, "shop_product_manuf", p_href, "")
        con.commit()
        n = op.get("name") or ""
        return n.split()[0] if n.split() else None

    m_ref = pdata.get("manufacturer")
    m_href = m_ref.get("href") if isinstance(m_ref, dict) else None
    cache_set(con, "shop_product_manuf", p_href, m_href or "")
    con.commit()

    if m_href:
        mname = shop_resolve_manufacturer_name(m_href, auth, con)
        if mname:
            return mname
    # Fallback
    n = op.get("name") or pdata.get("name") or ""
    return n.split()[0] if n.split() else None


def shop_get_orders_for_day(datum):
    base_url = SHOPRENTER_API_URL.rstrip("/")
    auth = (SHOPRENTER_API_USER, SHOPRENTER_API_PASSWORD)

    def get_page(page):
        for _ in range(3):
            try:
                r = requests.get(f"{base_url}/orders", auth=auth,
                                 headers={"Accept": "application/json"},
                                 params={"page": page, "limit": 25, "full": 1}, timeout=30)
                if r.status_code == 429:
                    time.sleep(10)
                    continue
                return r.json().get("items", [])
            except Exception:
                time.sleep(5)
        return []

    r0 = requests.get(f"{base_url}/orders", auth=auth,
                      headers={"Accept": "application/json"},
                      params={"page": 0, "limit": 25, "full": 1}, timeout=30)
    page_count = int(r0.json().get("pageCount", 1) or 1)

    lo, hi = 0, page_count - 1
    target = None
    while lo <= hi:
        mid = (lo + hi) // 2
        items = get_page(mid)
        if not items:
            break
        dates = [(o.get("dateCreated") or "")[:10] for o in items if o.get("dateCreated")]
        if not dates:
            break
        min_d, max_d = min(dates), max(dates)
        if max_d < datum:
            lo = mid + 1
        elif min_d > datum:
            hi = mid - 1
        else:
            target = mid
            break

    if target is None:
        return [], base_url, auth

    result = []
    for pg in range(max(0, target - 10), min(page_count, target + 11)):
        items = get_page(pg)
        for o in items:
            if (o.get("dateCreated") or "")[:10] != datum:
                continue
            st = o.get("orderStatus")
            status_href = st.get("href", "") if isinstance(st, dict) else ""
            status_id = get_status_id_from_href(status_href)
            if status_id is None or status_id in KIZART_STATUSZOK:
                continue
            result.append(o)
    return result, base_url, auth


def process_shop_day(con, datum, debug=False, dry_run=False):
    print(f"\n[Shoprenter] {datum}")
    orders, base_url, auth = shop_get_orders_for_day(datum)
    print(f"  {len(orders)} rendeles")

    brands = defaultdict(lambda: {"db": 0, "osszeg": 0.0})
    items_total = 0
    items_no_brand = 0

    for o in orders:
        op_items = shop_get_order_products(o, auth)
        if not op_items:
            continue
        for op in op_items:
            items_total += 1
            # Quantity szamitas: total / price (mert nincs kulon quantity mezo)
            try:
                p_net = float(op.get("price", 0) or 0)
                t_net = float(op.get("total", 0) or 0)
                qty = max(1, round(t_net / p_net)) if p_net > 0 else 1
            except Exception:
                qty = 1
            # Brutto sor osszeg
            try:
                gross_per_unit = float(op.get("grossPrice", 0) or 0)
            except Exception:
                gross_per_unit = 0
            line_total = gross_per_unit * qty

            brand_raw = shop_resolve_brand_for_orderproduct(op, auth, con)
            if brand_raw:
                brand = normalize_brand(brand_raw)
            else:
                items_no_brand += 1
                brand = "Ismeretlen"

            brands[brand]["db"] += qty
            brands[brand]["osszeg"] += line_total

    print(f"  Tetel: {items_total} | Marka nelkul (nev-fallback): {items_no_brand}")
    print(f"  Marka: {len(brands)} kulonbozo")
    if brands:
        top = sorted(brands.items(), key=lambda kv: -kv[1]["osszeg"])[:5]
        for b, v in top:
            print(f"    {b}: {v['db']} db | {v['osszeg']:,.0f} Ft")

    if not dry_run:
        delete_day_brands(con, datum, "shoprenter")
        for marka, v in brands.items():
            save_brand(con, datum, "shoprenter", marka, v["db"], v["osszeg"])
        con.commit()
        print("  [OK] DB-be mentve")
    return True


# ============================================================
# Reszletes debug fajlba iras
# ============================================================

def write_debug_file(datum):
    """API valaszok teljes feltarasa egy fajlba (Claude Code itt olvashatja)."""
    lines = []
    lines.append(f"=" * 70)
    lines.append(f"API debug - {datum}")
    lines.append(f"Idopont: {datetime.now().isoformat(timespec='seconds')}")
    lines.append(f"=" * 70)

    # ====== UNAS ======
    lines.append("\n\n" + "=" * 70)
    lines.append("UNAS")
    lines.append("=" * 70)
    try:
        token = unas_login()
        lines.append(f"\n[OK] Login - token: {token[:30]}...")
        orders = unas_get_orders_for_day(token, datum)
        lines.append(f"[OK] Rendeles ezen a napon: {len(orders)}")

        # Elso 3 rendeles teljes XML-je
        for i, o in enumerate(orders[:3]):
            lines.append(f"\n----- UNAS RENDELES #{i+1} TELJES XML -----")
            xml_str = ET.tostring(o, encoding="unicode")
            lines.append(xml_str)
            lines.append(f"----- VEGE rendeles #{i+1} -----")

        # Osszes item tag osszesitve
        all_item_tags = set()
        all_order_tags = set()
        item_count = 0
        for o in orders:
            for child in o:
                all_order_tags.add(child.tag)
            for item in o.iter("Item"):
                item_count += 1
                for c in item:
                    all_item_tags.add(c.tag)
        lines.append(f"\n----- UNAS Order szintu tag-ek (osszesen {len(orders)} rendeles) -----")
        for t in sorted(all_order_tags):
            lines.append(f"  {t}")
        lines.append(f"\n----- UNAS Item szintu tag-ek (osszesen {item_count} item) -----")
        for t in sorted(all_item_tags):
            lines.append(f"  {t}")

        # Probaljuk a getProduct-ot is - hatha ott van a Manufacturer
        lines.append(f"\n----- UNAS getProduct egy minta termekre -----")
        sample_sku = None
        for o in orders[:5]:
            for it in o.iter("Item"):
                sku = it.findtext("Sku") or it.findtext("Id")
                if sku:
                    sample_sku = sku
                    break
            if sample_sku:
                break
        if sample_sku:
            try:
                pr = f"""<?xml version="1.0" encoding="UTF-8"?>
<Params><Sku>{sample_sku}</Sku><Contents>full</Contents></Params>"""
                resp = requests.post(
                    "https://api.unas.eu/shop/getProduct",
                    data=pr.encode(),
                    headers={"Content-Type": "application/xml",
                             "Authorization": f"Bearer {token}"},
                    timeout=30
                )
                lines.append(f"  Sample SKU: {sample_sku}")
                lines.append(f"  HTTP: {resp.status_code}")
                lines.append(resp.text[:5000])
            except Exception as e:
                lines.append(f"  getProduct hiba: {e}")
        else:
            lines.append("  Nem talaltam SKU/Id-t az item-ekben")

    except Exception as e:
        lines.append(f"\n[!!] UNAS hiba: {e}")
        import traceback
        lines.append(traceback.format_exc())

    # ====== SHOPRENTER ======
    lines.append("\n\n" + "=" * 70)
    lines.append("SHOPRENTER")
    lines.append("=" * 70)
    try:
        orders, base_url, auth = shop_get_orders_for_day(datum)
        lines.append(f"\n[OK] Rendeles ezen a napon: {len(orders)}")

        if not orders:
            lines.append("Nem volt rendeles ezen a napon")
        else:
            first = orders[0]
            lines.append(f"\nElso rendeles innerId: {first.get('innerId')} | total: {first.get('total')}")

            # ===== orderProducts lekerese =====
            op_ref = first.get("orderProducts")
            op_href = op_ref.get("href") if isinstance(op_ref, dict) else None
            lines.append(f"\norderProducts href: {op_href}")

            order_product_items = []
            if op_href:
                # Probaljuk full=1 nelkul es 1-gyel
                for params in [{"full": 1, "limit": 50}, {"limit": 50}]:
                    try:
                        r = requests.get(op_href, auth=auth, headers={"Accept": "application/json"},
                                         params=params, timeout=30)
                        lines.append(f"\n----- SHOPRENTER orderProducts (params={params}) -----")
                        lines.append(f"HTTP: {r.status_code}")
                        data = r.json()
                        lines.append(f"Top-level kulcsok: {sorted(data.keys()) if isinstance(data, dict) else type(data).__name__}")
                        if isinstance(data, dict) and "items" in data:
                            items = data["items"]
                            lines.append(f"items length: {len(items)}")
                            if items:
                                order_product_items = items
                                lines.append(f"\n----- Elso orderProduct TELJES JSON -----")
                                lines.append(json.dumps(items[0], ensure_ascii=False, indent=2)[:5000])
                                lines.append(f"\n----- orderProduct kulcsok -----")
                                for k in sorted(items[0].keys()):
                                    lines.append(f"  {k}")
                        break
                    except Exception as e:
                        lines.append(f"HIBA: {e}")

            # ===== Probaljuk a termek hivatkozast kovetni =====
            if order_product_items:
                first_op = order_product_items[0]
                # product href?
                p_ref = first_op.get("product")
                p_href = p_ref.get("href") if isinstance(p_ref, dict) else None
                lines.append(f"\nElso orderProduct product href: {p_href}")
                if p_href:
                    try:
                        r = requests.get(p_href, auth=auth, headers={"Accept": "application/json"}, timeout=30)
                        lines.append(f"\n----- SHOPRENTER product (TELJES JSON) -----")
                        lines.append(f"HTTP: {r.status_code}")
                        pdata = r.json()
                        lines.append(json.dumps(pdata, ensure_ascii=False, indent=2)[:5000])
                        lines.append(f"\n----- product kulcsok -----")
                        if isinstance(pdata, dict):
                            for k in sorted(pdata.keys()):
                                lines.append(f"  {k}")
                            # manufacturer kovetese
                            m_ref = pdata.get("manufacturer")
                            m_href = m_ref.get("href") if isinstance(m_ref, dict) else None
                            if m_href:
                                lines.append(f"\nmanufacturer href: {m_href}")
                                try:
                                    mr = requests.get(m_href, auth=auth, headers={"Accept": "application/json"}, timeout=30)
                                    mdata = mr.json()
                                    lines.append(f"\n----- SHOPRENTER manufacturer (TELJES JSON) -----")
                                    lines.append(f"HTTP: {mr.status_code}")
                                    lines.append(json.dumps(mdata, ensure_ascii=False, indent=2)[:3000])
                                except Exception as e:
                                    lines.append(f"manufacturer fetch HIBA: {e}")
                            else:
                                lines.append("\nNINCS manufacturer href a termekben - nezzuk a kategoriakat is")
                                # categories?
                                c_ref = pdata.get("categories") or pdata.get("productCategories")
                                if isinstance(c_ref, dict) and c_ref.get("href"):
                                    try:
                                        cr = requests.get(c_ref["href"], auth=auth, headers={"Accept": "application/json"}, timeout=30)
                                        lines.append(f"\n----- categories valasz -----")
                                        lines.append(json.dumps(cr.json(), ensure_ascii=False, indent=2)[:3000])
                                    except Exception as e:
                                        lines.append(f"categories HIBA: {e}")
                    except Exception as e:
                        lines.append(f"product fetch HIBA: {e}")

    except Exception as e:
        lines.append(f"\n[!!] Shoprenter hiba: {e}")
        import traceback
        lines.append(traceback.format_exc())

    # Mentes
    content = "\n".join(lines)
    with open(DEBUG_FILE, "w", encoding="utf-8") as f:
        f.write(content)

    print(f"\n[OK] Debug kimenet mentve: {DEBUG_FILE}")
    print(f"     Meret: {len(content)/1024:.1f} KB")
    print(f"     Szolj Claude-nak, hogy olvassa be ezt a fajlt.")


# ============================================================
# Foprogram
# ============================================================

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--debug", action="store_true",
                    help="API struktura kiirasa (nem ment DB-be, csak elemez)")
    ap.add_argument("--napi", help="Egy nap yyyy-mm-dd formatumban")
    ap.add_argument("--backfill", type=int, help="Utolso N nap mentese")
    ap.add_argument("--forras", choices=["unas", "shoprenter", "both"], default="both")
    args = ap.parse_args()

    con = init_db()
    dry = args.debug

    if args.debug and not (args.napi or args.backfill):
        d = (datetime.today() - timedelta(days=1)).strftime("%Y-%m-%d")
        print(f"=== DEBUG mod: {d} (nem ment DB-be) ===")
        # Reszletes fajl-output Claude Code szamara
        write_debug_file(d)
        # Konzolos osszefoglalo is
        if args.forras in ("unas", "both"):
            process_unas_day(con, d, debug=False, dry_run=True)
        if args.forras in ("shoprenter", "both"):
            process_shop_day(con, d, debug=False, dry_run=True)
    elif args.napi:
        d = args.napi
        if args.forras in ("unas", "both"):
            process_unas_day(con, d, debug=args.debug, dry_run=dry)
        if args.forras in ("shoprenter", "both"):
            process_shop_day(con, d, debug=args.debug, dry_run=dry)
    elif args.backfill:
        n = args.backfill
        print(f"=== Backfill: utolso {n} nap ===")
        for i in range(1, n + 1):
            d = (datetime.today() - timedelta(days=i)).strftime("%Y-%m-%d")
            print(f"\n--- {i}/{n}: {d} ---")
            if args.forras in ("unas", "both"):
                try:
                    process_unas_day(con, d, dry_run=dry)
                except Exception as e:
                    print(f"  [!] UNAS hiba: {e}")
            if args.forras in ("shoprenter", "both"):
                try:
                    process_shop_day(con, d, dry_run=dry)
                except Exception as e:
                    print(f"  [!] Shop hiba: {e}")
    else:
        ap.print_help()

    con.close()
    print("\n[OK] Kesz")


if __name__ == "__main__":
    main()