#!/usr/bin/env python3
"""yakcloud datasource migrate — 데이터소스 스냅샷(블랙리스트) 캡처 + 빈 타깃 적용(부트스트랩).

모델(확정):
  capture  = 소스 전체 native 덤프 − 블랙리스트(db/<source>/.migrateignore, 글롭) → db/<source>/snapshot/.
             **읽기전용**(항상 안전). 커밋 전 '무엇이 잡히는지' 미리보기.
  apply    = 타깃이 **비어 있을 때만** 복원. 데이터가 있으면 **스킵**(절대 안 덮음, force 없음).
             즉 새 환경을 dev 상태로 채우는 부트스트랩/시딩 도구. (prod 적용은 백엔드 경유 — 별도 승인)

dev 채널: 러너를 DB 클라이언트 이미지 one-shot 으로 compose 네트워크에 join → 소스 컨테이너 직접(자격 미노출).
자격은 yakcloud_dev 의 결정적 파생(creds_for)을 그대로 사용. 지원 타입: postgresql·mysql·mariadb·mongodb·minio.
"""
from __future__ import annotations

import argparse
import fnmatch
import json
import os
import subprocess
import sys

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import yakcloud_dev as dev  # noqa: E402  (동일 scripts/ 의 dev 엔진 헬퍼 재사용)

SNAP = "db"                      # 프로젝트 루트 db/<source>/ (git 추적 — .gitignore 아님)
IGNORE = ".migrateignore"
SUPPORTED = ("postgresql", "mysql", "mariadb", "mongodb", "minio")
IMG = {"postgresql": "postgres:16-alpine", "mysql": "mysql:8.4", "mariadb": "mariadb:11.4",
       "mongodb": "mongo:7", "minio": "minio/mc:latest"}


def die(m: str) -> None:
    sys.exit(f"  ✗ {m}")


def _net(m: dict) -> str:
    return f"{dev.compose_project(m)}_default"


def _running(m: dict, source: str) -> bool:
    j = dev._ps_state(m).get(source) or {}
    return (j.get("State") or "") == "running"


def _srcdir(source: str) -> str:
    return os.path.join(SNAP, source)


def _blacklist(source: str) -> list[str]:
    p = os.path.join(_srcdir(source), IGNORE)
    if not os.path.exists(p):
        return []
    out = []
    for ln in open(p):
        ln = ln.split("#", 1)[0].strip()
        if ln:
            out.append(ln)
    return out


def _excluded(name: str, patterns: list[str]) -> bool:
    return any(fnmatch.fnmatch(name, pat) for pat in patterns)


def drun(net: str, image: str, shell: str, mounts=None, capture=True, check=True):
    """docker run one-shot(sh -c) — 모든 명령을 쉘 경유(리다이렉트/파이프 지원)."""
    args = ["docker", "run", "--rm", "--network", net]
    for host, cont in (mounts or []):
        os.makedirs(host, exist_ok=True)
        args += ["-v", f"{os.path.abspath(host)}:{cont}"]
    args += ["--entrypoint", "sh", image, "-c", shell]
    r = subprocess.run(args, text=True,
                       stdout=subprocess.PIPE if capture else None,
                       stderr=subprocess.PIPE if capture else None)
    if check and r.returncode != 0:
        die(f"클라이언트 실행 실패({r.returncode}): {(r.stderr or r.stdout or '').strip()[:400]}")
    return r


