"""Convert Claude Code subagents into Codex custom-agent TOML.

Reads `.claude/agents/*.md` files, parses their frontmatter/body, and emits
`.codex/agents/<name>.toml` artifacts. Partially mapped metadata such as
skills, tool allowlists, and unknown permission modes is preserved as prompt
guidance plus a manual-review report row.
"""

from __future__ import annotations

import tomllib
from pathlib import Path

from migrate.common import (
    CODEX_AGENTS_ROOT,
    ConversionResult,
    MigrationReportItem,
    ParsedDocument,
    PlannedArtifact,
    append_report_item,
    format_bullets,
    format_manual_migration_block,
    map_model_effort,
    map_model_name,
    map_permission_mode,
    unsupported_frontmatter_fields,
)
from utils.util import (
    TomlMultilineString,
    first_markdown_heading,
    render_toml_document,
    slugify_name,
)


AGENT_SOURCE_ROOTS = (
    Path(".claude") / "agents",
)
SUPPORTED_AGENT_FRONTMATTER = (
    "name",
    "description",
    "model",
    "permissionMode",
    "skills",
    "tools",
    "disallowedTools",
    "effort",
)


def iter_agent_files(source_root: Path) -> tuple[Path, ...]:
    if not source_root.exists():
        return ()
    return tuple(
        source_file
        for source_file in sorted(source_root.glob("*.md"))
        if source_file.stem != "README"
    )


def agent_metadata(source_file: Path, document: ParsedDocument) -> dict[str, object]:
    inferred_fields: list[str] = []
    name = document.frontmatter.optional_string("name")
    if not name:
        name = slugify_name(source_file.stem)
        inferred_fields.append("name")

    description = document.frontmatter.optional_string("description")
    if not description:
        heading = first_markdown_heading(document.body)
        if heading:
            description = f"Migrated Claude subagent inferred from heading `{heading}`."
        else:
            description = f"Migrated Claude subagent inferred from `{source_file.name}`."
        inferred_fields.append("description")

    return {
        "name": name,
        "description": description,
        "model": document.frontmatter.optional_string("model"),
        "permission_mode": document.frontmatter.optional_string("permissionMode"),
        "skills": document.frontmatter.string_tuple("skills"),
        "tools": document.frontmatter.string_tuple("tools"),
        "disallowed_tools": document.frontmatter.string_tuple("disallowedTools"),
        "effort": document.frontmatter.optional_string("effort"),
        "unsupported_fields": unsupported_frontmatter_fields(
            document.frontmatter.to_dict(),
            SUPPORTED_AGENT_FRONTMATTER,
        )
        + tuple(inferred_fields),
    }


def convert_agent_file(source_file: Path) -> tuple[PlannedArtifact, MigrationReportItem]:
    document = ParsedDocument.from_file(source_file)
    metadata = agent_metadata(source_file, document)
    artifact = PlannedArtifact.for_agent(
        source_file,
        render_agent_toml(document.body, **metadata),
    )
    return artifact, agent_report_item(source_file, **metadata)


def render_agent_toml(
    body: str,
    *,
    name: str,
    description: str,
    model: str | None,
    permission_mode: str | None,
    skills: tuple[str, ...],
    tools: tuple[str, ...],
    disallowed_tools: tuple[str, ...],
    effort: str | None,
    unsupported_fields: tuple[str, ...],
) -> str:
    document = {
        "name": name,
        "description": description,
    }

    if model:
        document["model"] = map_model_name(model)
    if effort:
        document["model_reasoning_effort"] = map_model_effort(model, effort)
    sandbox_mode = map_permission_mode(permission_mode)
    if sandbox_mode:
        document["sandbox_mode"] = sandbox_mode

    document["developer_instructions"] = TomlMultilineString(
        render_agent_body(
            body,
            permission_mode=permission_mode,
            skills=skills,
            tools=tools,
            disallowed_tools=disallowed_tools,
            unsupported_fields=unsupported_fields,
        ).strip()
    )

    return render_toml_document(document)


def render_agent_body(
    body: str,
    *,
    permission_mode: str | None,
    skills: tuple[str, ...],
    tools: tuple[str, ...],
    disallowed_tools: tuple[str, ...],
    unsupported_fields: tuple[str, ...],
) -> str:
    sections = []
    manual_notes: list[str] = []

    sandbox_mode = map_permission_mode(permission_mode)
    if permission_mode and not sandbox_mode:
        manual_notes.append(
            f"Claude `permissionMode: {permission_mode}` has no direct Codex mapping. "
            "Manually choose `sandbox_mode`, `[permissions]`, MCP tool filters, or app tool filters before relying on this agent."
        )

    if skills:
        sections.append(
            "## Skills\n\n"
            "You're allowed to use these skills when working on this task:\n\n"
            f"{format_bullets(skills, '$')}"
        )
        manual_notes.append(
            "Claude `skills` preload semantics were preserved as prompt guidance. Verify this agent still discovers the intended skills at runtime."
        )

    if tools or disallowed_tools:
        tool_section_lines = [
            "## Tools",
            "",
            "Claude tool allow/deny lists were preserved as prompt guidance, not Codex permissions.",
        ]
        if tools:
            tool_section_lines.extend(
                [
                    "",
                    "You're allowed to use these tools:",
                    "",
                    format_bullets(tools),
                ]
            )
        if disallowed_tools:
            tool_section_lines.extend(
                [
                    "",
                    "Don't use these tools:",
                    "",
                    format_bullets(disallowed_tools),
                ]
            )
        sections.append("\n".join(tool_section_lines))
        manual_notes.append(
            "Rebuild Claude `tools` / `disallowedTools` intent with Codex sandbox, MCP tool filters, or app tool filters if you need hard enforcement."
        )

    if unsupported_fields:
        manual_notes.append(
            "Review unsupported Claude subagent fields manually: "
            f"{', '.join(f'`{field_name}`' for field_name in unsupported_fields)}."
        )

    if manual_notes:
        sections.append(format_manual_migration_block(manual_notes))

    if not sections:
        return body

    joined_sections = "\n\n".join(sections)
    return f"{body.rstrip()}\n\n{joined_sections}\n"


def agent_report_detail(
    *,
    permission_mode: str | None,
    skills: tuple[str, ...],
    tools: tuple[str, ...],
    disallowed_tools: tuple[str, ...],
    unsupported_fields: tuple[str, ...],
    **_: object,
) -> str:
    caveats: list[str] = []
    if skills:
        caveats.append("skills")
    if tools:
        caveats.append("tools")
    if disallowed_tools:
        caveats.append("disallowedTools")
    if permission_mode and not map_permission_mode(permission_mode):
        caveats.append("permissionMode")
    caveats.extend(unsupported_fields)
    if not caveats:
        return "Converted Claude subagent."
    return (
        "Manual review required for Claude subagent fields: "
        + ", ".join(f"`{field_name}`" for field_name in caveats)
        + "."
    )


def agent_report_item(
    source_file: Path,
    *,
    permission_mode: str | None,
    skills: tuple[str, ...],
    tools: tuple[str, ...],
    disallowed_tools: tuple[str, ...],
    unsupported_fields: tuple[str, ...],
    **metadata: object,
) -> MigrationReportItem:
    report_items: list[MigrationReportItem] = []
    detail = agent_report_detail(
        permission_mode=permission_mode,
        skills=skills,
        tools=tools,
        disallowed_tools=disallowed_tools,
        unsupported_fields=unsupported_fields,
        **metadata,
    )
    append_report_item(
        report_items,
        skills
        or tools
        or disallowed_tools
        or (permission_mode and not map_permission_mode(permission_mode))
        or unsupported_fields,
        CODEX_AGENTS_ROOT / f"{source_file.stem}.toml",
        detail,
        detail,
    )
    return report_items[0]


def convert_agents(source_root: Path) -> ConversionResult:
    return convert_agent_files(source_root / ".claude" / "agents")


def convert_agent_files(source_root: Path) -> ConversionResult:
    result = ConversionResult()
    for source_file in iter_agent_files(source_root):
        artifact, report_item = convert_agent_file(source_file)
        result.artifacts.append(artifact)
        result.summary.subagents += 1
        result.report_items.append(report_item)
    return result


