"""
Podávání žádostí o výpis registrovaných pojištěnců ZPŠ — čistý Python, bez prohlížeče.

Co dělá:
  1. Přihlásí se certifikátem na portál ZPŠ (uloží cookies pro Playwright)
  2. Stáhne nové soubory z výpisové schránky (schranka-vypis-pojistencu-v-kapitaci)
  3. Podá žádost pro 1 následující měsíc

Stavový soubor: stav.json vedle tohoto skriptu.
  {"mesic": 2, "rok": 2025}  — poslední úspěšně podaný měsíc

Log podání: log_podani.json — seznam { datum, ref_cislo, podano_kdy }
"""

import calendar
import json
import os
import re
import sys
import time
from datetime import date, datetime
from pathlib import Path

import requests
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.serialization import pkcs7, pkcs12

sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "..")))
from Knihovny.najdi_dropbox import get_dropbox_root

PFX_PATH     = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "Certificates", "MBQualifiedCert.pfx"))
PFX_PASSWORD = b"Vlado7309208104++"

BASE_URL   = "https://portal.zpskoda.cz"
SUBMIT_URL = f"{BASE_URL}/json-api/formular-schranky/29-vypis-registrov-pojistencu/ulozit-formular"
ICZ        = "25520"

STATE_FILE = os.path.join(os.path.dirname(__file__), "stav.json")
LOG_FILE   = os.path.join(os.path.dirname(__file__), "log_podani.json")

# Sdílené soubory s ostatními ZPŠ skripty
STAHUJ_DIR     = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "StahováníZpráv", "209 ZPŠ"))
COOKIES_FILE   = os.path.join(STAHUJ_DIR, "zps_cookies.json")
CHROME_PROFILE = os.path.join(STAHUJ_DIR, "chrome_profile")
DOWNLOAD_DIR   = os.path.join(get_dropbox_root(), "Ordinace", "Dokumentace_ke_zpracování", "Zúčtovací zprávy", "SeznamyPojištěnců")

VYPIS_URL    = f"{BASE_URL}/app/schranka-vypis-pojistencu-v-kapitaci"
DOWNLOAD_URL = f"{BASE_URL}/html/prehled-zprav-ve-schrankach/zobrazit-prilohu"
PROTOKOL_URL = f"{BASE_URL}/html/prehled-zprav-ve-schrankach/zobrazit-protokol"


# ---------------------------------------------------------------------------
# Přihlášení
# ---------------------------------------------------------------------------

def prihlaseni() -> requests.Session:
    """Přihlásí se certifikátem, vrátí autentizovanou session. Uloží cookies pro Playwright."""
    challenge_url = f"{BASE_URL}/json-api/prihlaseni/prihlasovaci-zprava"
    certlogin_url = f"{BASE_URL}/json-api/prihlaseni/prihlaseni-certifikatem"

    session = requests.Session()
    session.headers.update({
        "User-Agent":       "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
        "X-Requested-With": "XMLHttpRequest",
        "Origin":           BASE_URL,
        "Referer":          BASE_URL + "/",
    })

    r = session.get(f"{BASE_URL}/app/prihlaseni")
    r.raise_for_status()
    session.cookies.set("pzp_sign", "CERT", domain="portal.zpskoda.cz", path="/")

    r = session.post(challenge_url, json={"login_sign": "CERT"},
                     headers={"Content-Type": "application/json; charset=UTF-8"})
    r.raise_for_status()
    zprava = r.json()["data"]["zprava"]
    print(f"Challenge: {zprava[:60]}...")

    with open(PFX_PATH, "rb") as f:
        private_key, cert, _ = pkcs12.load_key_and_certificates(f.read(), PFX_PASSWORD)

    podpis = (
        pkcs7.PKCS7SignatureBuilder()
        .set_data(zprava.encode("utf-8"))
        .add_signer(cert, private_key, hashes.SHA256())
        .sign(serialization.Encoding.PEM, [pkcs7.PKCS7Options.DetachedSignature])
        .decode("ascii").strip()
    )

    r = session.post(certlogin_url, json={"zprava": zprava, "podpis": podpis},
                     headers={"Content-Type": "application/json; charset=UTF-8"})
    r.raise_for_status()
    data = r.json()["data"]

    if not data.get("prihlasen"):
        raise RuntimeError(f"Přihlášení selhalo: {r.json().get('errMsg', '')}")

    print("Přihlášení úspěšné!")

    cookies = [
        {
            "name":     c.name,
            "value":    c.value,
            "domain":   c.domain if c.domain.startswith(".") else "." + c.domain,
            "path":     c.path or "/",
            "expires":  int(c.expires) if c.expires else -1,
            "secure":   bool(c.secure),
            "httpOnly": False,
            "sameSite": "Lax",
        }
        for c in session.cookies
    ]
    with open(COOKIES_FILE, "w", encoding="utf-8") as f:
        json.dump(cookies, f, indent=2, ensure_ascii=False)
    print(f"Cookies uloženy: {len(cookies)} → {COOKIES_FILE}")

    return session