# ── 타입별: 대상 단위 나열(미리보기·글롭 확장용) ────────────────────────────
def list_units(m: dict, source: str, stype: str, cr: dict) -> list[str]:
    net = _net(m)
    if stype == "postgresql":
        url = f"postgresql://{cr['user']}:{cr['password']}@{source}:5432/{cr['db']}"
        q = "SELECT tablename FROM pg_tables WHERE schemaname='public' ORDER BY tablename"
        r = drun(net, IMG[stype], f"psql '{url}' -tAc \"{q}\"", check=False)
    elif stype in ("mysql", "mariadb"):
        q = f"SELECT table_name FROM information_schema.tables WHERE table_schema='{cr['db']}'"
        r = drun(net, IMG[stype],
                 f"mysql -h {source} -u{cr['user']} -p{cr['password']} -N -B -e \"{q}\" 2>/dev/null", check=False)
    elif stype == "mongodb":
        js = "db.getCollectionNames().filter(c=>!c.startsWith('_yakcloud')).join('\\n')"
        r = drun(net, IMG[stype],
                 f"mongosh --quiet --host {source} -u {cr['user']} -p {cr['password']} "
                 f"--authenticationDatabase {cr['db']} {cr['db']} --eval \"{js}\"", check=False)
    elif stype == "minio":
        # minio/mc 이미지엔 awk 가 없음 → --json 으로 받아 파이썬에서 key 파싱.
        setup = f"mc alias set s http://{source}:9000 {cr['access']} {cr['secret']} >/dev/null 2>&1"
        r = drun(net, IMG[stype],
                 f"{setup} && mc ls --recursive --json s/{cr['bucket']} 2>/dev/null", check=False)
        keys = []
        for ln in (r.stdout or "").splitlines():
            ln = ln.strip()
            if not ln:
                continue
            try:
                j = json.loads(ln)
                if j.get("key"):
                    keys.append(j["key"])
            except Exception:
                pass
        return keys
    else:
        return []
    return [x.strip() for x in (r.stdout or "").splitlines() if x.strip() and "Warning" not in x]


# ── 미리보기 ────────────────────────────────────────────────────────────
def preview(m: dict, targets: list[tuple[str, str]]) -> dict:
    seed = dev.ensure_seed()
    plan = {}
    print("캡처 미리보기 (읽기전용) — ✓=포함, ✗=제외(블랙리스트)")
    for source, stype in targets:
        cr = dev.creds_for(seed, source, stype)
        bl = _blacklist(source)
        units = list_units(m, source, stype, cr)
        inc = [u for u in units if not _excluded(u, bl)]
        exc = [u for u in units if _excluded(u, bl)]
        plan[source] = {"type": stype, "include": inc, "exclude": exc, "blacklist": bl}
        unit_word = {"minio": "오브젝트"}.get(stype, "테이블/컬렉션")
        print(f"\n  ● {source} ({stype}) — {unit_word} {len(units)}개 · 포함 {len(inc)} / 제외 {len(exc)}")
        for u in inc[:20]:
            print(f"      ✓ {u}")
        if len(inc) > 20:
            print(f"      … 외 {len(inc)-20}개")
        for u in exc:
            print(f"      ✗ {u}  (블랙리스트)")
        if not bl:
            print(f"      · 블랙리스트 없음 → 전부 포함. 민감/개인정보·쓰레기는 "
                  f"{os.path.join(_srcdir(source), IGNORE)} 에 글롭으로 제외 권장")
    return plan