def validate_agent_files(target_root: Path) -> list[MigrationReportItem]:
    agents_root = target_root / CODEX_AGENTS_ROOT
    if not agents_root.exists():
        return []

    report_items: list[MigrationReportItem] = []
    for agent_file in sorted(agents_root.glob("*.toml")):
        relative_path = agent_file.relative_to(target_root)
        try:
            parsed = tomllib.loads(agent_file.read_text())
        except tomllib.TOMLDecodeError as exc:
            report_items.append(
                MigrationReportItem("error", relative_path, f"invalid TOML: {exc}.")
            )
            continue

        missing = [
            key
            for key in ("name", "description", "developer_instructions")
            if not parsed.get(key)
        ]
        if missing:
            report_items.append(
                MigrationReportItem(
                    "error",
                    relative_path,
                    "agent TOML missing " + ", ".join(missing) + ".",
                )
            )
            continue
        report_items.append(
            MigrationReportItem("ok", relative_path, "agent TOML has required fields.")
        )
    return report_items

"""Render Codex config from Claude Code settings and MCP inputs.

This module owns `.codex/config.toml` generation. It reads Claude Code
settings for model/sandbox equivalents, asks `mcps.py` for MCP server tables,
and adds Codex-native defaults that are not MCP-specific, such as the friendly
personality used for Claude Code migrations.
"""

from __future__ import annotations

import tomllib
from pathlib import Path

from migrate.common import (
    CODEX_CONFIG_PATH,
    ConversionResult,
    GeneratedText,
    MigrationReportItem,
    MigrationSummary,
    PlannedArtifact,
    ScopePaths,
    json_string,
    json_string_tuple,
    load_scope_settings,
    map_model_name,
    map_permission_mode,
)
from migrate.hooks import has_convertible_hooks
from migrate.mcps import (
    mcp_report_items,
    mcp_server_toml_table,
    read_claude_mcp_servers,
    validate_mcp_commands,
)
from utils.util import TomlValue, render_toml_document


DEFAULT_CODEX_PERSONALITY = "friendly"


def convert_settings(scope: ScopePaths) -> ConversionResult:
    settings = load_scope_settings(scope.source)
    mcp_servers = read_claude_mcp_servers(scope.source)
    if not settings and not mcp_servers:
        return ConversionResult()

    enabled_mcp_servers = json_string_tuple(settings.get("enabledMcpjsonServers"))
    disabled_mcp_servers = frozenset(
        json_string_tuple(settings.get("disabledMcpjsonServers"))
    )
    config_toml = render_codex_config(
        model=json_string(settings.get("model")),
        permission_mode=json_string(settings.get("permissionMode")),
        enabled_mcp_servers=enabled_mcp_servers,
        disabled_mcp_servers=disabled_mcp_servers,
        mcp_servers=mcp_servers,
        codex_hooks_enabled=has_convertible_hooks(scope.source),
    )
    if not config_toml.strip():
        return ConversionResult()
    return ConversionResult(
        summary=MigrationSummary(mcp_servers=len(mcp_servers)),
        artifacts=[
            PlannedArtifact(
                relative_path=CODEX_CONFIG_PATH,
                payload=GeneratedText(config_toml),
            )
        ],
        report_items=mcp_report_items(mcp_servers),
    )


def render_codex_config(
    model: str | None,
    permission_mode: str | None,
    enabled_mcp_servers: tuple[str, ...],
    disabled_mcp_servers: frozenset[str],
    mcp_servers: tuple[tuple[str, dict[str, object]], ...],
    codex_hooks_enabled: bool,
) -> str:
    document: dict[str, TomlValue] = {}
    if model:
        document["model"] = map_model_name(model)
    sandbox_mode = map_permission_mode(permission_mode)
    if sandbox_mode:
        document["sandbox_mode"] = sandbox_mode

    if mcp_servers:
        document["mcp_servers"] = {
            server_name: mcp_server_toml_table(
                server_name,
                server_config,
                enabled_mcp_servers,
                disabled_mcp_servers,
            )
            for server_name, server_config in mcp_servers
        }

    if codex_hooks_enabled:
        document["features"] = {"codex_hooks": True}

    if document:
        document = {"personality": DEFAULT_CODEX_PERSONALITY, **document}

    return render_toml_document(document)


def validate_config_toml(target_root: Path) -> list[MigrationReportItem]:
    config_path = target_root / CODEX_CONFIG_PATH
    if not config_path.exists():
        return [
            MigrationReportItem(
                "warning",
                CODEX_CONFIG_PATH,
                "not present; no Codex config to validate.",
            )
        ]

    try:
        parsed = tomllib.loads(config_path.read_text())
    except tomllib.TOMLDecodeError as exc:
        return [
            MigrationReportItem(
                "error",
                CODEX_CONFIG_PATH,
                f"invalid TOML: {exc}.",
            )
        ]

    report_items = [
        MigrationReportItem("ok", CODEX_CONFIG_PATH, "valid TOML."),
    ]
    report_items.extend(validate_mcp_commands(parsed))
    return report_items

"""Shared data models, frontmatter rendering, reporting, and path helpers.

Defines the artifact/report model used by every migration section, the
YAML-frontmatter adapter used for skills/agents/commands, Claude-model and
permission-mode partial mappings, and generic filesystem/report helpers. This
module should not know about one migration surface's control flow.
"""

from __future__ import annotations

import re
from collections.abc import Mapping, Sequence
from dataclasses import dataclass, field, fields as dataclass_fields
from enum import Enum
from pathlib import Path
from typing import TypeAlias

from migrate.settings import CLAUDE_SETTINGS_JSON_RELATIVE
from utils.util import (
    format_yaml_mapping,
    parse_yaml_mapping,
    read_json_mapping_file,
)


FRONTMATTER_RE = re.compile(r"\A---\n(.*?)\n---\n?(.*)\Z", re.S)
CODEX_CONFIG_PATH = Path(".codex") / "config.toml"
CODEX_AGENTS_ROOT = Path(".codex") / "agents"
CODEX_SKILLS_ROOT = Path(".agents") / "skills"
SUMMARY_LABELS = {
    "mcp_servers": "mcp servers",
}
PERMISSION_MODE_MAPPINGS = {
    "acceptEdits": "workspace-write",
    "readOnly": "read-only",
}
YamlScalar: TypeAlias = str | bool | int | float | None
YamlValue: TypeAlias = YamlScalar | Sequence[YamlScalar]


@dataclass(frozen=True)
class ScopePaths:
    source: Path
    is_global: bool


@dataclass(frozen=True)
class ModelMapping:
    source_prefix: str
    target_model: str
    effort_mapping: tuple[tuple[str, str], ...]

    def map_effort(self, effort: str) -> str:
        for source_effort, target_effort in self.effort_mapping:
            if effort == source_effort:
                return target_effort
        return effort


MODEL_PREFIX_MAPPINGS = (
    ModelMapping(
        "claude-opus",
        "gpt-5.4",
        (("low", "low"), ("medium", "medium"), ("high", "high"), ("max", "xhigh")),
    ),
    ModelMapping(
        "claude-sonnet",
        "gpt-5.4-mini",
        (("low", "medium"), ("medium", "high"), ("high", "xhigh"), ("max", "xhigh")),
    ),
    ModelMapping(
        "claude-haiku",
        "gpt-5.4-mini",
        (("low", "low"), ("medium", "medium"), ("high", "high"), ("max", "xhigh")),
    ),
)


class ArtifactKind(Enum):
    FILE = "file"
    SKILL = "skill"
    AGENT = "agent"


@dataclass(frozen=True)
class GeneratedText:
    content: str


@dataclass(frozen=True)
class SourceCopy:
    source_path: Path


@dataclass(frozen=True)
class SourceSymlink:
    source_path: Path


ArtifactPayload: TypeAlias = GeneratedText | SourceCopy | SourceSymlink


@dataclass(frozen=True)
class MigrationReportItem:
    status: str
    path: Path
    detail: str


@dataclass(frozen=True)
class SimpleYamlFrontmatter:
    values: dict[str, YamlValue]

    def required_string(self, key: str) -> str:
        return str(self.values[key])

    def optional_string(self, key: str) -> str | None:
        value = self.values.get(key)
        if value is None:
            return None
        return str(value)

    def string_tuple(self, key: str) -> tuple[str, ...]:
        value = self.values.get(key)
        if value is None:
            return ()

        if isinstance(value, Sequence) and not isinstance(value, (str, bytes)):
            return tuple(str(item).strip() for item in value if str(item).strip())

        return tuple(
            split_item
            for split_item in (part.strip() for part in str(value).split(","))
            if split_item
        )

    def to_dict(self) -> dict[str, YamlValue]:
        return self.values


