"""CLI entry point for mcp-skill."""

import asyncio
import sys
from pathlib import Path

import asyncclick as click

from mcp_skill.introspector import connect_and_list_tools
from mcp_skill.generator import generate_app_py, generate_skill_md
from mcp_skill.type_mapper import (
    derive_class_name,
    derive_module_name,
    derive_skill_name,
    derive_skill_name_from_url,
    generate_skill_description,
)
from mcp_skill.validator import validate_generated_code


@click.group()
async def main():
    """Convert any MCP server into an Agent Skill."""


@main.command()
@click.option("--url", help="MCP server URL")
@click.option(
    "--auth",
    type=click.Choice(["none", "api-key", "oauth"]),
    default="none",
    help="Authentication type",
)
@click.option("--name", help="Skill name (auto-detected if not provided)")
@click.option("--api-key", "api_key", help="API key (when auth=api-key)")
@click.option(
    "--auth-header",
    "auth_header",
    default=None,
    help="Header name for API key (e.g. 'x-api-key'). Omit for Bearer token.",
)
@click.option("--force", is_flag=True, help="Overwrite existing directory")
@click.option("--non-interactive", is_flag=True, help="Skip interactive prompts")
@click.option(
    "--app-name",
    "app_name",
    default=None,
    help="App class base name (e.g. 'Fetch' → FetchApp)",
)
async def create(
    url, auth, name, api_key, auth_header, force, non_interactive, app_name
):
    """Create an Agent Skill from an MCP server."""
    # Generation order:
    # 1. Ask/resolve URL
    # 2. Derive and confirm skill name from URL
    # 3. Derive and confirm app name from skill name
    # 4. Resolve auth type (using skill name for token storage)
    # 5. Connect and list tools
    # 6. Generate app.py and skill.md
    # 7. Run validation on generated code
    try:
        # Step 1: Resolve URL
        if non_interactive:
            if not url:
                click.echo("Error: --url is required in non-interactive mode", err=True)
                sys.exit(1)
        else:
            if not url:
                url = await click.prompt("MCP Server URL")

        # Step 2: Derive and confirm skill name from URL
        url_derived_name = derive_skill_name_from_url(url)
        if not name:
            if non_interactive:
                name = url_derived_name
            else:
                name = await click.prompt("Skill name", default=url_derived_name)
        else:
            name = derive_skill_name(name)

        # Step 3: Derive and confirm app name from skill name
        if not app_name:
            default_app = name.replace("-", " ").title().replace(" ", "")
            if non_interactive:
                app_name = default_app
            else:
                app_name = await click.prompt(
                    "App name (base name, 'App' suffix added automatically)",
                    default=default_app,
                )

        # Step 4: Resolve auth type, using skill name for token storage
        if not non_interactive and auth == "none":
            auth = await click.prompt(
                "Authentication type",
                type=click.Choice(["none", "api-key", "oauth"]),
                default="none",
            )

        if auth == "api-key" and not api_key:
            if non_interactive:
                click.echo(
                    "Error: --api-key is required when auth=api-key in non-interactive mode",
                    err=True,
                )
                sys.exit(1)
            api_key = await click.prompt("API Key", hide_input=True)

        auth_str = None
        headers: dict[str, str] | None = None
        if auth == "api-key" and api_key:
            if auth_header:
                headers = {auth_header: api_key}
                auth_type = "header"
            else:
                auth_str = api_key
                auth_type = "bearer"
        elif auth == "oauth":
            auth_str = "oauth"
            auth_type = "oauth"
        else:
            auth_type = "none"

        # Step 5: Connect and list tools
        click.echo(f"Connecting to {url}...")
        try:
            server_name, tools = await connect_and_list_tools(
                url, auth_str, headers=headers
            )
        except (ConnectionError, RuntimeError) as e:
            click.echo(f"Error: {e}", err=True)
            sys.exit(1)

        click.echo(f"Found {len(tools)} tools:")
        for tool in tools:
            desc = (tool.description or "")[:60]
            click.echo(f"  - {tool.name}: {desc}")

        if not tools:
            click.echo("Warning: Server has 0 tools. Generating minimal skill.")

        module_name = derive_module_name(name)
        output_dir = Path(".agents") / "skills" / module_name
        if output_dir.exists():
            if not force:
                if non_interactive:
                    click.echo(
                        f"Error: Directory '{output_dir}' already exists. Use --force to overwrite.",
                        err=True,
                    )
                    sys.exit(1)
                if not click.confirm(f"Directory '{output_dir}' exists. Overwrite?"):
                    click.echo("Aborted.")
                    sys.exit(0)

        # Generate class name and description
        class_name = derive_class_name(app_name)
        description = generate_skill_description(server_name, tools)

        click.echo("Generating skill...")

        app_code = generate_app_py(
            class_name,
            url,
            tools,
            auth_type=auth_type,
            auth_header=auth_header,
            skill_name=name,
            module_name=module_name,
        )
        skill_md = generate_skill_md(
            name,
            description,
            tools,
            class_name,
            auth_type=auth_type,
            auth_header=auth_header,
            module_name=module_name,
        )

        output_dir.mkdir(parents=True, exist_ok=True)

        await asyncio.gather(
            asyncio.to_thread((output_dir / "__init__.py").write_text, ""),
            asyncio.to_thread((output_dir / "app.py").write_text, app_code),
            asyncio.to_thread((output_dir / "SKILL.md").write_text, skill_md),
        )

        app_py_path = output_dir / "app.py"
        click.echo("Validating generated code...")
        report = validate_generated_code(app_py_path)
        click.echo(report.summary())

        if not report.passed:
            click.echo(
                "\nWarning: Validation found issues. The skill was still generated but may need fixes.",
                err=True,
            )

        click.echo(f"\nSkill generated at ./{output_dir}/")
        click.echo(f"  {output_dir}/app.py")
        click.echo(f"  {output_dir}/SKILL.md")

    except Exception as e:
        click.echo(f"Error: {e}", err=True)
        sys.exit(1)
