"""Mortgage Banker Portal operations CLI.

Uses the same environment variables as the server (MORTGAGE_DEMO, MORTGAGE_DATA_DIR).
Examples (private database):

    set MORTGAGE_DEMO=0
    python manage.py status
    python manage.py migrate
    python manage.py backup
    python manage.py list-backups
    python manage.py verify-backup mortgage_20261117_..._manual.db
    python manage.py verify-audit
    python manage.py health
    python manage.py import-loans extract.csv [--partial]
    python manage.py obfuscate [--output path.db]   # de-identified copy for demos/sharing
    python manage.py restore mortgage_20261117_..._manual.db   # server must be stopped
"""
import argparse
import json
import os
import sqlite3
import sys

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import core  # noqa: E402
from services import backup, health, importer, migrations, obfuscate  # noqa: E402


def _print(data):
    print(json.dumps(data, indent=2, default=str))


def cmd_status(_):
    conn = sqlite3.connect(core.DB_PATH)
    try:
        version = migrations.current_version(conn)
    finally:
        conn.close()
    _print({'mode': 'demo' if core.DEMO_MODE else 'private', 'database': core.DB_PATH,
            'schema_version': version, 'latest_version': migrations.LATEST_VERSION,
            'pending': [m[0] for m in migrations.MIGRATIONS if m[0] > version], 'app_version': core.__version__})


def cmd_migrate(_):
    applied = core.init_db()
    _print({'applied': applied or [], 'schema_version': migrations.LATEST_VERSION})


def cmd_backup(args):
    manifest = backup.create_backup(core.DB_PATH, core.DATA_DIR, reason=args.reason, app_version=core.__version__,
                                    actor='cli')
    pruned = backup.prune_backups(core.DATA_DIR, core.BACKUP_KEEP)
    core.audit_event('backup.created', 'governance', manifest['file'], f"cli;sha256={manifest['sha256'][:16]}")
    _print({**manifest, 'pruned': pruned})


def cmd_list(_):
    _print(backup.list_backups(core.DATA_DIR))


def cmd_verify_backup(args):
    result = backup.verify_backup(core.DATA_DIR, args.name)
    _print(result)
    return 0 if result['ok'] else 2


def cmd_restore(args):
    if not args.yes:
        answer = input(f'Replace {core.DB_PATH} with {args.name}? The server must be stopped. Type RESTORE: ')
        if answer.strip() != 'RESTORE':
            print('Cancelled.')
            return 1
    result = backup.restore_backup(core.DB_PATH, core.DATA_DIR, args.name, app_version=core.__version__)
    core.init_db()  # bring an older backup up to the current schema
    core.audit_event('backup.restored', 'governance', args.name, f"cli;safety={result['safety_backup']}")
    _print(result)


def cmd_import_loans(args):
    with open(args.csv, 'rb') as handle:
        raw = handle.read()
    conn = core.get_db()
    try:
        result = importer.run_import(conn, raw, os.path.basename(args.csv),
                                     'partial' if args.partial else 'strict', None, core.audit_event)
        conn.commit()
    except Exception:
        conn.rollback()
        raise
    finally:
        conn.close()
    _print(result)
    return 2 if result['rejected'] else 0


def cmd_obfuscate(args):
    target = args.output or os.path.join(core.DATA_DIR, 'mortgage_obfuscated.db')
    result = obfuscate.create_obfuscated_copy(core.DB_PATH, target)
    core.audit_event('data.obfuscated_copy', 'governance', os.path.basename(target),
                     f"loans={result['loans']};institutions={result['institutions_renamed']}")
    _print(result)


def cmd_verify_audit(_):
    result = core.verify_audit_chain()
    _print(result)
    return 0 if result['valid'] else 2


def cmd_health(_):
    conn = core.get_db()
    try:
        checks = health.run_checks(conn, core.verify_audit_chain,
                                   [] if core.DEMO_MODE else backup.list_backups(core.DATA_DIR), demo=core.DEMO_MODE)
    finally:
        conn.close()
    summary = health.summarize(checks)
    for check in checks:
        print(f"[{check['status'].upper():4}] {check['group']:<13} {check['label']:<58} {check['detail'] or ''}")
    print(f"\nOverall: {summary['status'].upper()} {summary['counts']}")
    return 0 if summary['status'] != 'fail' else 2


def main(argv=None):
    parser = argparse.ArgumentParser(description='Mortgage Banker Portal operations')
    sub = parser.add_subparsers(dest='command', required=True)
    sub.add_parser('status').set_defaults(func=cmd_status)
    sub.add_parser('migrate').set_defaults(func=cmd_migrate)
    b = sub.add_parser('backup')
    b.add_argument('--reason', default='manual')
    b.set_defaults(func=cmd_backup)
    sub.add_parser('list-backups').set_defaults(func=cmd_list)
    v = sub.add_parser('verify-backup')
    v.add_argument('name')
    v.set_defaults(func=cmd_verify_backup)
    r = sub.add_parser('restore')
    r.add_argument('name')
    r.add_argument('--yes', action='store_true', help='skip the confirmation prompt')
    r.set_defaults(func=cmd_restore)
    i = sub.add_parser('import-loans', help='validated loan CSV import (same rules as the Data Center)')
    i.add_argument('csv')
    i.add_argument('--partial', action='store_true', help='import valid rows even if some are invalid')
    i.set_defaults(func=cmd_import_loans)
    o = sub.add_parser('obfuscate', help='write a de-identified copy of the database (live DB untouched)')
    o.add_argument('--output', help='target .db path (default: <data dir>/mortgage_obfuscated.db)')
    o.set_defaults(func=cmd_obfuscate)
    sub.add_parser('verify-audit').set_defaults(func=cmd_verify_audit)
    sub.add_parser('health').set_defaults(func=cmd_health)
    args = parser.parse_args(argv)
    if args.command not in ('status', 'migrate', 'restore'):
        core.init_db()
    return args.func(args) or 0


if __name__ == '__main__':
    sys.exit(main())