@dataclass(frozen=True)
class ParsedDocument:
    frontmatter: SimpleYamlFrontmatter
    body: str
    path: Path | None = None

    @classmethod
    def from_file(cls, source_file: Path) -> ParsedDocument:
        return parse_frontmatter(source_file.read_text(), source_file)


@dataclass(frozen=True)
class PlannedArtifact:
    relative_path: Path
    payload: ArtifactPayload
    kind: ArtifactKind = ArtifactKind.FILE

    @classmethod
    def for_skill(cls, source_file: Path, content: str) -> PlannedArtifact:
        return cls(
            relative_path=CODEX_SKILLS_ROOT / source_file.parent.name / "SKILL.md",
            payload=GeneratedText(content),
            kind=ArtifactKind.SKILL,
        )

    @classmethod
    def for_agent(cls, source_file: Path, content: str) -> PlannedArtifact:
        return cls(
            relative_path=CODEX_AGENTS_ROOT / f"{source_file.stem}.toml",
            payload=GeneratedText(content),
            kind=ArtifactKind.AGENT,
        )

    @classmethod
    def from_source_file(
        cls, source_file: Path, relative_path: Path
    ) -> PlannedArtifact:
        return cls(
            relative_path=relative_path,
            payload=SourceCopy(source_file),
        )

    def prefixed(self, prefix: Path) -> PlannedArtifact:
        return PlannedArtifact(
            relative_path=prefix / self.relative_path,
            payload=self.payload,
            kind=self.kind,
        )

    def without_prefix(self) -> PlannedArtifact:
        return PlannedArtifact(
            relative_path=Path(*self.relative_path.parts[1:]),
            payload=self.payload,
            kind=self.kind,
        )

@dataclass
class MigrationSummary:
    instructions: int = 0
    skills: int = 0
    subagents: int = 0
    mcp_servers: int = 0
    orphaned_skills: int = 0
    orphaned_subagents: int = 0

    def add(self, other: MigrationSummary) -> None:
        for summary_field in dataclass_fields(self):
            field_name = summary_field.name
            setattr(
                self,
                field_name,
                getattr(self, field_name) + getattr(other, field_name),
            )

    def render(self, deploy_mode: object, dry_run: bool) -> str:
        suffix = " (dry-run)" if dry_run else ""
        deploy_mode_value = getattr(deploy_mode, "value", str(deploy_mode))
        lines = [
            f"Migration summary{suffix}:",
            f"  deploy mode: {deploy_mode_value}",
        ]
        for summary_field in dataclass_fields(self):
            field_name = summary_field.name
            value = getattr(self, field_name)
            label = SUMMARY_LABELS.get(field_name, field_name.replace("_", " "))
            lines.append(f"  {label}: {value}")
        return "\n".join(lines)


@dataclass
class ConversionResult:
    summary: MigrationSummary = field(default_factory=MigrationSummary)
    artifacts: list[PlannedArtifact] = field(default_factory=list)
    report_items: list[MigrationReportItem] = field(default_factory=list)

    def add(self, other: ConversionResult) -> None:
        self.summary.add(other.summary)
        self.artifacts.extend(other.artifacts)
        self.report_items.extend(other.report_items)

    def prefixed(self, prefix: Path) -> ConversionResult:
        return ConversionResult(
            summary=self.summary,
            artifacts=[artifact.prefixed(prefix) for artifact in self.artifacts],
            report_items=[
                MigrationReportItem(
                    item.status,
                    prefix / item.path,
                    item.detail,
                )
                for item in self.report_items
            ],
        )


def json_object(value: object) -> Mapping[str, object]:
    if isinstance(value, Mapping):
        return value
    return {}


def json_string(value: object) -> str | None:
    if value is None:
        return None
    return str(value)


def json_string_tuple(value: object) -> tuple[str, ...]:
    if value is None:
        return ()
    if isinstance(value, Sequence) and not isinstance(value, (str, bytes)):
        return tuple(str(item) for item in value)
    return (str(value),)


def load_scope_settings(scope_root: Path) -> Mapping[str, object]:
    settings: dict[str, object] = {}
    for rel in CLAUDE_SETTINGS_JSON_RELATIVE:
        outcome = read_json_mapping_file(scope_root / rel)
        if outcome.exists and outcome.ok:
            settings.update(json_object(outcome.data))
    return settings


def format_bullets(values: Sequence[str], prefix: str = "") -> str:
    return "\n".join(f"- {prefix}{value}" for value in values)


def format_manual_migration_block(notes: Sequence[str]) -> str:
    return "## MANUAL MIGRATION REQUIRED\n\n" + "\n\n".join(
        note.rstrip() for note in notes if note.strip()
    )


def unsupported_frontmatter_fields(
    frontmatter_values: Mapping[str, YamlValue],
    supported_fields: Sequence[str],
) -> tuple[str, ...]:
    supported = frozenset(supported_fields)
    return tuple(
        sorted(
            field_name
            for field_name in frontmatter_values
            if field_name not in supported
        )
    )


def append_report_item(
    report_items: list[MigrationReportItem],
    requires_manual_fix: object,
    path: Path,
    manual_detail: str,
    rewritten_detail: str,
) -> None:
    if requires_manual_fix:
        report_items.append(manual_report_item(path, manual_detail))
        return
    report_items.append(MigrationReportItem("rewritten", path, rewritten_detail))


def manual_report_item(path: Path, detail: str) -> MigrationReportItem:
    return MigrationReportItem("manual_fix_required", path, detail)


def report_manual_paths(
    scope: ScopePaths,
    path_labels: Sequence[tuple[Path, str]],
) -> ConversionResult:
    result = ConversionResult()

    for relative_path, label in path_labels:
        if path_exists_with_exact_case(scope.source / relative_path):
            result.report_items.append(
                manual_report_item(
                    relative_path,
                    f"Manual review required for {label}; not converted by this tool.",
                )
            )

    return result


def path_exists_with_exact_case(path: Path) -> bool:
    if not path.exists():
        return False
    try:
        return path.name in {child.name for child in path.parent.iterdir()}
    except FileNotFoundError:
        return False


def is_path_within_root(path: Path, root: Path) -> bool:
    try:
        path.resolve().relative_to(root.resolve())
    except ValueError:
        return False
    return True


def parse_frontmatter(content: str, path: Path | None = None) -> ParsedDocument:
    match = FRONTMATTER_RE.match(content)
    if not match:
        return ParsedDocument(SimpleYamlFrontmatter({}), content, path)

    raw_frontmatter, body = match.groups()
    return ParsedDocument(parse_yaml_frontmatter(raw_frontmatter, path), body, path)


def parse_yaml_frontmatter(
    content: str,
    path: Path | None = None,
) -> SimpleYamlFrontmatter:
    return SimpleYamlFrontmatter(parse_yaml_mapping(content))


def format_frontmatter(frontmatter: SimpleYamlFrontmatter, body: str) -> str:
    rendered = format_yaml_mapping(frontmatter.to_dict())
    return f"---\n{rendered}\n---\n\n{body.lstrip()}"


def map_model_name(model: str) -> str:
    for mapping in MODEL_PREFIX_MAPPINGS:
        if model.startswith(mapping.source_prefix):
            return mapping.target_model
    return model


def map_model_effort(model: str | None, effort: str) -> str:
    if not model:
        return effort
    for mapping in MODEL_PREFIX_MAPPINGS:
        if model.startswith(mapping.source_prefix):
            return mapping.map_effort(effort)
    return effort


def map_permission_mode(permission_mode: str | None) -> str | None:
    if not permission_mode:
        return None
    return PERMISSION_MODE_MAPPINGS.get(permission_mode)

"""Convert supported Claude Code hooks into Codex hook config."""

from __future__ import annotations

import json
from collections.abc import Mapping, Sequence
from dataclasses import dataclass
from pathlib import Path

from migrate.common import (
    ConversionResult,
    GeneratedText,
    MigrationReportItem,
    PlannedArtifact,
    ScopePaths,
    json_object,
    json_string,
    path_exists_with_exact_case,
    read_json_mapping_file,
)
from migrate.settings import CLAUDE_SETTINGS_JSON_RELATIVE


