import logging

from aiogram import F, Router
from aiogram.fsm.context import FSMContext
from aiogram.types import CallbackQuery, Message
from aiogram.utils.keyboard import InlineKeyboardBuilder

from bot.config import settings
from bot.keyboards.common import cancel_keyboard, main_menu_keyboard
from bot.services.api import ApiError, api
from bot.services.checkout import render, show_result
from bot.services.texts import money, texts
from bot.states.purchase import SupportStates, TrackStates

logger = logging.getLogger("bot.account")
router = Router(name="account")


@router.callback_query(F.data == "menu:account")
async def account_menu(callback: CallbackQuery, state: FSMContext) -> None:
    await state.clear()
    data = await api.me(callback.from_user.id)
    user = data["user"]

    builder = InlineKeyboardBuilder()
    builder.button(text=await texts.text("btn_my_orders"), callback_data="menu:orders")
    builder.button(text=await texts.text("btn_wallet_history"), callback_data="menu:wallet")
    builder.button(text=await texts.text("btn_back"), callback_data="menu:main")
    builder.adjust(2, 1)

    text = await texts.text(
        "account_menu",
        telegram_id=user["telegram_id"],
        name=user.get("first_name") or user.get("username") or "",
        balance=money(data["wallet"]["balance"]),
        orders=len(data.get("recent_orders", [])),
    )
    await render(callback, text, builder.as_markup())
    await callback.answer()


@router.callback_query(F.data == "menu:wallet")
async def wallet_menu(callback: CallbackQuery, state: FSMContext) -> None:
    await state.clear()
    wallet = await api.wallet(callback.from_user.id)
    history = await api.transactions(callback.from_user.id)

    lines = [await texts.text("wallet_menu", balance=money(wallet["balance"]))]
    items = history.get("items", [])
    if items:
        lines.append("")
        lines.append(await texts.text("wallet_history"))
        for item in items:
            sign = "+" if float(item["amount"]) >= 0 else ""
            lines.append(f"{sign}{money(item['amount'])} — {item.get('description') or item['type']}")
    else:
        lines.append(await texts.text("wallet_empty_history"))

    builder = InlineKeyboardBuilder()
    builder.button(text=await texts.text("btn_topup"), callback_data="menu:topup")
    builder.button(text=await texts.text("btn_back"), callback_data="menu:main")
    builder.adjust(1)

    await render(callback, "\n".join(lines), builder.as_markup())
    await callback.answer()


@router.callback_query(F.data == "menu:referral")
async def referral_menu(callback: CallbackQuery, state: FSMContext) -> None:
    await state.clear()
    data = await api.referral(callback.from_user.id)
    username = settings.bot_username or await texts.setting("bot_username", "")
    link = f"https://t.me/{username}?start={data['referral_code']}" if username else data["referral_code"]

    text = await texts.text(
        "referral_menu",
        link=link,
        invited_count=data["invited_count"],
        orders_count=data["orders_count"],
        total_reward=money(data["total_reward"]),
        percent=data["percent"],
    )
    await render(callback, text, await main_menu_keyboard())
    await callback.answer()


@router.callback_query(F.data == "menu:track")
async def ask_order_number(callback: CallbackQuery, state: FSMContext) -> None:
    await state.clear()
    await state.set_state(TrackStates.order_number)
    await render(callback, await texts.text("input_track"), await cancel_keyboard())
    await callback.answer()


@router.message(TrackStates.order_number)
async def track_order(message: Message, state: FSMContext) -> None:
    if not message.text:
        return
    try:
        order = await api.track(message.from_user.id, message.text.strip())
    except ApiError:
        await message.answer(await texts.text("order_not_found"))
        return

    await state.clear()
    status = await texts.text(f"status_{order['status']}")
    text = await texts.text(
        "track_result",
        order_number=order["order_number"],
        title=order["product_snapshot"].get("title", ""),
        final_price=money(order["final_price"]),
        status=status,
        created_at=order["created_at"][:10],
    )
    await message.answer(text, reply_markup=await main_menu_keyboard())


@router.callback_query(F.data == "menu:support")
async def support_menu(callback: CallbackQuery, state: FSMContext) -> None:
    await state.clear()
    text = await texts.text(
        "support_menu",
        text=await texts.setting("support_text", ""),
        support_username=await texts.setting("support_username", ""),
    )
    builder = InlineKeyboardBuilder()
    builder.button(text=await texts.text("btn_contact_support"), callback_data="support:new")
    builder.button(text=await texts.text("btn_back"), callback_data="menu:main")
    builder.adjust(1)

    await render(callback, text, builder.as_markup())
    await callback.answer()


@router.callback_query(F.data == "support:new")
async def ask_support_message(callback: CallbackQuery, state: FSMContext) -> None:
    await state.set_state(SupportStates.message)
    await render(callback, await texts.text("input_support"), await cancel_keyboard())
    await callback.answer()


@router.message(SupportStates.message)
async def send_support_message(message: Message, state: FSMContext) -> None:
    if not message.text:
        return
    await api.create_ticket(message.from_user.id, message.text.strip())
    await state.clear()
    await message.answer(await texts.text("support_sent"), reply_markup=await main_menu_keyboard())


@router.callback_query(F.data.startswith("ord:result:"))
async def order_result(callback: CallbackQuery) -> None:
    order = await api.order(callback.from_user.id, callback.data.split(":")[2])
    await show_result(callback, order)
    await callback.answer()