#!/usr/bin/env python3
"""crema - Repository-Verwaltung fuer das Crema Software-Center

Laeuft auf jedem Mac und Linux mit Python 3.9 oder neuer, ohne Zusatzpakete.
Das Repository kann auch ueber CREMA_REPO angegeben werden.

    crema init        REPO
    crema import      REPO DATEI [--name N] [--version V] [--catalog C] [--set k=v]
    crema makecatalogs REPO [--deep]
    crema manifest    REPO NAME [--catalog C] [--optional P] [--managed P] ...
    crema pkginfo     REPO NAME [--version V] [--set k=v] [--show]
    crema list        REPO
    crema autopkg     REPO REZEPT.toml ...   (Rezepte laufen lassen)
    crema admin       REPO [--port 8080]     (Weboberflaeche)
    crema serve       REPO [--port 8080]     (Repository fuer Amigas ausliefern)
"""
import argparse
import os
import sys

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))

from cremalib import VERSION, kategorien, repo as repomod, textfmt  # noqa: E402
from cremalib.textfmt import Record  # noqa: E402


def die(msg, code=1):
    print(f"crema: {msg}", file=sys.stderr)
    sys.exit(code)


def parse_sets(sets):
    out = {}
    for s in sets or []:
        if "=" not in s:
            die(f"--set erwartet schluessel=wert, nicht {s!r}")
        k, v = s.split("=", 1)
        k = k.strip()
        v = v.replace("\\n", "\n")
        if k == "category":
            v = kategorien.normalize_str(v)
        if k in repomod.REPEATED:
            out.setdefault(k, []).append(v)
        else:
            out[k] = v
    return out


def get_repo(args, must_exist=True):
    path = args.repo or os.environ.get("CREMA_REPO")
    if not path:
        die("kein Repository angegeben (Argument oder CREMA_REPO)")
    r = repomod.Repo(path)
    if must_exist and not r.exists():
        die(f"{path} ist kein Crema-Repository - erst 'crema init {path}'")
    return r


def cmd_init(a):
    r = get_repo(a, must_exist=False)
    r.init()
    print(f"Repository angelegt: {r.root}")
    print("  manifests/site_default bietet alles aus dem Katalog 'production' an.")


def cmd_import(a):
    r = get_repo(a)
    if not os.path.isfile(a.file):
        die(f"{a.file} gibt es nicht")
    fields = parse_sets(a.set)
    try:
        rel, rec, notes = r.import_package(
            a.file, name=a.name, version=a.version, subdir=a.subdir or "",
            catalogs=a.catalog or ["testing"], fields=fields,
            extract_icon=not a.no_icon, overwrite=a.overwrite)
    except (repomod.RepoError, ValueError) as e:
        die(str(e))
    print(f"importiert: pkgsinfo/{rel}")
    for n in notes:
        print(f"  Hinweis: {n}")
    errs, warns = r.validate(rec)
    for w in warns:
        print(f"  Warnung: {w}")
    for e in errs:
        print(f"  FEHLER: {e}")
    if not a.no_makecatalogs:
        cmd_makecatalogs(a)


def cmd_makecatalogs(a):
    r = get_repo(a)
    counts, msgs = r.make_catalogs(deep=getattr(a, "deep", False))
    for level, m in msgs:
        print(f"  {'FEHLER' if level == 'error' else 'Warnung'}: {m}")
    print("Kataloge: " + ", ".join(f"{k} ({v})" for k, v in counts.items()))
    if any(l == "error" for l, _ in msgs):
        sys.exit(2)


def cmd_manifest(a):
    r = get_repo(a)
    try:
        rec = r.load_manifest(a.name)
    except repomod.RepoError:
        rec = Record("manifest")
        if a.show:
            die(f"Manifest {a.name} gibt es nicht")
    for key, vals in (("catalogs", a.catalog), ("optional_installs", a.optional),
                      ("managed_installs", a.managed), ("managed_uninstalls", a.uninstall),
                      ("featured_items", a.featured), ("included_manifests", a.include)):
        for v in vals or []:
            cur = rec.get_all(key)
            if v.startswith("-"):
                cur = [c for c in cur if c.lower() != v[1:].lower()]
            elif v.lower() not in (c.lower() for c in cur):
                cur.append(v)
            rec.set(key, ", ".join(cur) if cur else None)
    if not a.show:
        r.save_manifest(a.name, rec)
    print(textfmt.emit([rec]), end="")