CODEX_HOOKS_PATH = Path(".codex") / "hooks.json"
CODEX_HOOK_EVENTS = (
    "PreToolUse",
    "PostToolUse",
    "SessionStart",
    "UserPromptSubmit",
    "Stop",
)
CODEX_HOOK_MATCHER_EVENTS = frozenset(("PreToolUse", "PostToolUse", "SessionStart"))


@dataclass(frozen=True)
class ClaudeHookCommand:
    command: str
    timeout_sec: int | None = None
    status_message: str | None = None

    @classmethod
    def from_mapping(cls, hook_config: Mapping[str, object]) -> ClaudeHookCommand | None:
        command = json_string(hook_config.get("command"))
        if command is None or not command.strip():
            return None

        timeout_value = hook_config.get("timeout")
        if timeout_value is None:
            timeout_value = hook_config.get("timeoutSec")

        return cls(
            command=command,
            timeout_sec=json_int(timeout_value),
            status_message=json_string(hook_config.get("statusMessage")),
        )

    def to_mapping(self) -> dict[str, object]:
        result: dict[str, object] = {
            "type": "command",
            "command": self.command,
        }
        if self.timeout_sec is not None:
            result["timeout"] = self.timeout_sec
        if self.status_message is not None:
            result["statusMessage"] = self.status_message
        return result


@dataclass(frozen=True)
class ClaudeHookMatcherGroup:
    event_name: str
    matcher: str | None
    hooks: tuple[ClaudeHookCommand, ...]

    def to_mapping(self) -> dict[str, object]:
        result: dict[str, object] = {
            "hooks": [hook.to_mapping() for hook in self.hooks],
        }
        if self.matcher is not None:
            result["matcher"] = self.matcher
        return result


@dataclass(frozen=True)
class ClaudeHooks:
    matcher_groups: tuple[ClaudeHookMatcherGroup, ...] = ()
    source_paths: tuple[Path, ...] = ()
    unsupported_fields: tuple[str, ...] = ()

    @classmethod
    def from_scope(cls, scope_root: Path) -> ClaudeHooks:
        hook_sets = [
            cls.from_settings_mapping(relative_path, outcome.data)
            for relative_path in CLAUDE_SETTINGS_JSON_RELATIVE
            if path_exists_with_exact_case(scope_root / relative_path)
            for outcome in (read_json_mapping_file(scope_root / relative_path),)
            if outcome.exists and outcome.ok
        ]
        return cls(
            matcher_groups=tuple(
                matcher_group
                for hook_set in hook_sets
                for matcher_group in hook_set.matcher_groups
            ),
            source_paths=tuple(
                source_path
                for hook_set in hook_sets
                for source_path in hook_set.source_paths
            ),
            unsupported_fields=tuple(
                unsupported_field
                for hook_set in hook_sets
                for unsupported_field in hook_set.unsupported_fields
            ),
        )

    @classmethod
    def from_settings_mapping(
        cls,
        relative_path: Path,
        settings: Mapping[str, object],
    ) -> ClaudeHooks:
        hooks_config = json_object(settings.get("hooks"))
        if not hooks_config:
            return cls()

        matcher_groups: list[ClaudeHookMatcherGroup] = []
        unsupported_fields: list[str] = []
        for event_name, groups_value in hooks_config.items():
            if event_name not in CODEX_HOOK_EVENTS:
                unsupported_fields.append(f"hooks.{event_name}")
                continue

            for group_config in json_object_tuple(groups_value):
                matcher = json_string(group_config.get("matcher"))
                if matcher is not None and event_name not in CODEX_HOOK_MATCHER_EVENTS:
                    unsupported_fields.append(f"hooks.{event_name}.matcher")
                    matcher = None
                if "if" in group_config:
                    unsupported_fields.append(f"hooks.{event_name}.if")

                hook_commands: list[ClaudeHookCommand] = []
                for hook_config in json_object_tuple(group_config.get("hooks")):
                    hook_type = json_string(hook_config.get("type")) or "command"
                    if hook_type != "command":
                        unsupported_fields.append(
                            f"hooks.{event_name}.hooks[].type:{hook_type}"
                        )
                        continue
                    if bool(hook_config.get("async")):
                        unsupported_fields.append(f"hooks.{event_name}.hooks[].async")
                        continue

                    hook_command = ClaudeHookCommand.from_mapping(hook_config)
                    if hook_command is None:
                        unsupported_fields.append(f"hooks.{event_name}.hooks[].command")
                        continue
                    hook_commands.append(hook_command)

                if hook_commands:
                    matcher_groups.append(
                        ClaudeHookMatcherGroup(
                            event_name=event_name,
                            matcher=matcher,
                            hooks=tuple(hook_commands),
                        )
                    )

        return cls(
            matcher_groups=tuple(matcher_groups),
            source_paths=(relative_path,),
            unsupported_fields=tuple(sorted(set(unsupported_fields))),
        )

    def render_codex_file(self) -> str:
        hooks_payload: dict[str, list[dict[str, object]]] = {}
        for matcher_group in self.matcher_groups:
            hooks_payload.setdefault(matcher_group.event_name, []).append(
                matcher_group.to_mapping()
            )
        return json.dumps({"hooks": hooks_payload}, indent=2) + "\n"

    def report_detail(self) -> str:
        runtime_caveats = (
            "Rewritten for Codex hooks; review behavior before relying on it. "
            "Codex hooks require `[features].codex_hooks = true`, only execute "
            "`command` handlers, skip `async` / `prompt` / `agent` handlers, ignore "
            "`matcher` for `UserPromptSubmit` and `Stop`, and `PreToolUse` / "
            "`PostToolUse` currently run for shell commands only."
        )
        if not self.unsupported_fields:
            return runtime_caveats
        return (
            "Unsupported Claude hook fields need review: "
            + ", ".join(f"`{field_name}`" for field_name in self.unsupported_fields)
            + f". {runtime_caveats}"
        )


def has_convertible_hooks(scope_root: Path) -> bool:
    return bool(ClaudeHooks.from_scope(scope_root).matcher_groups)


def report_hooks(scope: ScopePaths) -> ConversionResult:
    claude_hooks = ClaudeHooks.from_scope(scope.source)
    if not claude_hooks.matcher_groups:
        return ConversionResult()

    return ConversionResult(
        artifacts=[
            PlannedArtifact(
                relative_path=CODEX_HOOKS_PATH,
                payload=GeneratedText(claude_hooks.render_codex_file()),
            )
        ],
        report_items=[
            MigrationReportItem(
                "rewritten",
                CODEX_HOOKS_PATH,
                claude_hooks.report_detail(),
            )
        ],
    )


def json_int(value: object) -> int | None:
    if value is None or isinstance(value, bool):
        return None
    try:
        return int(str(value))
    except ValueError:
        return None


def json_object_tuple(value: object) -> tuple[Mapping[str, object], ...]:
    if isinstance(value, Sequence) and not isinstance(value, (str, bytes)):
        return tuple(json_object(item) for item in value)
    return ()

"""Discover and classify source instruction files for AGENTS.md migration.

Chooses the first supported instruction file for a project/global scope. Neutral
instruction files are safe for `AGENTS.md` symlinks; content with obvious
Claude-only lifecycle, hook, subagent, or permission assumptions is treated as
requiring a generated Codex-specific copy and manual rewrite.
"""

from __future__ import annotations

from collections.abc import Callable
from pathlib import Path

from migrate.common import MigrationReportItem


INSTRUCTION_SOURCE_CANDIDATES = (
    Path(".claude") / "CLAUDE.md",
    Path("CLAUDE.md"),
    Path("claude.md"),
    Path("AGENTS.md"),
)

CLAUDE_ONLY_INSTRUCTION_MARKERS = (
    "/hooks",
    ".claude/agents/",
    ".claude/settings",
    "Subagent",
    "subagent",
    "permissionMode",
    "ExitPlanMode",
)
MAX_AGENTS_MD_BYTES = 32 * 1024


def instruction_source_file(
    source_root: Path,
    is_global: bool,
    path_exists_with_exact_case: Callable[[Path], bool],
) -> Path | None:
    candidates = INSTRUCTION_SOURCE_CANDIDATES
    if not is_global:
        candidates = tuple(
            candidate
            for candidate in candidates
            if candidate != Path(".claude") / "CLAUDE.md"
        )

    for candidate in candidates:
        source_file = source_root / candidate
        if path_exists_with_exact_case(source_file):
            return source_file
    return None


