"""Post-migration section-skip logic and the OpenClaw first-run migration flow.

Extracted from hermes_cli/setup.py, which re-exports the names it still uses.
"""

import importlib.util
import logging
import sys
from functools import partial
from pathlib import Path
from typing import Optional

from hermes_constants import get_optional_skills_dir

logger = logging.getLogger("hermes_cli.setup")

PROJECT_ROOT = Path(__file__).parent.parent.resolve()


# ── Post-Migration Section Skip Logic ──

_OPENROUTER_ENV_VARS = ("OPENROUTER_API_KEY", "OPENAI_API_KEY")


def _model_section_has_credentials(config: dict) -> bool:
    """True when any known inference provider has usable credentials: ``active_provider`` in the
    auth store (OAuth providers), ``PROVIDER_REGISTRY`` ``api_key_env_vars``, or the legacy
    OpenRouter aggregator env vars (``OPENAI_API_KEY`` / ``OPENROUTER_API_KEY``)."""
    from hermes_cli.setup import get_env_value
    try:
        from hermes_cli.auth import get_active_provider
        if get_active_provider():
            return True
    except Exception:
        pass

    try:
        from hermes_cli.auth import PROVIDER_REGISTRY
    except Exception:
        PROVIDER_REGISTRY = {}  # type: ignore[assignment]

    def _has_key(pconfig) -> bool:
        # CLAUDE_CODE_OAUTH_TOKEN is set by Claude Code itself, not by the user —
        # mirrors is_provider_explicitly_configured in auth.py.
        return any(get_env_value(v) for v in pconfig.api_key_env_vars if v != "CLAUDE_CODE_OAUTH_TOKEN")

    def _any_openrouter_key() -> bool:
        return any(get_env_value(v) for v in _OPENROUTER_ENV_VARS)

    # Prefer the provider declared in config.yaml, avoids false positives from stray
    # env vars (GH_TOKEN, etc.) when the user has already picked a different provider.
    model_cfg = config.get("model") if isinstance(config, dict) else None
    if isinstance(model_cfg, dict):
        provider_id = (model_cfg.get("provider") or "").strip().lower()
        if provider_id in PROVIDER_REGISTRY and _has_key(PROVIDER_REGISTRY[provider_id]):
            return True
        if provider_id == "openrouter" and _any_openrouter_key():
            return True

    # OpenRouter aggregator fallback (no provider declared in config).
    if _any_openrouter_key():
        return True

    # Skip copilot in auto-detect: GH_TOKEN / GITHUB_TOKEN are commonly set for
    # git tooling.  Mirrors resolve_provider in auth.py.
    return any(_has_key(pconfig) for pid, pconfig in PROVIDER_REGISTRY.items() if pid != "copilot")


def _gateway_platform_short_label(label: str) -> str:
    """Strip trailing parenthetical qualifiers from a gateway platform label."""
    return label.split("(", 1)[0].strip() or label


def _model_summary(config: dict) -> Optional[str]:
    if not _model_section_has_credentials(config):
        return None
    model = config.get("model")
    if isinstance(model, str) and model.strip():
        return model.strip()
    if isinstance(model, dict):
        return str(model.get("default") or model.get("model") or "configured")
    return "configured"


def _cfg_summary(config: dict, section: str, key: str, default, prefix: str) -> str:
    from hermes_cli.setup import cfg_get
    return f"{prefix}{cfg_get(config, section, key, default=default)}"


def _gateway_summary(config: dict) -> Optional[str]:
    from hermes_cli.gateway import _all_platforms, _platform_status
    # Any non-empty status other than "not configured" counts — WhatsApp ("enabled, not paired"),
    # Matrix ("configured + E2EE"), Signal ("partially configured") mean setup already started.
    configured = [
        _gateway_platform_short_label(plat["label"])
        for plat in _all_platforms()
        if _platform_status(plat) and _platform_status(plat) != "not configured"
    ]
    return ", ".join(configured) if configured else None


_TOOL_ENV_LABELS = (
    ("ELEVENLABS_API_KEY", "TTS/ElevenLabs"),
    ("BROWSERBASE_API_KEY", "Browser"),
    ("FIRECRAWL_API_KEY", "Firecrawl"),
)


def _tools_summary(config: dict) -> Optional[str]:
    from hermes_cli.setup import get_env_value
    tools = [label for env_var, label in _TOOL_ENV_LABELS if get_env_value(env_var)]
    return ", ".join(tools) if tools else None


_SECTION_SUMMARIES = {
    "model": _model_summary,
    "terminal": partial(_cfg_summary, section="terminal", key="backend", default="local", prefix="backend: "),
    "agent": partial(_cfg_summary, section="agent", key="max_turns", default=90, prefix="max turns: "),
    "gateway": _gateway_summary,
    "tools": _tools_summary,
}


