"""Командный интерфейс для работы с API сервиса проверки IOC."""

from __future__ import annotations

import argparse
import asyncio
import logging
import sys
from pathlib import Path
from typing import Any

import httpx

from ioc_checker.config import configure_logging, settings

logger = logging.getLogger(__name__)


class SimpleCli:
    """Минимальный клиент для общения с API."""

    def __init__(
        self,
        base_url: str,
        timeout: float,
        *,
        verify: bool,
        proxy: str | None,
    ) -> None:
        self._base_url = base_url.rstrip("/")
        self._timeout = timeout
        self._verify = verify
        self._proxy = proxy

    def _read_text(self, file_path: Path) -> str:
        """Прочитать сырой текст из файла без дополнительной обработки."""

        logger.info("Чтение исходного текста из файла %s", file_path)
        text = file_path.read_text(encoding="utf-8")
        logger.debug("Загружено %d символов", len(text))
        return text

    async def submit(self, file_path: Path) -> dict[str, Any]:
        """Передать IOC в API и вернуть исходный JSON."""

        source_text = self._read_text(file_path)
        payload: dict[str, Any] = {"text": source_text}
        logger.debug("Отправка в API: %s", payload)
        client_args: dict[str, Any] = {
            "base_url": self._base_url,
            "timeout": self._timeout,
            "verify": self._verify,
        }
        if self._proxy:
            client_args["proxies"] = self._proxy
        async with httpx.AsyncClient(**client_args) as client:
            response = await client.post("/api/tasks", json=payload)
        response.raise_for_status()
        logger.info("API вернуло корректный ответ, продолжаем обработку")
        data = response.json()
        logger.debug("Ответ API: %s", data)
        return data

    @staticmethod
    def print_response(data: dict[str, Any]) -> None:
        """Вывести результат без интерпретации."""

        print("Ответ API:")
        for key, value in data.items():
            print(f"  {key}: {value}")


def _build_parser() -> argparse.ArgumentParser:
    """Создать парсер аргументов командной строки."""

    default_url = f"http://{settings.api_host}:{settings.api_port}"
    parser = argparse.ArgumentParser(
        description="CLI для постановки IOC на проверку через API",
    )
    parser.add_argument(
        "file",
        type=Path,
        help="Путь к файлу с IOC (по одному в строке)",
    )
    parser.add_argument(
        "--api-url",
        default=default_url,
        help="Базовый URL API (по умолчанию берётся из конфигурации)",
    )
    parser.add_argument(
        "--timeout",
        type=float,
        default=settings.http_timeout,
        help="Таймаут ожидания ответа API в секундах",
    )
    return parser


async def _async_main(arguments: list[str]) -> int:
    """Асинхронная точка входа для CLI."""

    parser = _build_parser()
    args = parser.parse_args(arguments)
    configure_logging()
    client = SimpleCli(
        base_url=args.api_url,
        timeout=args.timeout,
        verify=not settings.http_proxy_skip_verify,
        proxy=settings.http_proxy,
    )
    data = await client.submit(args.file)
    client.print_response(data)
    return 0


def main(argv: list[str] | None = None) -> int:
    """Синхронная точка входа."""

    arguments = list(sys.argv[1:] if argv is None else argv)
    return asyncio.run(_async_main(arguments))


if __name__ == "__main__":  # pragma: no cover - защищаем запуск как скрипта
    raise SystemExit(main())