def should_symlink_instructions(content: str) -> bool:
    return not any(marker in content for marker in CLAUDE_ONLY_INSTRUCTION_MARKERS)


def validate_agents_md_files(target_root: Path) -> list[MigrationReportItem]:
    report_items: list[MigrationReportItem] = []
    for agents_file in sorted(target_root.rglob("AGENTS.md")):
        relative_path = agents_file.relative_to(target_root)
        size_bytes = agents_file.stat().st_size
        if size_bytes > MAX_AGENTS_MD_BYTES:
            report_items.append(
                MigrationReportItem(
                    "warning",
                    relative_path,
                    f"{size_bytes / 1024:.1f}KB exceeds the 32KB review threshold.",
                )
            )
            continue
        report_items.append(
            MigrationReportItem(
                "ok",
                relative_path,
                f"{size_bytes / 1024:.1f}KB is under the 32KB review threshold.",
            )
        )
    return report_items

"""Convert Claude Code MCP/settings JSON into Codex config TOML.

Reads Claude settings plus `.mcp.json` / `.claude.json`, maps model and sandbox
settings when there is a known Codex equivalent, and renders MCP server entries
for `.codex/config.toml`. Header/env forms are partially normalized to Codex
`bearer_token_env_var`, `env_http_headers`, `http_headers`, `env_vars`, and
literal `env` tables.
"""

from __future__ import annotations

import json
import re
import shutil
from collections.abc import Mapping
from pathlib import Path

from migrate.common import (
    CODEX_CONFIG_PATH,
    MigrationReportItem,
    json_object,
    json_string,
    json_string_tuple,
    path_exists_with_exact_case,
)
from migrate.settings import CLAUDE_MCP_JSON_RELATIVE
from utils.util import TomlValue


ENV_VAR_RE = re.compile(r"\A\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-[^}]*)?\}\Z")
BEARER_ENV_VAR_RE = re.compile(
    r"\ABearer\s+\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-[^}]*)?\}\Z"
)


def mcp_server_toml_table(
    server_name: str,
    server_config: Mapping[str, object],
    enabled_servers: tuple[str, ...],
    disabled_servers: frozenset[str],
) -> dict[str, TomlValue]:
    table: dict[str, TomlValue] = {}
    enabled = mcp_enabled_state(server_config)
    if enabled is False:
        table["enabled"] = False
    elif enabled_servers and server_name not in enabled_servers:
        table["enabled"] = False
    elif server_name in disabled_servers:
        table["enabled"] = False
    if url := json_string(server_config.get("url")):
        table["url"] = url
    if command := json_string(server_config.get("command")):
        table["command"] = command
    if args := json_string_tuple(server_config.get("args")):
        table["args"] = list(args)
    if "headers" in server_config:
        append_header_config(table, json_object(server_config["headers"]))
    if "env" in server_config:
        append_env_config(table, json_object(server_config["env"]))
    return table


def mcp_report_items(
    mcp_servers: tuple[tuple[str, dict[str, object]], ...],
) -> list[MigrationReportItem]:
    report_items = [
        MigrationReportItem(
            "rewritten",
            CODEX_CONFIG_PATH,
            f"Converted {len(mcp_servers)} MCP server entries.",
        )
    ]
    for server_name, server_config in mcp_servers:
        notes = mcp_manual_notes(server_name, server_config)
        if notes:
            report_items.append(
                MigrationReportItem(
                    "manual_fix_required",
                    CODEX_CONFIG_PATH,
                    f"MCP server `{server_name}` needs review: {' '.join(notes)}",
                )
            )
    return report_items


def append_header_config(
    table: dict[str, TomlValue],
    headers: Mapping[str, object],
) -> None:
    static_headers: dict[str, str] = {}
    env_headers: dict[str, str] = {}

    for key, value in headers.items():
        header_value = str(value)
        bearer_match = BEARER_ENV_VAR_RE.match(header_value)
        if key.lower() == "authorization" and bearer_match:
            table["bearer_token_env_var"] = bearer_match.group(1)
            continue

        env_match = ENV_VAR_RE.match(header_value)
        if env_match:
            env_headers[key] = env_match.group(1)
            continue

        static_headers[key] = header_value

    if static_headers:
        table["http_headers"] = static_headers
    if env_headers:
        table["env_http_headers"] = env_headers


def append_env_config(
    table: dict[str, TomlValue],
    env: Mapping[str, object],
) -> None:
    static_env: dict[str, str] = {}
    env_vars: list[str] = []

    for key, value in env.items():
        env_value = str(value)
        env_match = ENV_VAR_RE.match(env_value)
        if env_match and env_match.group(1) == key:
            env_vars.append(key)
            continue

        static_env[key] = env_value

    if env_vars:
        table["env_vars"] = env_vars
    if static_env:
        table["env"] = static_env


def mcp_manual_notes(
    server_name: str,
    server_config: Mapping[str, object],
) -> tuple[str, ...]:
    notes: list[str] = []
    source_type = json_string(server_config.get("type"))
    if source_type and source_type not in {"http", "stdio"}:
        notes.append(
            f"Claude MCP `type: {source_type}` was not written to Codex config; verify that the generated `url` or `command` is a supported Codex transport."
        )
    unsupported_fields = unsupported_mcp_server_fields(server_config)
    if unsupported_fields:
        notes.append(
            "Review unsupported Claude MCP fields manually: "
            + ", ".join(f"`{field_name}`" for field_name in unsupported_fields)
            + "."
        )
    return tuple(notes)


def mcp_enabled_state(server_config: Mapping[str, object]) -> bool | None:
    if server_config.get("enabled") is False:
        return False
    if server_config.get("disabled") is True:
        return False
    return None


def unsupported_mcp_server_fields(
    server_config: Mapping[str, object],
) -> tuple[str, ...]:
    supported = {
        "args",
        "command",
        "disabled",
        "enabled",
        "env",
        "headers",
        "name",
        "scope",
        "type",
        "url",
    }
    return tuple(sorted(key for key in server_config if key not in supported))


def read_claude_mcp_servers(source_root: Path) -> tuple[tuple[str, dict[str, object]], ...]:
    servers: list[tuple[str, dict[str, object]]] = []
    for relative_path in CLAUDE_MCP_JSON_RELATIVE:
        source_file = source_root / relative_path
        if not path_exists_with_exact_case(source_file):
            continue
        mcp_config = json_object(json.loads(source_file.read_text()))
        for server_name, server_config in json_object(mcp_config.get("mcpServers")).items():
            servers.append((server_name, json_object(server_config)))
    return tuple(servers)


def validate_mcp_commands(config: dict[str, object]) -> list[MigrationReportItem]:
    mcp_servers = config.get("mcp_servers")
    if not isinstance(mcp_servers, dict):
        return []

    report_items: list[MigrationReportItem] = []
    for server_name, server_config in sorted(mcp_servers.items()):
        if not isinstance(server_config, dict):
            continue
        command = server_config.get("command")
        if not command:
            continue
        command_text = str(command)
        if shutil.which(command_text):
            report_items.append(
                MigrationReportItem(
                    "ok",
                    CODEX_CONFIG_PATH,
                    f"MCP server `{server_name}` command `{command_text}` is on PATH.",
                )
            )
        else:
            report_items.append(
                MigrationReportItem(
                    "warning",
                    CODEX_CONFIG_PATH,
                    f"MCP server `{server_name}` command `{command_text}` was not found on PATH.",
                )
            )
    return report_items

"""Report Claude Code plugin surfaces that need manual Codex migration.

Claude Code plugins and plugin marketplaces can bundle commands, agents, MCP
servers, skills, and hooks with provider-specific metadata. The migrator reports
their presence as manual follow-up; it does not install Codex plugins, copy
plugin trees, or read marketplace `source` entries.
"""

from __future__ import annotations

from migrate.common import ConversionResult, ScopePaths, report_manual_paths
from migrate.settings import CLAUDE_PLUGIN_MANUAL_PATHS


def report_plugins(scope: ScopePaths) -> ConversionResult:
    return report_manual_paths(scope, CLAUDE_PLUGIN_MANUAL_PATHS)

"""Shared source path constants for migration discovery/reporting.

Constants here describe where Claude Code commonly stores instructions,
commands, skills, agents, MCP config, plugin references, and hooks. Paths are
relative to `ScopePaths.source`, the directory containing `.claude`, `.mcp.json`,
and similar source roots.
"""

from __future__ import annotations

from pathlib import Path

