from __future__ import annotations

import tempfile
import unittest
from pathlib import Path

from prompt64.providers import ClaudeProvider, CodexProvider, FakeProvider
from prompt64.server import create_provider, parse_args, validate_args


class ServerCliTests(unittest.TestCase):
    def test_defaults_to_codex_and_accepts_legacy_cwd_alias(self) -> None:
        with tempfile.TemporaryDirectory() as cwd:
            args = parse_args(["--codex-cwd", cwd])
            validate_args(args, {})
            provider = create_provider(args)

        self.assertEqual(args.provider, "codex")
        self.assertEqual(args.agent_cwd, cwd)
        self.assertIsInstance(provider, CodexProvider)
        self.assertEqual(provider.cwd, str(Path(cwd).resolve()))

    def test_agent_cwd_model_and_claude_factory(self) -> None:
        with tempfile.TemporaryDirectory() as cwd:
            args = parse_args(
                [
                    "--provider",
                    "claude",
                    "--agent-cwd",
                    cwd,
                    "--model",
                    "claude-sonnet-test",
                    "--claude-command",
                    "/opt/claude",
                    "--claude-auth",
                    "subscription",
                ]
            )
            validate_args(args, {})
            provider = create_provider(args)

        self.assertIsInstance(provider, ClaudeProvider)
        self.assertEqual(provider.model, "claude-sonnet-test")
        self.assertEqual(provider.command, "/opt/claude")
        self.assertEqual(provider.auth_mode, "subscription")

    def test_local_provider_is_required_and_exclusive(self) -> None:
        args = parse_args(["--provider", "local"])
        with self.assertRaisesRegex(ValueError, "required"):
            validate_args(args, {})

        args = parse_args(["--local-provider", "ollama"])
        with self.assertRaisesRegex(ValueError, "requires"):
            validate_args(args, {})

    def test_local_factory_preserves_codex_and_provider_name(self) -> None:
        with tempfile.TemporaryDirectory() as cwd:
            args = parse_args(
                [
                    "--provider",
                    "local",
                    "--local-provider",
                    "lmstudio",
                    "--agent-cwd",
                    cwd,
                    "--model",
                    "local-model",
                ]
            )
            validate_args(args, {})
            provider = create_provider(args)

        self.assertIsInstance(provider, CodexProvider)
        self.assertEqual(provider.local_provider, "lmstudio")
        self.assertEqual(provider.name, "lmstudio")
        self.assertEqual(provider.model, "local-model")

    def test_claude_api_mode_requires_supported_credentials(self) -> None:
        args = parse_args(["--provider", "claude"])
        with self.assertRaisesRegex(ValueError, "ANTHROPIC_API_KEY"):
            validate_args(args, {})

        for environ in (
            {"ANTHROPIC_API_KEY": "secret"},
            {"CLAUDE_CODE_USE_BEDROCK": "1"},
            {"CLAUDE_CODE_USE_VERTEX": "true"},
            {"CLAUDE_CODE_USE_FOUNDRY": "yes"},
        ):
            validate_args(args, environ)

    def test_subscription_is_an_explicit_no_api_credential_opt_in(self) -> None:
        args = parse_args(
            [
                "--provider",
                "claude",
                "--claude-auth",
                "subscription",
            ]
        )
        validate_args(args, {})
        self.assertEqual(args.claude_auth, "subscription")

    def test_fake_factory_remains_offline(self) -> None:
        args = parse_args(["--provider", "fake"])
        validate_args(args, {})
        self.assertIsInstance(create_provider(args), FakeProvider)