# -*- coding: utf-8 -*-
"""Deploy: backend python szkriptek + sablon feltoltese a Rackforest-re FTP-n.

Hasznalat:
  python deploy.py             # Felulirja az osszes backend .py + sablon HTML-t
  python deploy.py --dry-run   # Csak listazza mit toltene fel

FTP credentialeket a config.py-bol olvas (FTP_HOST, FTP_USER, FTP_PASSWORD, FTP_TARGET_DIR).
"""
import sys, os, argparse, ftplib, ssl
try:
    sys.stdout.reconfigure(encoding="utf-8", errors="replace")
except Exception:
    pass

try:
    from config import (FTP_HOST, FTP_USER, FTP_PASSWORD, FTP_TARGET_DIR)
except ImportError:
    print("HIBA: config.py nem talalhato")
    sys.exit(1)
try:
    from config import FTP_USE_TLS
except ImportError:
    FTP_USE_TLS = True

# A backend mappa a tarholy oldalan
try:
    from config import FTP_BACKEND_DIR
except ImportError:
    # Default: a public mappa szomszedja (Rackforest konvencionok szerint)
    FTP_BACKEND_DIR = FTP_TARGET_DIR.rstrip("/").replace(
        "riport.schneider-juwelier.at",
        "riport.schneider-juwelier.at-backend"
    )

SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))

# Mit toltsunk fel: a backend mappa fontos fajljai (csak forrasokod, NEM a DB!)
FILES_TO_UPLOAD = [
    "webshop_auto.py",
    "utalvany_lekerdezes.py",
    "marka_lekerdezes.py",
    "napi_futas.py",
    "dashboard_export.py",
    "dashboard_template.html",
    "email_kuldes.py",
    "webshop_riport_uj.py",
    "reszamolas_napi.py",
]


def _connect():
    """FTPS kapcsolat (cert-verify nelkul shared hosting miatt)."""
    if FTP_USE_TLS:
        ctx = ssl.create_default_context()
        ctx.check_hostname = False
        ctx.verify_mode = ssl.CERT_NONE
        ftp = ftplib.FTP_TLS(FTP_HOST, timeout=120, context=ctx)
        ftp.login(FTP_USER, FTP_PASSWORD)
        ftp.prot_p()
    else:
        ftp = ftplib.FTP(FTP_HOST, timeout=120)
        ftp.login(FTP_USER, FTP_PASSWORD)
    return ftp


def pull_db(local_path):
    """Server-rol letolti a webshop_adatok.db-t a local_path-ra."""
    print(f"[..] DB letoltese a serverr-rol...")
    ftp = _connect()
    ftp.cwd(FTP_BACKEND_DIR)
    with open(local_path, "wb") as f:
        ftp.retrbinary("RETR webshop_adatok.db", f.write)
    ftp.quit()
    size = os.path.getsize(local_path) / 1024
    print(f"[OK] Letoltve: {local_path} ({size:.1f} KB)")


def push_db(local_path):
    """Lokal DB feltoltese a serverre, felulirja a webshop_adatok.db-t."""
    print(f"[..] DB feltoltese a serverre...")
    ftp = _connect()
    ftp.cwd(FTP_BACKEND_DIR)
    with open(local_path, "rb") as f:
        ftp.storbinary("STOR webshop_adatok.db", f)
    ftp.quit()
    size = os.path.getsize(local_path) / 1024
    print(f"[OK] Feltoltve: {local_path} ({size:.1f} KB)")


def push_index(local_html):
    """Frissitett index.html feltoltese a publikus mappaba."""
    print(f"[..] index.html feltoltese a publikus mappaba...")
    ftp = _connect()
    ftp.cwd(FTP_TARGET_DIR)
    with open(local_html, "rb") as f:
        ftp.storbinary("STOR index.html", f)
    ftp.quit()
    size = os.path.getsize(local_html) / 1024
    print(f"[OK] Feltoltve: index.html ({size:.1f} KB)")


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--dry-run", action="store_true")
    ap.add_argument("--pull-db", action="store_true", help="Server DB letoltese")
    ap.add_argument("--push-db", action="store_true", help="Lokal DB feltoltese a serverre")
    ap.add_argument("--push-index", action="store_true", help="index.html feltoltese a publikus mappaba")
    args = ap.parse_args()

    if args.pull_db:
        pull_db(os.path.join(SCRIPT_DIR, "webshop_adatok.db"))
        return
    if args.push_db:
        push_db(os.path.join(SCRIPT_DIR, "webshop_adatok.db"))
        return
    if args.push_index:
        idx = os.path.normpath(os.path.join(SCRIPT_DIR, "..", "riport.schneider-juwelier.at", "index.html"))
        if not os.path.exists(idx):
            print(f"HIBA: nem talalhato: {idx}")
            sys.exit(1)
        push_index(idx)
        return

    if not (FTP_HOST and FTP_USER and FTP_PASSWORD):
        print("HIBA: config.py-ban hianyoznak az FTP adatok")
        print("Toltsd ki: FTP_HOST, FTP_USER, FTP_PASSWORD")
        sys.exit(1)

    print(f"[..] Kapcsolodas: {FTP_HOST} ({'FTPS' if FTP_USE_TLS else 'FTP'})")
    print(f"     Backend mappa: {FTP_BACKEND_DIR}")

    if args.dry_run:
        print("\n[DRY-RUN] Csak listazas, NEM toltunk fel.")

    # FTP/FTPS kapcsolat
    if not args.dry_run:
        if FTP_USE_TLS:
            # Shared hosting (Rackforest) eseten a TLS cert sokszor wildcard-os
            # vagy a host nevre nem illeszkedik. A titkositast megtartjuk,
            # de a hostname-verification-t kikapcsoljuk.
            ctx = ssl.create_default_context()
            ctx.check_hostname = False
            ctx.verify_mode = ssl.CERT_NONE
            ftp = ftplib.FTP_TLS(FTP_HOST, timeout=60, context=ctx)
            ftp.login(FTP_USER, FTP_PASSWORD)
            ftp.prot_p()
        else:
            ftp = ftplib.FTP(FTP_HOST, timeout=60)
            ftp.login(FTP_USER, FTP_PASSWORD)
        ftp.cwd(FTP_BACKEND_DIR)

    uploaded = 0
    skipped = 0
    for fname in FILES_TO_UPLOAD:
        fpath = os.path.join(SCRIPT_DIR, fname)
        if not os.path.exists(fpath):
            print(f"  [SKIP] {fname}: lokalisan nem letezik")
            skipped += 1
            continue
        size_kb = os.path.getsize(fpath) / 1024
        print(f"  [{'WOULD UPLOAD' if args.dry_run else 'UPLOAD'}] {fname}  ({size_kb:.1f} KB)")
        if not args.dry_run:
            with open(fpath, "rb") as f:
                ftp.storbinary(f"STOR {fname}", f)
        uploaded += 1

    if not args.dry_run:
        ftp.quit()
        print(f"\n[OK] Feltoltve {uploaded} fajl, kihagyva {skipped}")
    else:
        print(f"\n[OK] {uploaded} fajl menne fel.")


if __name__ == "__main__":
    main()