CLAUDE_SETTINGS_JSON_RELATIVE = (
    Path(".claude") / "settings.json",
    Path(".claude") / "settings.local.json",
)

CLAUDE_MCP_JSON_RELATIVE = (
    Path(".mcp.json"),
    Path(".claude.json"),
)

CLAUDE_PLUGIN_MANUAL_PATHS = (
    (Path(".claude") / "plugins", "Claude Code plugins"),
    (
        Path(".claude") / "plugin-marketplaces.json",
        "Claude Code plugin marketplace registry",
    ),
    (
        Path(".claude-plugin") / "marketplace.json",
        "Claude Code plugin marketplace",
    ),
)

SOURCE_SCAN_ROOTS = (
    (Path(".claude"), "primary source"),
)

SOURCE_SCOPE_MARKERS = (
    Path(".claude"),
)

"""Convert Claude Code skills and commands into Codex skills.

Reads `.claude/skills/<name>/SKILL.md` and `.claude/skills/<name>.md`, then emits
`.agents/skills/<name>/SKILL.md` plus supported helper directories for directory
skills. Also wraps `.claude/commands/*.md` as
one-file Codex skills. Runtime placeholders, file expansion, shell
interpolation, and unsupported metadata are preserved with manual-review
caveats.
"""

from __future__ import annotations

import re
from collections.abc import Sequence
from pathlib import Path

from migrate.common import (
    CODEX_SKILLS_ROOT,
    ArtifactKind,
    ConversionResult,
    GeneratedText,
    MigrationReportItem,
    ParsedDocument,
    PlannedArtifact,
    SimpleYamlFrontmatter,
    append_report_item,
    format_bullets,
    format_frontmatter,
    format_manual_migration_block,
    is_path_within_root,
    manual_report_item,
    parse_frontmatter,
    unsupported_frontmatter_fields,
)
from utils.util import slugify_name


COMMAND_FILE_SOURCES = (
    (Path(".claude") / "commands", "source-command", "source command"),
)

SKILL_SOURCE_ROOTS = (
    Path(".claude") / "skills",
)
SKILL_SUPPORT_DIRS = ("scripts", "references", "assets")


def iter_skill_files(source_root: Path) -> tuple[Path, ...]:
    if not source_root.exists():
        return ()
    single_file_skills = tuple(
        source_file
        for source_file in sorted(source_root.glob("*.md"))
        if source_file.stem != "README"
    )
    directory_skills = tuple(sorted(source_root.glob("*/SKILL.md")))
    return single_file_skills + directory_skills


def skill_target_name(source_file: Path) -> str:
    if source_file.name == "SKILL.md":
        return source_file.parent.name
    return source_file.stem


def command_caveats(
    template: str,
    unsupported_fields: Sequence[str],
) -> tuple[str, ...]:
    caveats: list[str] = []
    if re.search(r"\$(ARGUMENTS|\d+)\b", template):
        caveats.append(
            "Provider argument placeholders like `$ARGUMENTS` or `$1` were preserved as text; rewrite them into natural-language instructions for Codex."
        )
    if "{{" in template and "}}" in template:
        caveats.append(
            "Provider template variables like `{{name}}` were preserved as text; rewrite them into natural-language instructions for Codex."
        )
    if re.search(r"!\s*`", template):
        caveats.append(
            "Provider shell-output interpolation like ``!`command` `` was preserved as text; replace it with explicit Codex instructions to run the command when needed."
        )
    if re.search(r"(^|\s)@[\w./~:-]+", template):
        caveats.append(
            "Provider automatic file-reference expansion was preserved as text; verify Codex should read those files explicitly."
        )
    if unsupported_fields:
        caveats.append(
            "Review unsupported command metadata manually: "
            + ", ".join(f"`{field_name}`" for field_name in unsupported_fields)
            + "."
        )
    return tuple(caveats)


def convert_skills(source_root: Path) -> ConversionResult:
    result = convert_skill_files(source_root / ".claude" / "skills")
    result.add(convert_command_skills(source_root))
    return result


def convert_skill_files(source_root: Path) -> ConversionResult:
    result = ConversionResult()
    for source_file in iter_skill_files(source_root):
        artifacts, report_item = convert_skill_file(source_file)
        result.artifacts.extend(artifacts)
        result.summary.skills += 1
        result.report_items.append(report_item)
    return result


def convert_command_skills(source_root: Path) -> ConversionResult:
    result = ConversionResult()
    for command_source_root, name_prefix, provider in COMMAND_FILE_SOURCES:
        result.add(
            convert_markdown_command_files(
                source_root / command_source_root,
                name_prefix,
                provider,
            )
        )
    return result


def codex_skill_frontmatter(name: str, description: str) -> SimpleYamlFrontmatter:
    return SimpleYamlFrontmatter(
        {
            "name": name,
            "description": description,
        }
    )


def convert_skill_file(source_file: Path) -> tuple[list[PlannedArtifact], MigrationReportItem]:
    document = ParsedDocument.from_file(source_file)
    name = document.frontmatter.required_string("name")
    description = document.frontmatter.required_string("description")
    allowed_tools = document.frontmatter.string_tuple("allowed-tools")
    unsupported_fields = unsupported_frontmatter_fields(
        document.frontmatter.to_dict(),
        ("name", "description", "allowed-tools"),
    )
    artifacts = [
        PlannedArtifact(
            relative_path=CODEX_SKILLS_ROOT / skill_target_name(source_file) / "SKILL.md",
            payload=GeneratedText(
                render_skill(
                    document.body,
                    name=name,
                    description=description,
                    allowed_tools=allowed_tools,
                    unsupported_fields=unsupported_fields,
                )
            ),
            kind=ArtifactKind.SKILL,
        )
    ]
    artifacts.extend(skill_support_artifacts(source_file))
    return artifacts, skill_report_item(source_file, allowed_tools, unsupported_fields)


def skill_support_artifacts(source_file: Path) -> list[PlannedArtifact]:
    if source_file.name != "SKILL.md":
        return []

    artifacts: list[PlannedArtifact] = []
    skill_root = source_file.parent
    target_root = CODEX_SKILLS_ROOT / skill_root.name
    source_files: list[Path] = []
    for dirname in SKILL_SUPPORT_DIRS:
        source_dir = skill_root / dirname
        if not source_dir.exists():
            continue
        source_files.extend(
            source_file
            for source_file in source_dir.rglob("*")
            if source_file.is_file() and is_path_within_root(source_file, skill_root)
        )
    for support_file in sorted(
        source_files,
        key=lambda path: path.relative_to(skill_root).as_posix(),
    ):
        artifacts.append(
            PlannedArtifact.from_source_file(
                support_file,
                target_root / support_file.relative_to(skill_root),
            )
        )
    return artifacts


def render_skill(
    body: str,
    *,
    name: str,
    description: str,
    allowed_tools: tuple[str, ...],
    unsupported_fields: tuple[str, ...],
) -> str:
    return format_frontmatter(
        codex_skill_frontmatter(name, description),
        render_skill_body(body, allowed_tools, unsupported_fields),
    )


def render_skill_body(
    body: str,
    allowed_tools: tuple[str, ...],
    unsupported_fields: tuple[str, ...],
) -> str:
    manual_notes: list[str] = []
    if allowed_tools:
        manual_notes.append(
            "Claude `allowed-tools` was preserved as prompt guidance, not a Codex permission boundary.\n\n"
            "You're allowed to use these tools:\n\n"
            f"{format_bullets(allowed_tools)}"
        )
    if unsupported_fields:
        manual_notes.append(
            "Review unsupported Claude skill fields manually: "
            f"{', '.join(f'`{field_name}`' for field_name in unsupported_fields)}."
        )

    if not manual_notes:
        return body

    return f"{body.rstrip()}\n\n{format_manual_migration_block(manual_notes)}\n"


def skill_report_detail(
    allowed_tools: tuple[str, ...],
    unsupported_fields: tuple[str, ...],
) -> str:
    caveats: list[str] = []
    if allowed_tools:
        caveats.append("allowed-tools")
    caveats.extend(unsupported_fields)
    if not caveats:
        return "Converted Claude skill."
    return (
        "Manual review required for Claude skill fields: "
        + ", ".join(f"`{field_name}`" for field_name in caveats)
        + "."
    )