# ── 캡처(전체 native 덤프 − 블랙리스트) ───────────────────────────────────
def capture_source(m: dict, source: str, stype: str, cr: dict) -> dict:
    net, outdir = _net(m), os.path.join(_srcdir(source), "snapshot")
    os.makedirs(outdir, exist_ok=True)
    bl = _blacklist(source)
    units = list_units(m, source, stype, cr)
    excluded = [u for u in units if _excluded(u, bl)]
    info = {"type": stype, "excluded": excluded, "blacklist": bl}
    if stype == "postgresql":
        url = f"postgresql://{cr['user']}:{cr['password']}@{source}:5432/{cr['db']}"
        # pg_dump 는 패턴(*)을 지원 → 블랙리스트 글롭을 그대로 넘겨 소유 시퀀스(<tbl>_id_seq 등)까지 제외.
        ex = " ".join(f"--exclude-table='{g}'" for g in bl)
        drun(net, IMG[stype], f"pg_dump '{url}' {ex} -f /out/snapshot.sql", [(outdir, "/out")])
        info["file"] = "snapshot.sql"
    elif stype in ("mysql", "mariadb"):
        ig = " ".join(f"--ignore-table={cr['db']}.{e}" for e in excluded)
        drun(net, IMG[stype],
             f"mysqldump -h {source} -u{cr['user']} -p{cr['password']} --skip-comments {ig} "
             f"{cr['db']} > /out/snapshot.sql", [(outdir, "/out")])
        info["file"] = "snapshot.sql"
    elif stype == "mongodb":
        ex = " ".join(f"--excludeCollection={e}" for e in excluded)
        drun(net, IMG[stype],
             f"mongodump --host {source} -u {cr['user']} -p {cr['password']} "
             f"--authenticationDatabase {cr['db']} --db {cr['db']} {ex} --archive=/out/dump.archive",
             [(outdir, "/out")])
        info["file"] = "dump.archive"
    elif stype == "minio":
        setup = f"mc alias set s http://{source}:9000 {cr['access']} {cr['secret']} >/dev/null"
        exflag = " ".join(f"--exclude '{e}'" for e in bl)
        drun(net, IMG[stype],
             f"{setup} && mc mirror --overwrite {exflag} s/{cr['bucket']} /out/bucket", [(outdir, "/out")])
        info["file"], info["bucket"] = "bucket/", cr["bucket"]
    else:
        die(f"미지원 타입(캡처): {stype}")
    json.dump(info, open(os.path.join(outdir, "manifest.json"), "w"), ensure_ascii=False, indent=2)
    return info


# ── 타깃 비어있음 검사 + 적용(부트스트랩) ─────────────────────────────────
def is_empty(m: dict, source: str, stype: str, cr: dict) -> bool:
    return len(list_units(m, source, stype, cr)) == 0


def apply_source(m: dict, source: str, stype: str, cr: dict) -> str:
    net, outdir = _net(m), os.path.join(_srcdir(source), "snapshot")
    if not os.path.isdir(outdir):
        return "스냅샷 없음(먼저 capture)"
    if not is_empty(m, source, stype, cr):
        return "타깃에 데이터 있음 → 스킵(덮지 않음)"
    if stype == "postgresql":
        url = f"postgresql://{cr['user']}:{cr['password']}@{source}:5432/{cr['db']}"
        drun(net, IMG[stype], f"psql '{url}' -v ON_ERROR_STOP=1 -f /out/snapshot.sql", [(outdir, "/out")])
    elif stype in ("mysql", "mariadb"):
        drun(net, IMG[stype],
             f"mysql -h {source} -u{cr['user']} -p{cr['password']} {cr['db']} < /out/snapshot.sql",
             [(outdir, "/out")])
    elif stype == "mongodb":
        drun(net, IMG[stype],
             f"mongorestore --host {source} -u {cr['user']} -p {cr['password']} "
             f"--authenticationDatabase {cr['db']} --archive=/out/dump.archive", [(outdir, "/out")])
    elif stype == "minio":
        setup = f"mc alias set s http://{source}:9000 {cr['access']} {cr['secret']} >/dev/null"
        drun(net, IMG[stype],
             f"{setup} && (mc mb -p s/{cr['bucket']} 2>/dev/null || true) && "
             f"mc mirror --overwrite /out/bucket s/{cr['bucket']}", [(outdir, "/out")])
    else:
        die(f"미지원 타입(적용): {stype}")
    return "적용 완료(부트스트랩)"