# ---------------------------------------------------------------------------
# Stahování z výpisové schránky
# ---------------------------------------------------------------------------

def safe_filename(name: str) -> str:
    return re.sub(r'[\\/:*?"<>|]', "_", name).strip()


def parse_date(date_str: str) -> str:
    try:
        return datetime.strptime(date_str.strip()[:19], "%d.%m.%Y %H:%M:%S").strftime("%Y-%m-%d")
    except Exception:
        try:
            return datetime.strptime(date_str.strip()[:10], "%d.%m.%Y").strftime("%Y-%m-%d")
        except Exception:
            return "0000-00-00"


def parse_row(cells: list) -> dict:
    date_raw  = cells[1].strip() if len(cells) > 1 else ""
    desc_raw  = cells[2].strip() if len(cells) > 2 else ""
    fname_raw = cells[3].strip() if len(cells) > 3 else ""

    desc_lines = [l.strip() for l in desc_raw.split("\n") if l.strip()]
    if len(desc_lines) >= 3:
        description = desc_lines[2]
    elif len(desc_lines) >= 2:
        description = desc_lines[1]
    else:
        description = desc_lines[0] if desc_lines else ""
    description = description[:80]

    fname_match = re.match(r'^(.+?)\s*\(\d{2}\.\d{2}\.\d{4}\)\s*$', fname_raw)
    original = fname_match.group(1).strip() if fname_match else fname_raw.split("(")[0].strip()
    orig_path = Path(original)
    stem = orig_path.stem or "zprava"
    ext  = orig_path.suffix or ""

    date_iso = parse_date(date_raw)
    name = f"{date_iso} {safe_filename(description)} ({safe_filename(stem)}){ext}"
    if len(name) > 240:
        name = f"{date_iso} ({safe_filename(stem)}){ext}"

    return {"date": date_iso, "desc": description, "original": original, "filename": name}