def cmd_pkginfo(a):
    r = get_repo(a)
    found = list(r.find(a.name, a.version))
    if not found:
        die(f"{a.name} {a.version or ''} nicht gefunden")
    if len(found) > 1 and not a.version:
        found.sort(key=lambda x: repomod.vercmp_key(x[1].get("version")))
        found = found[-1:]
    rel, rec = found[0]
    fields = parse_sets(a.set)
    if fields:
        for k, v in fields.items():
            rec.set(k, v)
        r.save_pkginfo(rel, rec)
        errs, warns = r.validate(rec)
        for m in errs + warns:
            print(f"  {m}")
        if not a.no_makecatalogs:
            cmd_makecatalogs(a)
    print(f"# pkgsinfo/{rel}")
    print(textfmt.emit([rec]), end="")


def cmd_list(a):
    r = get_repo(a)
    rows = r.pkginfo_list()
    rows.sort(key=lambda x: ((x[1].get("name") or "").lower(), repomod.vercmp_key(x[1].get("version"))))
    for rel, rec in rows:
        print(f"  {rec.get('name', '?'):<24} {rec.get('version', '?'):<10} "
              f"{rec.get('installer_type', '?'):<6} {', '.join(rec.get_all('catalogs')):<20} {rel}")
    print(f"{len(rows)} Paketbeschreibungen")


def cmd_serve(a):
    from cremalib.serve import serve
    r = get_repo(a)
    srv = serve(r.root, a.bind, a.port, quiet=a.quiet)
    print(f"Repository {r.root} unter http://{a.bind}:{a.port}/ - Strg-C beendet", flush=True)
    try:
        srv.serve_forever()
    except KeyboardInterrupt:
        pass


def cmd_autopkg(a):
    from cremalib import autopkg
    r = get_repo(a)
    sys.exit(autopkg.run_cli(r, a))


def cmd_aminet(a):
    from cremalib import aminet as am, autopkg
    amn = am.Aminet()
    try:
        if a.action == "suche":
            rows = amn.search(" ".join(a.args), a.dir or "", limit=a.limit, include_other=a.andere)
            for e in rows:
                print(f"  {e.name:<30} {e.dir:<12} {e.size:>5} {'neu ' if e.age < 30 else ''}{e.desc}")
            print(f"{len(rows)} Treffer (Verzeichnis vom {amn.index_date()})")
        elif a.action == "neu":
            for e in amn.recent():
                print(f"  {e.name:<30} {e.dir:<12} {e.size:>5} {e.desc}")
        elif a.action == "readme":
            head, body = amn.readme(a.args[0])
            for k, v in head.items():
                print(f"{k.capitalize():<13} {v}")
            print()
            print(body)
        elif a.action == "rezept":
            e = amn.find(a.args[0])
            if not e:
                die(f"{a.args[0]} ist nicht im Aminet-Verzeichnis")
            try:
                head, _ = amn.readme(e.path)
            except Exception:  # noqa: BLE001
                head = {}
            rdir = autopkg.recipe_dir(a.recipe_dir)
            fn = os.path.join(rdir, am.recipe_name(e.stem) + ".toml")
            if os.path.exists(fn):
                die(f"{fn} gibt es schon")
            os.makedirs(rdir, exist_ok=True)
            open(fn, "w", encoding="utf-8").write(am.recipe_toml(e, head))
            print(f"Rezept angelegt: {fn}")
    except autopkg.RecipeError as e:
        die(str(e))


def cmd_admin(a):
    from cremalib import webadmin
    r = get_repo(a, must_exist=False)
    webadmin.main(r, a)


