# - *- coding: utf- 8 - *-
import json
from typing import Any, Dict, Optional, Tuple, Union

from aiogram import Bot
from aiogram.types import CallbackQuery, Message
from aiohttp import ClientConnectorCertificateError

from tgbot.database import Paymentsx
from tgbot.utils.const_functions import ded, to_number
from tgbot.utils.misc.bot_logging import bot_logger
from tgbot.utils.misc.bot_models import ARS
from tgbot.utils.misc_functions import send_admins

# Список поддерживаемых валют
ALLOW_CURRENCIES = [
    "BTC",
    "ETH",
    "LTC",
    "USDT",
    "USDC",
    "TRX",
    "TON",
    "BNB",
    "SOL",
    "DOGE",
]


# АПИ для работы с CryptoBot
class CryptobotAPI:
    # Настройка клиента CryptoBot
    def __init__(
        self,
        bot: Bot,
        arSession: ARS,
        update: Optional[Union[Message, CallbackQuery]] = None,
        token: str = "None",
        adding: bool = False,
        skipping_error: bool = False,
    ):
        self.bot = bot
        self.arSession = arSession
        self.update = update
        self.token = token
        self.adding = adding
        self.skipping_error = skipping_error

    # Инициализация данных
    @classmethod
    async def connect(
        cls,
        bot: Bot,
        arSession: ARS,
        update: Optional[Union[Message, CallbackQuery]] = None,
        token: Optional[str] = None,
        skipping_error: bool = False,
    ) -> "CryptobotAPI":
        adding = token is not None

        if token is None:
            payments = await Paymentsx().get()
            token = payments.cryptobot_token
            adding = False

        return cls(
            bot=bot,
            arSession=arSession,
            update=update,
            token=token,
            adding=adding,
            skipping_error=skipping_error,
        )

    # Уведомления о неработоспособности кассы/кошелька
    async def error_notification(self, error_code: str = "Unknown"):
        bot_logger.warning("CryptoBot недоступен: %s", error_code)

        if not self.skipping_error:
            if self.adding and self.update is not None:
                await self.update.edit_text(
                    f"<b>🔷 Не удалось добавить CryptoBot кассу ❌</b>\n"
                    f"❗️ Ошибка: <code>{error_code}</code>"
                )
            else:
                await send_admins(
                    self.bot,
                    f"<b>🔷 CryptoBot недоступен. Как можно быстрее его замените</b>\n"
                    f"❗️ Ошибка: <code>{error_code}</code>",
                )

    # Проверка кассы/кошелька
    async def check(self) -> Tuple[bool, str]:
        status, response = await self._request("getMe")

        if status and response["ok"]:
            return True, ded(
                f"""
                <b>🔷 CryptoBot кошелёк полностью функционирует ✅</b>
                ➖➖➖➖➖➖➖➖➖➖
                ▪️ Токен: <code>{self.token}</code>
                ▪️ Айди: <code>{response['result']['app_id']}</code>
                ▪️ Имя: <code>{response['result']['name']}</code>
            """
            )

        return False, "<b>🔷 Не удалось проверить CryptoBot кошелёк ❌</b>"

    # Получение баланса
    async def balance(self) -> str:
        status, response = await self._request("getBalance")

        if status and response["ok"]:
            save_currencies = []

            response_balances = sorted(
                response["result"],
                reverse=True,
                key=lambda balance: to_number(balance["available"]),
            )

            for currency in response_balances:
                if currency["currency_code"] in ALLOW_CURRENCIES:
                    save_currencies.append(
                        f"▪️ {currency['currency_code']}: <code>{currency['available']}</code>"
                    )

            save_currencies = "\n".join(save_currencies)

            return ded(f"""
                <b>🔷 Баланс CryptoBot кошелька составляет</b>
                ➖➖➖➖➖➖➖➖➖➖
                {save_currencies}
            """)

        return "<b>🔷 Не удалось получить баланс CryptoBot кошелька ❌</b>"

    # Создание счета на оплату
    async def bill(
        self, pay_amount: Union[float, int]
    ) -> Tuple[Union[str, bool], str, str]:
        assets_currencies = ",".join(ALLOW_CURRENCIES)

        payload = {
            "currency_type": "fiat",
            "fiat": "RUB",
            "amount": str(pay_amount),
            "expires_in": 10800,
            "accepted_assets": assets_currencies,
        }

        status, response = await self._request("createInvoice", payload)

        if status and response["ok"]:
            bill_message = ded(f"""
                <b>💰 Пополнение баланса</b>
                ➖➖➖➖➖➖➖➖➖➖
                ▪️ Для пополнения баланса, нажмите на кнопку ниже
                <code>Перейти к оплате</code> и оплатите выставленный вам счёт
                ▪️ У вас имеется 3 часа на оплату счета
                ▪️ Сумма пополнения: <code>{pay_amount}₽</code>
                ➖➖➖➖➖➖➖➖➖➖
                ❗️ После оплаты, нажмите на <code>Проверить оплату</code>
            """)

            return (
                bill_message,
                response["result"]["mini_app_invoice_url"],
                response["result"]["invoice_id"],
            )

        return False, "", ""

    # Проверка счета на оплату
    async def bill_check(
        self, bill_receipt: Optional[Union[str, int]] = None, records: int = 1
    ) -> Tuple[int, float]:
        payload = {
            "invoice_ids": f"{bill_receipt}",
            "fiat": "RUB",
        }

        status, response = await self._request("getInvoices", payload)

        pay_status, pay_amount = 1, 0

        if status and response["ok"]:
            get_invoice = response["result"]["items"][0]

            if get_invoice["status"] == "active":
                pay_status = 2
            elif get_invoice["status"] == "expired":
                pay_status = 3
            else:
                pay_status = 0
                pay_amount = to_number(get_invoice["amount"])

        return pay_status, pay_amount

    # Генерация запроса
    async def _request(
        self,
        method: str,
        data: Optional[Dict[str, Any]] = None,
    ) -> Tuple[bool, Any]:
        session = await self.arSession.get_session()

        base_url = "https://pay.crypt.bot/api/"
        headers = {
            "Crypto-Pay-API-Token": self.token,
            "Content-Type": "application/x-www-form-urlencoded",
        }

        url = base_url + method

        try:
            response = await session.post(
                url=url,
                headers=headers,
                data=data,
            )

            response_data = json.loads((await response.read()).decode())

            if response.status == 200:
                return True, response_data
            else:
                await self.error_notification(
                    f"{response.status} - {str(response_data)}"
                )

                return False, response_data
        except ClientConnectorCertificateError:
            bot_logger.warning("Ошибка SSL при запросе CryptoBot", exc_info=True)
            await self.error_notification("CERTIFICATE_VERIFY_FAILED")

            return False, "CERTIFICATE_VERIFY_FAILED"
        except Exception as ex:
            bot_logger.warning("Ошибка запроса CryptoBot", exc_info=True)
            await self.error_notification(str(ex))

            return False, str(ex)