from __future__ import annotations

import os
from pathlib import Path
from typing import Any

from services.ai.apimart_image_client import APIMartConfigError, APIMartImageGenerationClient, APIMartVisualReviewClient
from services.ai.openai_image_client import OpenAIConfigError, OpenAIImageGenerationClient, OpenAIVisualReviewClient
from services.ai.qwen_client import QwenImageGenerationClient, QwenReviewClient


def load_image_generator(env_path: str | Path = ".env.local", **kwargs: Any) -> Any:
    values = _read_env_file(Path(env_path))
    merged = {
        **values,
        **{
            key: value
            for key, value in os.environ.items()
            if key.startswith("PET_") or key.startswith("APIMART_") or key.startswith("OPENAI_") or key.startswith("QWEN_")
        },
    }
    provider_raw = str(merged.get("PET_IMAGE_PROVIDER", "")).strip()
    provider = provider_raw.lower()
    if not provider or provider in {"auto", "default"}:
        return _load_default_image_generator_chain(env_path, merged=merged, **kwargs)
    if provider in {"qwen", ""}:
        return QwenImageGenerationClient.from_env(env_path, **kwargs)
    if provider in {"apimart", "apimart_gpt_image_2", "gpt-image-2"}:
        enabled = str(merged.get("APIMART_IMAGE_PROVIDER_ENABLED", "")).strip().lower()
        if enabled not in {"1", "true", "yes", "on"}:
            raise APIMartConfigError(
                "APIMart image provider is disabled. Set APIMART_IMAGE_PROVIDER_ENABLED=true before using PET_IMAGE_PROVIDER=apimart."
            )
        return APIMartImageGenerationClient.from_env(env_path, **kwargs)
    if provider in {"openai", "official_openai", "openai_gpt_image", "openai-gpt-image"}:
        enabled = str(merged.get("OPENAI_IMAGE_PROVIDER_ENABLED", "")).strip().lower()
        if enabled not in {"1", "true", "yes", "on"}:
            raise OpenAIConfigError(
                "OpenAI image provider is disabled. Set OPENAI_IMAGE_PROVIDER_ENABLED=true before using PET_IMAGE_PROVIDER=openai."
            )
        return OpenAIImageGenerationClient.from_env(env_path, **kwargs)
    raise ValueError(f"Unsupported PET_IMAGE_PROVIDER: {provider!r}")


def _load_default_image_generator_chain(
    env_path: str | Path,
    *,
    merged: dict[str, str],
    **kwargs: Any,
) -> Any:
    errors: list[str] = []
    if _enabled(merged.get("OPENAI_IMAGE_PROVIDER_ENABLED", "")):
        try:
            return OpenAIImageGenerationClient.from_env(env_path, **kwargs)
        except Exception as exc:
            errors.append(f"openai: {type(exc).__name__}: {exc}")
    else:
        errors.append("openai: OPENAI_IMAGE_PROVIDER_ENABLED is not true")
    if _enabled(merged.get("APIMART_IMAGE_PROVIDER_ENABLED", "")):
        try:
            return APIMartImageGenerationClient.from_env(env_path, **kwargs)
        except Exception as exc:
            errors.append(f"apimart: {type(exc).__name__}: {exc}")
    else:
        errors.append("apimart: APIMART_IMAGE_PROVIDER_ENABLED is not true")
    raise ValueError(
        "Default image provider chain is unavailable. Configure OpenAI first "
        "(OPENAI_IMAGE_PROVIDER_ENABLED=true plus OPENAI_* settings) or APIMart fallback "
        "(APIMART_IMAGE_PROVIDER_ENABLED=true plus APIMART_* settings). "
        f"Checked: {'; '.join(errors)}"
    )


def load_visual_reviewer(
    env_path: str | Path = ".env.local",
    *,
    provider_slug: str | None = None,
    **kwargs: Any,
) -> Any:
    values = _read_env_file(Path(env_path))
    merged = {
        **values,
        **{
            key: value
            for key, value in os.environ.items()
            if key.startswith("PET_") or key.startswith("APIMART_") or key.startswith("OPENAI_") or key.startswith("QWEN_")
        },
    }
    provider_raw = str(
        provider_slug
        or merged.get("PET_VISUAL_REVIEW_PROVIDER")
        or merged.get("PET_IMAGE_PROVIDER", "")
    ).strip()
    if not provider_raw:
        raise ValueError("Set PET_VISUAL_REVIEW_PROVIDER or PET_IMAGE_PROVIDER explicitly; no default reviewer is allowed.")
    provider = provider_raw.lower()
    if provider in {"openai", "official_openai", "openai_gpt_image", "openai-gpt-image"}:
        return OpenAIVisualReviewClient.from_env(env_path, **kwargs)
    if provider in {"apimart", "apimart_gpt_image_2", "gpt-image-2"}:
        return APIMartVisualReviewClient.from_env(env_path, **kwargs)
    if provider in {"qwen", ""}:
        return QwenReviewClient.from_env(env_path)
    raise ValueError(f"Unsupported PET_VISUAL_REVIEW_PROVIDER: {provider!r}")


def _enabled(value: str | None) -> bool:
    return str(value or "").strip().lower() in {"1", "true", "yes", "on"}


def _read_env_file(path: Path) -> dict[str, str]:
    if not path.exists():
        return {}
    values: dict[str, str] = {}
    for raw_line in path.read_text(encoding="utf-8").splitlines():
        line = raw_line.strip()
        if not line or line.startswith("#") or "=" not in line:
            continue
        key, value = line.split("=", 1)
        values[key.strip()] = value.strip().strip('"').strip("'")
    return values