def select_targets(m: dict, names: list[str], require_running: bool) -> list[tuple[str, str]]:
    reqs = {r["name"]: r["type"] for r in dev.requires(m)}
    if names:
        miss = [n for n in names if n not in reqs]
        if miss:
            die(f"requires 에 없음: {', '.join(miss)}")
        chosen = [(n, reqs[n]) for n in names]
    else:
        chosen = list(reqs.items())
    out = []
    for s, t in chosen:
        if t not in SUPPORTED:
            print(f"  · {s}({t}) — 마이그레이션 미지원(다음 단계: redis/solr/rabbitmq/oracle). 건너뜀")
            continue
        if require_running and not _running(m, s):
            print(f"  · {s} — dev 컨테이너 미기동('yakcloud dev up {s}' 먼저). 건너뜀")
            continue
        out.append((s, t))
    if not out:
        die("대상 소스가 없습니다.")
    return out


# ── 명령 ────────────────────────────────────────────────────────────────
def cmd_capture(a) -> None:
    m = dev.load_manifest()
    targets = select_targets(m, a.source, require_running=True)
    preview(m, targets)
    if a.dry_run:
        print("\n(미리보기 전용 — 캡처 안 함)")
        return
    if not a.yes and sys.stdin.isatty():
        if input("\n위 대상을 db/<source>/snapshot/ 에 캡처할까요? [y/N] ").strip().lower() not in ("y", "yes"):
            print("취소.")
            return
    seed = dev.ensure_seed()
    for source, stype in targets:
        cr = dev.creds_for(seed, source, stype)
        info = capture_source(m, source, stype, cr)
        print(f"  ✓ {source} 캡처 → {os.path.join(_srcdir(source), 'snapshot', info['file'])}"
              f" (제외 {len(info['excluded'])})")
    print("  · db/ 를 커밋하세요(리뷰 대상). 적용: 'yakcloud datasource migrate apply'(빈 타깃만)")


def cmd_apply(a) -> None:
    m = dev.load_manifest()
    targets = select_targets(m, a.source, require_running=True)
    seed = dev.ensure_seed()
    for source, stype in targets:
        cr = dev.creds_for(seed, source, stype)
        print(f"  ▸ {source} ({stype}): {apply_source(m, source, stype, cr)}")
    print("  · prod 적용은 콘솔 소스관리자 컨펌 + 백업 후(롤백 보장) — 별도 경로")


def cmd_status(a) -> None:
    m = dev.load_manifest()
    reqs = {r["name"]: r["type"] for r in dev.requires(m)}
    names = a.source or list(reqs)
    print("migrate 스냅샷 상태")
    for s in names:
        t = reqs.get(s, "?")
        snap = os.path.join(_srcdir(s), "snapshot", "manifest.json")
        bl = _blacklist(s)
        if os.path.exists(snap):
            info = json.load(open(snap))
            print(f"  {s} ({t}): 스냅샷 있음(제외 {len(info.get('excluded', []))}) · 블랙리스트 {len(bl)}줄")
        else:
            print(f"  {s} ({t}): 스냅샷 없음 · 블랙리스트 {len(bl)}줄")


def build_parser() -> argparse.ArgumentParser:
    p = argparse.ArgumentParser(prog="yakcloud datasource migrate")
    sub = p.add_subparsers(dest="cmd", required=True)
    c = sub.add_parser("capture", help="소스 전체 상태 − 블랙리스트 를 db/<source>/snapshot/ 에 캡처(읽기전용)")
    c.add_argument("source", nargs="*")
    c.add_argument("--dry-run", action="store_true", help="미리보기만")
    c.add_argument("-y", "--yes", action="store_true", help="확인 없이")
    c.set_defaults(fn=cmd_capture)
    ap = sub.add_parser("apply", help="스냅샷을 타깃에 적용(빈 타깃만, 데이터 있으면 스킵)")
    ap.add_argument("source", nargs="*")
    ap.set_defaults(fn=cmd_apply)
    st = sub.add_parser("status", help="스냅샷·블랙리스트 상태")
    st.add_argument("source", nargs="*")
    st.set_defaults(fn=cmd_status)
    return p


if __name__ == "__main__":
    args = build_parser().parse_args()
    args.fn(args)