def skill_report_item(
    source_file: Path,
    allowed_tools: tuple[str, ...],
    unsupported_fields: tuple[str, ...],
) -> MigrationReportItem:
    report_items: list[MigrationReportItem] = []
    detail = skill_report_detail(allowed_tools, unsupported_fields)
    append_report_item(
        report_items,
        allowed_tools or unsupported_fields,
        CODEX_SKILLS_ROOT / skill_target_name(source_file) / "SKILL.md",
        detail,
        detail,
    )
    return report_items[0]


def convert_markdown_command_files(
    source_root: Path,
    name_prefix: str,
    provider: str,
) -> ConversionResult:
    result = ConversionResult()
    if not source_root.exists():
        return result
    for source_file in sorted(source_root.rglob("*.md")):
        artifact, report_item = convert_command_file(
            source_root,
            source_file,
            name_prefix,
            provider,
        )
        result.artifacts.append(artifact)
        result.summary.skills += 1
        result.report_items.append(report_item)
    return result


def convert_command_file(
    source_root: Path,
    source_file: Path,
    name_prefix: str,
    provider: str,
) -> tuple[PlannedArtifact, MigrationReportItem]:
    document = ParsedDocument.from_file(source_file)
    source_name = "-".join(source_file.relative_to(source_root).with_suffix("").parts)
    name = slugify_name(f"{name_prefix}-{source_name}")
    description = document.frontmatter.optional_string("description")
    if not description:
        description = f"Run the migrated {provider} `{source_name}`."
    unsupported_fields = unsupported_frontmatter_fields(
        document.frontmatter.to_dict(),
        ("description",),
    )
    caveats = command_caveats(document.body, unsupported_fields)
    artifact = PlannedArtifact(
        relative_path=CODEX_SKILLS_ROOT / name / "SKILL.md",
        payload=GeneratedText(
            render_command_skill(
                document.body,
                name=name,
                description=description,
                provider=provider,
                source_name=source_name,
                caveats=caveats,
            )
        ),
        kind=ArtifactKind.SKILL,
    )
    return artifact, command_report_item(name, provider, source_name)


def render_command_skill(
    body: str,
    *,
    name: str,
    description: str,
    provider: str,
    source_name: str,
    caveats: tuple[str, ...],
) -> str:
    manual_notes = [
        f"Migrated from {provider} `{source_name}` into a Codex skill. "
        f"Invoke it as `${name}` and manually rewrite any slash-command behavior that depended on provider-specific runtime expansion."
    ]
    manual_notes.extend(caveats)
    template_body = body.strip() or "No command template body was found."
    return format_frontmatter(
        codex_skill_frontmatter(name, description),
        f"# {name}\n\n"
        "Use this skill when the user asks to run the migrated "
        f"{provider} `{source_name}`.\n\n"
        "## Command Template\n\n"
        f"{template_body}\n\n"
        f"{format_manual_migration_block(manual_notes)}\n",
    )


def validate_skill_files(target_root: Path) -> list[MigrationReportItem]:
    skills_root = target_root / CODEX_SKILLS_ROOT
    if not skills_root.exists():
        return []

    report_items: list[MigrationReportItem] = []
    for skill_file in sorted(skills_root.glob("*/SKILL.md")):
        relative_path = skill_file.relative_to(target_root)
        document = parse_frontmatter(skill_file.read_text(), skill_file)
        missing = [
            key
            for key in ("name", "description")
            if not document.frontmatter.optional_string(key)
        ]
        if missing:
            report_items.append(
                MigrationReportItem(
                    "error",
                    relative_path,
                    "skill frontmatter missing " + ", ".join(missing) + ".",
                )
            )
            continue
        report_items.append(
            MigrationReportItem(
                "ok",
                relative_path,
                "skill frontmatter has name and description.",
            )
        )
    return report_items


def command_report_detail(provider: str, source_name: str) -> str:
    return (
        f"Converted {provider} `{source_name}` to a single-file Codex skill; "
        "review invocation and template placeholder semantics."
    )


def command_report_item(
    name: str,
    provider: str,
    source_name: str,
) -> MigrationReportItem:
    return manual_report_item(
        CODEX_SKILLS_ROOT / name / "SKILL.md",
        command_report_detail(provider, source_name),
    )

"""Section-level migration code for migrate-to-codex.

Each module owns one source-to-Codex surface: instructions, skills/commands,
subagents, MCP/config, hooks, plugin-like sources, or shared primitives.
`cli.py` should orchestrate these modules instead of embedding conversions.
"""

from __future__ import annotations

from collections.abc import Callable, Sequence
from pathlib import Path


def should_skip_inventory_child(child: Path) -> bool:
    return child.name in {".DS_Store", "__pycache__"}


def command_file_inventory(
    source_root: Path,
    command_file_sources: Sequence[tuple[Path, str, str]],
) -> tuple[tuple[str, tuple[str, ...]], ...]:
    inventory: list[tuple[str, tuple[str, ...]]] = []
    for relative_root, _name_prefix, provider in command_file_sources:
        absolute_root = source_root / relative_root
        if not absolute_root.exists():
            continue
        command_names = tuple(
            sorted(
                source_file.relative_to(absolute_root).with_suffix("").as_posix()
                for source_file in absolute_root.rglob("*.md")
            )
        )
        if command_names:
            inventory.append((provider, command_names))
    return tuple(inventory)


def render_named_inventory(
    lines: list[str],
    label: str,
    values: Sequence[str],
) -> None:
    if not values:
        lines.append(f"  inactive: {label} - none found")
        return
    lines.append(f"  active: {label} - {len(values)} found")
    for value in values:
        lines.append(f"    - {value}")


def render_scope_inventory(
    source_root: Path,
    instruction_source_candidates: Sequence[Path],
    command_file_sources: Sequence[tuple[Path, str, str]],
    skill_source_roots: Sequence[Path],
    agent_source_roots: Sequence[Path],
    iter_skill_files: Callable[[Path], Sequence[Path]],
    iter_agent_files: Callable[[Path], Sequence[Path]],
    path_exists_with_exact_case: Callable[[Path], bool],
) -> str:
    lines = ["", "Migration inventory:"]
    instruction_candidates = tuple(
        candidate.as_posix()
        for candidate in instruction_source_candidates
        if path_exists_with_exact_case(source_root / candidate)
    )
    skill_names = tuple(
        sorted(
            {
                source_file.parent.name
                for relative_root in skill_source_roots
                for source_file in iter_skill_files(source_root / relative_root)
            }
        )
    )
    agent_names = tuple(
        sorted(
            {
                source_file.stem
                for relative_root in agent_source_roots
                for source_file in iter_agent_files(source_root / relative_root)
            }
        )
    )

    render_named_inventory(lines, "instruction files", instruction_candidates)
    render_named_inventory(lines, "skills", skill_names)

    command_inventory = command_file_inventory(source_root, command_file_sources)
    if not command_inventory:
        lines.append("  inactive: command sources - none found")
    else:
        total_commands = sum(
            len(command_names) for _, command_names in command_inventory
        )
        lines.append(f"  active: command sources - {total_commands} found")
        for provider, command_names in command_inventory:
            lines.append(f"    provider: {provider} ({len(command_names)})")
            for command_name in command_names:
                lines.append(f"      - {command_name}")

    render_named_inventory(lines, "subagents", agent_names)
    return "\n".join(lines)


def render_source_inventory(
    source_root: Path,
    source_scan_roots: Sequence[tuple[Path, str]],
    path_exists_with_exact_case: Callable[[Path], bool],
) -> str:
    lines = ["", "Source inventory:"]
    discovered = False

    for relative_root, label in source_scan_roots:
        absolute_root = source_root / relative_root
        if not path_exists_with_exact_case(absolute_root):
            continue
        discovered = True
        lines.append(f"  detected: {relative_root.as_posix()} - {label}")
        try:
            children = sorted(
                absolute_root.iterdir(), key=lambda child: child.name.lower()
            )
        except FileNotFoundError:
            continue
        for child in children:
            if should_skip_inventory_child(child):
                continue
            child_kind = "dir" if child.is_dir() else "file"
            lines.append(f"    {child_kind}: {(relative_root / child.name).as_posix()}")

    if not discovered:
        lines.append("  inactive: No supported source directories found.")

    return "\n".join(lines)

from __future__ import annotations

import glob
import json
import re
from collections.abc import Mapping, Sequence
from dataclasses import dataclass
from pathlib import Path
from typing import TypeAlias