def _get_section_config_summary(config: dict, section_key: str) -> Optional[str]:
    """Return a short summary if a setup section is already configured, else None.

    Used after OpenClaw migration to detect which sections can be skipped. ``get_env_value`` is
    reached through hermes_cli.setup so that test patches on ``setup_mod.get_env_value`` apply.
    """
    summarize = _SECTION_SUMMARIES.get(section_key)
    return summarize(config) if summarize else None


def _skip_configured_section(config: dict, section_key: str, label: str) -> bool:
    """Show an already-configured section summary and offer to skip.

    Returns True if the user chose to skip, False if the section should run.
    """
    from hermes_cli.setup import print_success, prompt_yes_no
    summary = _get_section_config_summary(config, section_key)
    if not summary:
        return False
    print()
    print_success(f"  {label}: {summary}")
    return not prompt_yes_no(f"  Reconfigure {label.lower()}?", default=False)


# ── OpenClaw Migration ──

_OPENCLAW_SCRIPT = (
    get_optional_skills_dir(PROJECT_ROOT / "optional-skills")
    / "migration" / "openclaw-migration" / "scripts" / "openclaw_to_hermes.py"
)


def _load_openclaw_migration_module():
    """Load the openclaw_to_hermes migration script as a module; None if it can't be loaded."""
    from hermes_cli.setup import _OPENCLAW_SCRIPT
    if not _OPENCLAW_SCRIPT.exists():
        return None
    spec = importlib.util.spec_from_file_location("openclaw_to_hermes", _OPENCLAW_SCRIPT)
    if spec is None or spec.loader is None:
        return None
    mod = importlib.util.module_from_spec(spec)
    # Register in sys.modules so @dataclass can resolve the module
    # (Python 3.11+ requires this for dynamically loaded modules)
    sys.modules[spec.name] = mod
    try:
        spec.loader.exec_module(mod)
    except Exception:
        sys.modules.pop(spec.name, None)
        raise
    return mod


# Item kinds that warrant explicit warnings: gateway tokens/channels hijack the old agent's
# platforms; config values and instruction/context .md files may not map 1:1 to Hermes.
_HIGH_IMPACT_KIND_KEYWORDS = {
    "gateway": "⚠ Gateway/messaging — this will configure Hermes to use your OpenClaw messaging channels",
    "telegram": "⚠ Telegram — this will point Hermes at your OpenClaw Telegram bot",
    "slack": "⚠ Slack — this will point Hermes at your OpenClaw Slack workspace",
    "discord": "⚠ Discord — this will point Hermes at your OpenClaw Discord bot",
    "whatsapp": "⚠ WhatsApp — this will point Hermes at your OpenClaw WhatsApp connection",
    "config": "⚠ Config values — OpenClaw settings may not map 1:1 to Hermes equivalents",
    "soul": "⚠ Instruction file — may contain OpenClaw-specific setup/restart procedures",
    "memory": "⚠ Memory/context file — may reference OpenClaw-specific infrastructure",
    "context": "⚠ Context file — may contain OpenClaw-specific instructions",
}

_MIGRATION_WARNING_NOTES = (
    "  Note: OpenClaw config values may have different semantics in Hermes.",
    "  For example, OpenClaw's tool_call_execution: \"auto\" ≠ Hermes's yolo mode.",
    "  Instruction files (.md) from OpenClaw may contain incompatible procedures.",
)


def _migrated_row(item: dict, kind: str) -> str:
    dest = item.get("destination", "")
    if dest:
        return f"      {kind:<22s} → {str(dest).replace(str(Path.home()), '~')}"
    return f"      {kind}"


def _reason_row(default_reason: str, item: dict, kind: str) -> str:
    return f"      {kind:<22s}  {item.get('reason', default_reason)}"


def _print_migration_preview(report: dict):
    """Dry-run preview grouped by status, with warnings for high-impact items (gateway takeover,
    config semantics)."""
    from hermes_cli.setup import color, Colors, print_info
    items = report.get("items", [])
    if not items:
        print_info("Nothing to migrate.")
        return

    groups = (
        ("migrated", "  Would import:", Colors.GREEN, _migrated_row),
        ("conflict", "  Would overwrite (conflicts with existing Hermes config):", Colors.YELLOW,
         partial(_reason_row, "already exists")),
        ("skipped", "  Would skip:", Colors.DIM, partial(_reason_row, "")),
    )
    warnings_shown = set()
    for status, header, col, row in groups:
        group = [i for i in items if i.get("status") == status]
        if not group:
            continue
        print(color(header, col))
        for item in group:
            kind = item.get("kind", "unknown")
            print(row(item, kind))
            if status == "migrated":  # collect warnings for high-impact items
                kind_lower, dest_lower = kind.lower(), str(item.get("destination", "")).lower()
                warnings_shown.update(
                    w for kw, w in _HIGH_IMPACT_KIND_KEYWORDS.items() if kw in kind_lower or kw in dest_lower
                )
        print()

    if warnings_shown:
        print(color("  ── Warnings ──", Colors.YELLOW))
        for warning in sorted(warnings_shown):
            print(color(f"    {warning}", Colors.YELLOW))
        print()
        for line in _MIGRATION_WARNING_NOTES:
            print(color(line, Colors.YELLOW))
        print()