def stahni_nove_vypisy() -> int:
    """Stáhne nové soubory z výpisové schránky. Vrátí počet stažených souborů."""
    try:
        from playwright.sync_api import sync_playwright
    except ImportError:
        print("Chybí playwright: pip install playwright && playwright install chrome")
        return 0

    os.makedirs(DOWNLOAD_DIR, exist_ok=True)

    with open(COOKIES_FILE, encoding="utf-8") as f:
        cookies = json.load(f)

    downloaded = 0

    with sync_playwright() as p:
        context = p.chromium.launch_persistent_context(
            user_data_dir=CHROME_PROFILE,
            channel="chrome",
            headless=False,
            slow_mo=100,
            ignore_https_errors=True,
        )
        try:
            context.add_cookies(cookies)
            page = context.new_page()

            page.goto(f"{VYPIS_URL}/", wait_until="domcontentloaded", timeout=30_000)
            if "prihlaseni" in page.url or "login" in page.url.lower():
                print("Session v prohlížeči expirovala — stahování přeskočeno")
                return 0
            print("Prohlížeč přihlášen OK\n")

            already = set(os.listdir(DOWNLOAD_DIR))
            print(f"V archivu: {len(already)} souborů.\n")

            page_num = 1
            seen_ids: set = set()

            while True:
                url = f"{VYPIS_URL}/stranka-{page_num}"
                print(f"  Stránka {page_num}: {url}")
                try:
                    page.goto(url, wait_until="domcontentloaded", timeout=30_000)
                except Exception as e:
                    print(f"  Navigace selhala: {e}")
                    break
                page.wait_for_load_state("networkidle", timeout=15_000)

                data = page.evaluate("""() => {
                    const rows = [];
                    for (const tr of document.querySelectorAll('table tr')) {
                        const cells = Array.from(tr.querySelectorAll('td')).map(td => td.innerText.trim());
                        if (cells.length < 4) continue;
                        const dlLink = tr.querySelector('a[onclick*="SchrPolOpenFile"]');
                        if (!dlLink) continue;
                        const mFile = dlLink.getAttribute('onclick').match(/\\d+/);
                        const protLink = tr.querySelector('a[onclick*="SchrPolDBProtokol"]');
                        const mProt = protLink ? protLink.getAttribute('onclick').match(/\\d+/) : null;
                        rows.push({
                            cells,
                            fileId:     mFile ? mFile[0] : null,
                            protokolId: mProt ? mProt[0] : null,
                        });
                    }
                    return rows;
                }""")
                rows = [r for r in data if r["fileId"]]

                if not rows:
                    print(f"  Stránka {page_num} — žádné řádky, konec schránky.")
                    break

                current_ids = {r["fileId"] for r in rows}
                if current_ids & seen_ids:
                    print(f"  Stránka {page_num} — opakující se obsah, konec schránky.")
                    break
                seen_ids.update(current_ids)
                print(f"  Nalezeno {len(rows)} zpráv.")

                stop = False
                for row in rows:
                    info = parse_row(row["cells"])

                    # Zajímají nás pouze .001 soubory
                    if Path(info["original"]).suffix.lower() != ".001":
                        continue

                    target = os.path.join(DOWNLOAD_DIR, info["filename"])

                    if info["filename"] in already or os.path.exists(target):
                        print(f"  [stop] Nalezena již stažená zpráva: {info['filename']}")
                        stop = True
                        break

                    dl_url = f"{DOWNLOAD_URL}?zprava_id={row['fileId']}"
                    try:
                        r = context.request.get(dl_url, headers={"Referer": VYPIS_URL}, timeout=30_000)
                        if not r.ok:
                            print(f"    HTTP {r.status} příloha (id={row['fileId']})")
                        else:
                            body = r.body()
                            if not body[:9].decode("ascii", errors="ignore").startswith("H09305001"):
                                print(f"    přeskočeno (není výpis pojištěnců): {info['filename']}")
                            else:
                                with open(target, "wb") as fh:
                                    fh.write(body)
                                print(f"    OK: {info['filename']}")
                                already.add(info["filename"])
                                downloaded += 1
                    except Exception as e:
                        print(f"    Chyba příloha (id={row['fileId']}): {e}")
                    time.sleep(1.0)

                if stop:
                    break

                page_num += 1

        finally:
            context.close()

    return downloaded


# ---------------------------------------------------------------------------
# Sestavení XML a podpis
# ---------------------------------------------------------------------------

def build_xml(datum: date) -> str:
    datum_str = datum.strftime("%d.%m.%Y")
    return (
        f'<SchrankaZadost NazevSchranky="VypisPojKap" NazevFiltru="ZZ_VYP_REG">\r\n'
        f'<PolozkaFiltru Nazev="icz">{ICZ}</PolozkaFiltru>\r\n'
        f'<PolozkaFiltru Nazev="datum">{datum_str}</PolozkaFiltru>\r\n'
        f'<PolozkaFiltru Nazev="razeni">jmeno</PolozkaFiltru>\r\n'
        f'<PolozkaFiltru Nazev="typ">soubor</PolozkaFiltru>\r\n'
        f'</SchrankaZadost>'
    )


def sign_xml(xml: str) -> str:
    """Podepíše XML certifikátem, vrátí PKCS7 PEM s \\r\\n (stejný formát jako NMSigner)."""
    with open(PFX_PATH, "rb") as f:
        private_key, cert, _ = pkcs12.load_key_and_certificates(f.read(), PFX_PASSWORD)

    pem = (
        pkcs7.PKCS7SignatureBuilder()
        .set_data(xml.encode("utf-8"))
        .add_signer(cert, private_key, hashes.SHA256())
        .sign(serialization.Encoding.PEM, [pkcs7.PKCS7Options.DetachedSignature, pkcs7.PKCS7Options.NoCerts])
        .decode("ascii")
    )
    return pem.replace("\r\n", "\n").replace("\n", "\r\n")


# ---------------------------------------------------------------------------
# Odeslání žádosti
# ---------------------------------------------------------------------------