YamlScalar: TypeAlias = str | bool | int | float | None
YamlValue: TypeAlias = YamlScalar | Sequence[YamlScalar]
TomlScalar: TypeAlias = str | bool | int | float | None
TomlValue: TypeAlias = object


def detected_json_keys(content: str, keys: Sequence[str]) -> tuple[str, ...]:
    return tuple(key for key in keys if re.search(rf'"{re.escape(key)}"\s*:', content))


def strip_jsonc_comments(content: str) -> str:
    lines: list[str] = []
    for line in content.splitlines():
        in_string = False
        escaped = False
        result: list[str] = []
        index = 0
        while index < len(line):
            char = line[index]
            if escaped:
                result.append(char)
                escaped = False
                index += 1
                continue
            if char == "\\" and in_string:
                result.append(char)
                escaped = True
                index += 1
                continue
            if char == '"':
                in_string = not in_string
                result.append(char)
                index += 1
                continue
            if (
                not in_string
                and char == "/"
                and index + 1 < len(line)
                and line[index + 1] == "/"
            ):
                break
            result.append(char)
            index += 1
        lines.append("".join(result))
    return "\n".join(lines)


def load_jsonc_object(content: str, json_object: callable) -> Mapping[str, object]:
    without_comments = strip_jsonc_comments(content)
    without_trailing_commas = re.sub(r",\s*([}\]])", r"\1", without_comments)
    return json_object(json.loads(without_trailing_commas))


def parse_jsonc_mapping_text(text: str) -> Mapping[str, object] | None:
    """Return the top-level JSON object, or None if the text is not a JSON object."""
    try:
        without_comments = strip_jsonc_comments(text)
        without_trailing_commas = re.sub(r",\s*([}\]])", r"\1", without_comments)
        parsed = json.loads(without_trailing_commas)
    except (json.JSONDecodeError, TypeError, ValueError):
        return None
    if isinstance(parsed, Mapping):
        return parsed
    return None


@dataclass(frozen=True)
class JsonMappingFileRead:
    exists: bool
    ok: bool
    data: Mapping[str, object]


def read_json_mapping_file(path: Path) -> JsonMappingFileRead:
    """Read a JSON/JSONC file. ``ok`` is False when the file exists but could not be parsed."""
    if not path.is_file():
        return JsonMappingFileRead(exists=False, ok=True, data={})
    text = path.read_text()
    parsed = parse_jsonc_mapping_text(text)
    if parsed is None:
        return JsonMappingFileRead(exists=True, ok=False, data={})
    return JsonMappingFileRead(exists=True, ok=True, data=parsed)


@dataclass(frozen=True)
class TomlMultilineString:
    value: str


def parse_yaml_mapping(content: str) -> dict[str, YamlValue]:
    """Parse the small YAML-frontmatter subset used by Claude metadata."""
    result: dict[str, YamlValue] = {}
    current_key: str | None = None

    for raw_line in content.splitlines():
        if not raw_line.strip():
            continue

        if raw_line.startswith("  - ") and current_key:
            current_value = result.setdefault(current_key, [])
            if not isinstance(current_value, list):
                current_value = [current_value]
                result[current_key] = current_value
            current_value.append(parse_yaml_value(raw_line[4:].strip()))
            continue

        key, separator, value = raw_line.partition(":")
        if not separator:
            continue

        current_key = key.strip()
        value = value.strip()
        result[current_key] = parse_yaml_value(value) if value else []

    return result


def parse_yaml_value(value: str) -> YamlValue:
    if value in {"true", "True"}:
        return True
    if value in {"false", "False"}:
        return False
    if value in {"null", "Null", "~"}:
        return None
    if value.startswith("[") and value.endswith("]"):
        return tuple(
            parse_yaml_value(item)
            for item in split_delimited_values(value[1:-1])
            if item
        )
    if value.startswith('"') and value.endswith('"'):
        try:
            return json.loads(value)
        except json.JSONDecodeError:
            return value[1:-1]
    if value.startswith("'") and value.endswith("'"):
        return value[1:-1].replace("''", "'")
    return value


def split_delimited_values(content: str) -> tuple[str, ...]:
    values: list[str] = []
    token: list[str] = []
    quote: str | None = None
    escaped = False
    for char in content:
        if escaped:
            token.append(char)
            escaped = False
            continue
        if char == "\\" and quote == '"':
            token.append(char)
            escaped = True
            continue
        if quote:
            token.append(char)
            if char == quote:
                quote = None
            continue
        if char in {"'", '"'}:
            token.append(char)
            quote = char
            continue
        if char == ",":
            values.append("".join(token).strip())
            token = []
            continue
        token.append(char)
    values.append("".join(token).strip())
    return tuple(values)


def format_yaml_mapping(values: Mapping[str, YamlValue]) -> str:
    return "\n".join(
        f"{key}: {format_yaml_value(value)}" for key, value in values.items()
    )


def format_yaml_value(value: YamlValue) -> str:
    if isinstance(value, bool):
        return "true" if value else "false"
    if value is None:
        return "null"
    if isinstance(value, Sequence) and not isinstance(value, (str, bytes)):
        return "[" + ", ".join(format_yaml_value(item) for item in value) + "]"
    return json.dumps(str(value))


def render_toml_document(values: Mapping[str, TomlValue]) -> str:
    lines: list[str] = []
    append_toml_entries(lines, values)
    for key, value in values.items():
        if isinstance(value, Mapping):
            append_toml_table(lines, (key,), value)
    return "\n".join(lines).rstrip() + "\n"


def append_toml_table(
    lines: list[str],
    path: tuple[str, ...],
    values: Mapping[str, TomlValue],
) -> None:
    append_blank_line(lines)
    lines.append("[" + ".".join(format_toml_key(path_part) for path_part in path) + "]")
    append_toml_entries(lines, values)

    for key, value in values.items():
        if isinstance(value, Mapping):
            append_toml_table(lines, (*path, key), value)


def append_toml_entries(lines: list[str], values: Mapping[str, TomlValue]) -> None:
    for key, value in values.items():
        if isinstance(value, Mapping):
            continue
        lines.append(f"{format_toml_key(key)} = {format_toml_value(value)}")


def append_blank_line(lines: list[str]) -> None:
    if lines and lines[-1]:
        lines.append("")


def format_toml_key(key: str) -> str:
    if re.fullmatch(r"[A-Za-z0-9_-]+", key):
        return key
    return json.dumps(key)


def format_toml_value(value: TomlValue) -> str:
    if isinstance(value, TomlMultilineString):
        return format_toml_multiline_string(value.value)
    if isinstance(value, bool):
        return "true" if value else "false"
    if value is None:
        return '""'
    if isinstance(value, Sequence) and not isinstance(value, (str, bytes)):
        return "[" + ", ".join(format_toml_value(item) for item in value) + "]"
    return json.dumps(str(value))


def format_toml_multiline_string(value: str) -> str:
    escaped = value.replace("\\", "\\\\").replace('"""', '\\"\\"\\"')
    return f'"""{escaped}"""'


def slugify_name(value: str) -> str:
    result = re.sub(r"[^A-Za-z0-9_-]+", "-", value.strip()).strip("-").lower()
    return result or "migrated-command"


def first_markdown_heading(content: str) -> str | None:
    for line in content.splitlines():
        match = re.match(r"^#\s+(.+?)\s*$", line)
        if match:
            return match.group(1).strip()
    return None


def format_backtick_list(values: Sequence[str]) -> str:
    if not values:
        return ""
    if len(values) == 1:
        return f"`{values[0]}`"
    return ", ".join(f"`{value}`" for value in values[:-1]) + f", and `{values[-1]}`"


def normalize_source_scope_root(
    path: Path, source_scope_markers: Sequence[Path]
) -> Path:
    resolved = path
    for marker in source_scope_markers:
        if resolved.parts[-len(marker.parts) :] == marker.parts:
            return resolved.parents[len(marker.parts) - 1]
    return resolved


def resolve_source_root(source: str) -> Path:
    if not glob.has_magic(source):
        return Path(source)

    matches = [Path(match) for match in glob.glob(source, recursive=True)]
    if not matches:
        raise FileNotFoundError(f"No matches for source pattern: {source}")

    for match in matches:
        if (
            match.is_dir()
            and (match / "global").exists()
            and (match / "project").exists()
        ):
            return match

    static_prefix = source.split("*", 1)[0].rstrip("/")
    return Path(static_prefix)

# Migration script helper modules.