def _run_migrator(mod, openclaw_dir: Path, hermes_home: Path, selected, *, execute: bool, overwrite: bool):
    """Run a Migrator with the fixed first-time-setup options and return its report."""
    return mod.Migrator(
        source_root=openclaw_dir.resolve(), target_root=hermes_home.resolve(), execute=execute,
        workspace_target=None, overwrite=overwrite, migrate_secrets=True, output_dir=None,
        selected_options=selected, preset_name="full",
    ).migrate()


def _offer_openclaw_migration(hermes_home: Path) -> bool:
    """Detect ~/.openclaw and offer to migrate during first-time setup: dry-run preview first,
    execute only after explicit confirmation. Returns True iff migration ran successfully."""
    from hermes_cli.setup import (
        get_config_path, _info, load_config, _OPENCLAW_SCRIPT, print_header, print_info, print_success,
        print_warning, prompt_yes_no, save_config,
    )
    openclaw_dir = Path.home() / ".openclaw"
    if not openclaw_dir.is_dir() or not _OPENCLAW_SCRIPT.exists():
        return False

    print()
    print_header("OpenClaw Installation Detected")
    _info(f"Found OpenClaw data at {openclaw_dir}",
          "Hermes can preview what would be imported before making any changes.", None)
    if not prompt_yes_no("Would you like to see what can be imported?", default=True):
        print_info("Skipping migration. You can run it later with: hermes claw migrate --dry-run")
        return False

    # Ensure config.yaml exists before migration tries to read it
    if not get_config_path().exists():
        save_config(load_config())

    try:
        mod = _load_openclaw_migration_module()
        if mod is None:
            print_warning("Could not load migration script.")
            return False
    except Exception as e:
        print_warning(f"Could not load migration script: {e}")
        logger.debug("OpenClaw migration module load error", exc_info=True)
        return False

    # ── Phase 1: Dry-run preview (overwrite=True shows everything, including conflicts) ──
    try:
        selected = mod.resolve_selected_options(None, None, preset="full")
        preview_report = _run_migrator(mod, openclaw_dir, hermes_home, selected, execute=False, overwrite=True)
    except Exception as e:
        print_warning(f"Migration preview failed: {e}")
        logger.debug("OpenClaw migration preview error", exc_info=True)
        return False

    preview_count = preview_report.get("summary", {}).get("migrated", 0)
    if preview_count == 0:
        _info(None, "Nothing to import from OpenClaw.")
        return False
    print()
    print_header(f"Migration Preview — {preview_count} item(s) would be imported")
    _info("No changes have been made yet. Review the list below:", None)
    _print_migration_preview(preview_report)

    # ── Phase 2: Confirm and execute ──
    if not prompt_yes_no("Proceed with migration?", default=False):
        _info("Migration cancelled. You can run it later with: hermes claw migrate",
              "Use --dry-run to preview again, or --preset minimal for a lighter import.")
        return False

    # overwrite=False so existing Hermes configs are preserved. The user saw the
    # preview; conflicts are skipped by default.
    try:
        report = _run_migrator(mod, openclaw_dir, hermes_home, selected, execute=True, overwrite=False)
    except Exception as e:
        print_warning(f"Migration failed: {e}")
        logger.debug("OpenClaw migration error", exc_info=True)
        return False

    summary = report.get("summary", {})
    migrated, skipped = summary.get("migrated", 0), summary.get("skipped", 0)
    conflicts, errors = summary.get("conflict", 0), summary.get("error", 0)
    print()
    for count, printer, text in (
        (migrated, print_success, f"Imported {migrated} item(s) from OpenClaw."),
        (conflicts, print_info,
         f"Skipped {conflicts} item(s) that already exist in Hermes (use hermes claw migrate --overwrite to force)."),
        (skipped, print_info, f"Skipped {skipped} item(s) (not found or unchanged)."),
        (errors, print_warning, f"{errors} item(s) had errors — check the migration report."),
    ):
        if count:
            printer(text)

    output_dir = report.get("output_dir")
    if output_dir:
        print_info(f"Full report saved to: {output_dir}")
    print_success("Migration complete! Continuing with setup...")
    return True