def odeslat_zadost(session: requests.Session, datum: date) -> str | None:
    """Odešle podepsanou žádost na portál. Vrátí referenční číslo nebo None."""
    xml    = build_xml(datum)
    podpis = sign_xml(xml)

    payload = {"schrXml": xml, "schrSign": podpis, "schrFiles": []}

    r = session.post(SUBMIT_URL, json=payload, headers={
        "Content-Type":     "application/json; charset=UTF-8",
        "X-Requested-With": "XMLHttpRequest",
        "Referer":          BASE_URL + "/",
    })
    r.raise_for_status()

    try:
        resp = r.json()
    except Exception:
        print(f"  Odpověď není JSON: {r.text[:300]}")
        return None

    resp_str = json.dumps(resp, ensure_ascii=False)
    m = re.search(r'\b(17\d{7}|18\d{7})\b', resp_str)
    ref = m.group(1) if m else None

    if resp.get("errMsg") or resp.get("error"):
        print(f"  Chyba od serveru: {resp.get('errMsg') or resp.get('error')}")
        return None

    if ref:
        print(f"  OK — ref. číslo: {ref}")
    else:
        print(f"  Odpověď (bez ref. čísla): {resp_str[:300]}")

    return ref or ("OK" if r.ok else None)


# ---------------------------------------------------------------------------
# Stav a log
# ---------------------------------------------------------------------------

def dalsi_mesic(mesic: int, rok: int) -> tuple[int, int]:
    mesic += 1
    if mesic > 12:
        mesic = 1
        rok += 1
    return mesic, rok


def posledni_den(mesic: int, rok: int) -> date:
    _, last = calendar.monthrange(rok, mesic)
    return date(rok, mesic, last)


def nacti_stav() -> tuple[int, int] | None:
    if os.path.exists(STATE_FILE):
        with open(STATE_FILE, encoding="utf-8") as f:
            data = json.load(f)
        print(f"Stav: poslední podaný {data['mesic']:02d}/{data['rok']}")
        return data["mesic"], data["rok"]
    return None


def uloz_stav(mesic: int, rok: int) -> None:
    with open(STATE_FILE, "w", encoding="utf-8") as f:
        json.dump({"mesic": mesic, "rok": rok}, f, ensure_ascii=False)


def uloz_log(mesic: int, rok: int, ref_cislo: str) -> None:
    log = []
    if os.path.exists(LOG_FILE):
        with open(LOG_FILE, encoding="utf-8") as f:
            log = json.load(f)
    log.append({
        "datum":      posledni_den(mesic, rok).strftime("%d.%m.%Y"),
        "ref_cislo":  ref_cislo,
        "podano_kdy": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
    })
    with open(LOG_FILE, "w", encoding="utf-8") as f:
        json.dump(log, f, indent=2, ensure_ascii=False)


# ---------------------------------------------------------------------------
# Hlavní funkce
# ---------------------------------------------------------------------------

def hlavni() -> None:
    posledni = nacti_stav()
    if posledni is None:
        raise SystemExit(
            "Nelze zjistit poslední podaný měsíc.\n"
            f"Vytvoř ručně soubor {STATE_FILE} ve tvaru:\n"
            '  {"mesic": 2, "rok": 2025}'
        )

    # 1. Přihlášení — uloží cookies pro Playwright
    prihlaseni()

    # 2. Stažení nových výpisů z výpisové schránky
    print("\n=== Stahování nových výpisů ===")
    stazeno = stahni_nove_vypisy()
    print(f"Staženo: {stazeno} souborů.\n")

    # 3. Znovu přihlásit — Playwright mohl invalidovat předchozí session
    print("=== Znovu přihlašuji před podáním ===")
    session = prihlaseni()

    # 4. Podání žádosti pro následující měsíc
    mesic, rok = dalsi_mesic(*posledni)
    datum = posledni_den(mesic, rok)
    print(f"=== Podávám žádost pro: {datum.strftime('%d.%m.%Y')} ===")

    ref = odeslat_zadost(session, datum)

    if ref:
        uloz_stav(mesic, rok)
        uloz_log(mesic, rok, ref)
        print(f"\nHotovo — stav uložen: {mesic:02d}/{rok}, ref: {ref}")
    else:
        print(f"\nPodání selhalo — stav nebyl aktualizován, příště se zkusí znovu {datum.strftime('%d.%m.%Y')}")


if __name__ == "__main__":
    hlavni()