from aiogram import Router, types
from aiogram.filters import Command
import logging
from datetime import datetime
from instences.config import BASE_URL_FASTAPI
import aiohttp
from aiogram.fsm.context import FSMContext
from aiogram.fsm.state import State, StatesGroup
from keyboard.keyboards import faq_keyboard, sup_keyboard, ticket_list_keyboard, ticket_keyboard

logger = logging.getLogger(__name__)
router = Router()

class TicketState(StatesGroup):
    subject = State()
    message = State()

async def call_api(method, endpoint, data=None):
    """
    Выполняет HTTP-запрос к FastAPI.
    """
    url = f"{BASE_URL_FASTAPI}{endpoint}"
    logger.info(f"Инициализация запроса: {method} {url} с данными {data}")

    try:
        async with aiohttp.ClientSession() as session:
            async with session.request(method, url, json=data) as response:
                logger.info(f"Получен ответ от {url}: статус {response.status}")

                if response.status in {200, 201}:
                    result = await response.json()
                    logger.debug(f"Ответ JSON: {result}")
                    return result
                if response.status == 404:
                    logger.debug(f"Код {response.status}, возвращаю ничего")
                    return None
                logger.error(f"Ошибка в запросе: статус {response.status}, причина {response.reason}")
                return "ERROR"
    except Exception as e:
        logger.exception(f"Исключение при выполнении запроса к {url}: {e}")
        return "ERROR"

@router.callback_query(lambda callback: callback.data == "faq")
async def faq_callback_handler(callback: types.CallbackQuery):
    """
    Обработчик callback_query с data="faq".
    """   
    await callback.message.edit_text(
        "FAQ YOU",
        reply_markup=faq_keyboard()
    )

@router.message(Command("support"))
async def supp(message: types.Message):
    """
    Меню сапп системы
    """
    await message.answer(
        "Добро пожаловать в саппорт систему!",
        reply_markup=sup_keyboard()
    )

@router.callback_query(lambda callback: callback.data == "main_sup")
async def supp_callback(callback: types.CallbackQuery):
    """
    Меню сапп системы (callback версия)
    """
    await callback.message.answer(
        "Добро пожаловать в саппорт систему!",
        reply_markup=sup_keyboard()
    )

@router.callback_query(lambda callback: callback.data == "my_tickets")
async def list_tickets_callback(callback: types.CallbackQuery):
    user_id = callback.from_user.id
    user_data = await call_api("GET", f"/user/{user_id}")
    if not user_data:
        user_data = await call_api("POST", f"/user/create", {"telegram_id": f"{user_id}"})

    tickets = await call_api("GET", f"/support/tickets?user_id={user_data['id']}")

    if tickets == "ERROR" or not tickets:
        await callback.message.edit_text("У вас нет тикетов.", reply_markup=sup_keyboard())
        return

    await callback.message.edit_text(
        "Ваши тикеты:",
        reply_markup=ticket_list_keyboard(tickets)
    )

@router.callback_query(lambda callback: callback.data == "make_ticket")
async def start_ticket_creation(callback: types.CallbackQuery, state: FSMContext):
    """
    Начинает процесс создания тикета.
    """
    await callback.message.answer(
        "Введите тему тикета (или нажмите 'Отмена', чтобы выйти):",
        reply_markup=ticket_keyboard()
    )
    await state.set_state(TicketState.subject)

@router.message()
async def handle_ticket_input(message: types.Message, state: FSMContext):
    """
    Обрабатывает ввод данных для тикета.
    """
    current_state = await state.get_state()
    if current_state == TicketState.subject:
        await state.update_data(subject=message.text)
        await message.answer("Введите описание проблемы:", reply_markup=ticket_keyboard())
        await state.set_state(TicketState.message)

    elif current_state == TicketState.message:
        user_data = await state.get_data()
        subject = user_data.get("subject")
        message_text = message.text
        await create_ticket(message, subject, message_text, state)
        await state.clear()

async def create_ticket(message: types.Message, subject: str, message_text: str, state: FSMContext):
    """
    Отправляет запрос на создание тикета через FastAPI.
    """
    user_id = message.from_user.id

    try:
        logger.info(f"Создание тикета для пользователя {user_id}: Тема - {subject}, Сообщение - {message_text}")

        user_data = await call_api("GET", f"/user/{user_id}")
        if not user_data:
            await message.answer("Вы еще не зарегистрированы.")
            return

        ticket_data = await call_api(
            "POST",
            f"/support/tickets?user_id={user_data['id']}",
            data={"subject": subject, "message": message_text}
        )

        if ticket_data != "ERROR":
            await message.answer(
                f"✅ Тикет успешно создан!\n"
                f"📌 Тема: {ticket_data['subject']}\n"
                f"📊 Статус: {ticket_data['status']}\n"
                f"📅 Дата создания: {ticket_data['created_at']}"
            )
        else:
            await message.answer("❌ Ошибка создания тикета. Попробуйте позже.")

    except Exception as e:
        logger.exception(f"Ошибка при создании тикета для пользователя {user_id}: {e}")
        await message.answer("❌ Произошла ошибка при создании тикета.")

@router.callback_query(lambda callback: callback.data == "cancel_ticket")
async def cancel_ticket_creation(callback: types.CallbackQuery, state: FSMContext):
    """
    Отмена создания тикета.
    """
    await state.clear()
    await callback.message.answer("Создание тикета отменено.", reply_markup=types.ReplyKeyboardRemove())