import logging
import os
from typing import Optional

import aiohttp

logger = logging.getLogger(__name__)

BASE_URL = "https://api.shiznumber.com/api"


def _headers() -> dict:
    return {
        "Accept": "application/json",
        "Content-Type": "application/json",
        "X-API-KEY": os.getenv("SHIZNUMBER_API_KEY", ""),
    }


async def _request(
    method: str,
    path: str,
    json_data: Optional[dict] = None,
):
    key = os.getenv("SHIZNUMBER_API_KEY", "").strip()

    if not key:
        logger.error("SHIZNUMBER_API_KEY is not configured")
        return None

    url = f"{BASE_URL}/{path.lstrip('/')}"
    timeout = aiohttp.ClientTimeout(total=20)

    try:
        async with aiohttp.ClientSession(timeout=timeout) as session:
            async with session.request(
                method,
                url,
                headers=_headers(),
                json=json_data,
            ) as resp:
                raw = await resp.text()

                if resp.status >= 400:
                    logger.warning(
                        "ShizNumber API error [%s]: %s",
                        resp.status,
                        raw[:1000],
                    )
                    return {
                        "success": False,
                        "status": resp.status,
                        "error": raw[:1000],
                    }

                try:
                    return await resp.json(content_type=None)
                except Exception:
                    logger.error("Invalid JSON: %s", raw[:500])
                    return None

    except Exception as exc:
        logger.error("ShizNumber request failed: %s", exc)
        return None


async def get_user():
    return await _request("GET", "/user")


async def get_services():
    return await _request("GET", "/services")


async def get_countries():
    return await _request("GET", "/countries")


async def get_numbers():
    return await _request("GET", "/numbers")


async def get_service_numbers(service_slug: str):
    return await _request(
        "GET",
        f"/services/{service_slug}/numbers",
    )


async def get_country_numbers(country_slug: str):
    return await _request(
        "GET",
        f"/countries/{country_slug}/numbers",
    )


async def get_number(number_id: int):
    return await _request(
        "GET",
        f"/numbers/{int(number_id)}",
    )


async def buy_number(number_id: int):
    return await _request(
        "POST",
        f"/numbers/{int(number_id)}",
    )


async def get_order(order_id: int):
    return await _request(
        "GET",
        f"/orders/{int(order_id)}",
    )


async def cancel_order(order_id: int):
    return await _request(
        "PUT",
        f"/orders/{int(order_id)}/cancel",
    )


async def report_order(order_id: int):
    return await _request(
        "PUT",
        f"/orders/{int(order_id)}/report",
    )


async def recode_order(order_id: int):
    return await _request(
        "PUT",
        f"/orders/{int(order_id)}/recode",
    )

async def get_telegram_numbers_with_prices():
    """
    Get Telegram inventory from ShizNumber and convert it to the
    same pricing structure used by the existing virtual-number flow.
    No purchase request is made here.
    """
    from database.db import get_profit_margin
    from config import config

    data = await get_service_numbers("telegram")
    if not isinstance(data, list):
        return []

    margin = await get_profit_margin(
        config.ACCOUNT_PROFIT_MARGIN_PERCENT
    ) / 100

    result = []

    for item in data:
        if not isinstance(item, dict):
            continue

        try:
            number_id = int(item.get("id"))
        except (TypeError, ValueError):
            continue

        raw_price = item.get("price", item.get("amount", 0))
        try:
            base_price = int(float(raw_price))
        except (TypeError, ValueError):
            continue

        raw_count = item.get("count", 0)
        try:
            count = int(float(str(raw_count).replace(",", "").replace("،", "")))
        except (TypeError, ValueError):
            count = 0

        fa_name = str(item.get("fa_name") or item.get("name") or "").strip()
        country = (
            item.get("country")
            or item.get("country_name")
            or fa_name
            or "نامشخص"
        )

        result.append({
            "provider": "shiznumber",
            "number_id": number_id,
            "service_slug": "telegram",
            "country": str(country),
            "country_slug": item.get("slug"),
            "name": fa_name,
            "base_price": base_price,
            "final_price": int(base_price + (base_price * margin)),
            "count": count,
            "in_stock": count > 0,
        })

    result.sort(key=lambda x: (x["country"], x["final_price"]))

    logger.info(
        "ShizNumber Telegram inventory loaded: %s items",
        len(result),
    )

    return result