def main():
    p = argparse.ArgumentParser(prog="crema", description=f"Crema-Repository-Verwaltung {VERSION}")
    sub = p.add_subparsers(dest="cmd", required=True)

    s = sub.add_parser("init", help="Repository anlegen")
    s.add_argument("repo", nargs="?")
    s.set_defaults(func=cmd_init)

    s = sub.add_parser("import", help="Paket (.lha .zip .adf) aufnehmen")
    s.add_argument("repo", nargs="?")
    s.add_argument("file")
    s.add_argument("--name")
    s.add_argument("--version")
    s.add_argument("--catalog", action="append")
    s.add_argument("--subdir")
    s.add_argument("--set", action="append", metavar="SCHLUESSEL=WERT")
    s.add_argument("--overwrite", action="store_true")
    s.add_argument("--no-icon", action="store_true")
    s.add_argument("--no-makecatalogs", action="store_true")
    s.set_defaults(func=cmd_import)

    s = sub.add_parser("makecatalogs", help="Kataloge neu bauen")
    s.add_argument("repo", nargs="?")
    s.add_argument("--deep", action="store_true", help="Pruefsummen aller Pakete nachrechnen")
    s.set_defaults(func=cmd_makecatalogs)

    s = sub.add_parser("manifest", help="Manifest anlegen/aendern (Wert mit - davor entfernt)")
    s.add_argument("repo", nargs="?")
    s.add_argument("name")
    for opt in ("catalog", "optional", "managed", "uninstall", "featured", "include"):
        s.add_argument(f"--{opt}", action="append")
    s.add_argument("--show", action="store_true")
    s.set_defaults(func=cmd_manifest)

    s = sub.add_parser("pkginfo", help="Paketbeschreibung zeigen/aendern")
    s.add_argument("repo", nargs="?")
    s.add_argument("name")
    s.add_argument("--version")
    s.add_argument("--set", action="append", metavar="SCHLUESSEL=WERT")
    s.add_argument("--no-makecatalogs", action="store_true")
    s.set_defaults(func=cmd_pkginfo)

    s = sub.add_parser("list", help="Paketbeschreibungen auflisten")
    s.add_argument("repo", nargs="?")
    s.set_defaults(func=cmd_list)

    s = sub.add_parser("serve", help="Repository per HTTP ausliefern")
    s.add_argument("repo", nargs="?")
    s.add_argument("--bind", default="0.0.0.0")
    s.add_argument("--port", type=int, default=8080)
    s.add_argument("--quiet", action="store_true")
    s.set_defaults(func=cmd_serve)

    s = sub.add_parser("autopkg", help="Rezepte ausfuehren (Aminet, GitHub, URL)")
    s.add_argument("repo", nargs="?")
    s.add_argument("recipes", nargs="*")
    s.add_argument("--recipe-dir", default=None)
    s.add_argument("--catalog", default="testing")
    s.add_argument("--check", action="store_true", help="nur pruefen, nichts importieren")
    s.set_defaults(func=cmd_autopkg)

    s = sub.add_parser("aminet", help="Aminet durchsuchen, Readme lesen, Rezept anlegen")
    s.add_argument("action", choices=["suche", "neu", "readme", "rezept"])
    s.add_argument("args", nargs="*")
    s.add_argument("--dir")
    s.add_argument("--limit", type=int, default=100)
    s.add_argument("--andere", action="store_true", help="auch OS4/MorphOS/AROS")
    s.add_argument("--recipe-dir")
    s.set_defaults(func=cmd_aminet)

    s = sub.add_parser("admin", help="Weboberflaeche starten")
    s.add_argument("repo", nargs="?")
    s.add_argument("--bind", default="127.0.0.1")
    s.add_argument("--port", type=int, default=8080)
    s.add_argument("--user")
    s.add_argument("--password")
    s.add_argument("--recipe-dir", default=None)
    s.add_argument("--no-repo-serving", action="store_true")
    s.set_defaults(func=cmd_admin)

    a = p.parse_args()
    # "crema import datei" ohne Repo: dann steht die Datei im Repo-Feld
    if getattr(a, "cmd", "") == "import" and a.repo and not os.path.isdir(a.repo) and \
            os.environ.get("CREMA_REPO") and not os.path.exists(a.file):
        pass
    a.func(a)


if __name__ == "__main__":
    main()
