from idlelib import query
from sqlite3 import IntegrityError
from turtle import pd
from typing import Union

from aiogram import Dispatcher, F, types
from aiogram.filters import Command
from aiogram.fsm.context import FSMContext
from aiogram.types import Message, CallbackQuery
from aiogram.utils.markdown import hbold
import os
import pandas as pd

from bot.constants import SAVE_PATH
from bot.core_bot import Form, add_region_to_database, disable_buttons
from bot.decorators import user_permission
from bot.keyboards.inline_keyboard import RetailerKeyboards, CancelActionCallback, RetailerCallback, SalesDataKeyboards
from data_management_app.data_manager import SalesDataUploader


async def return_to_main_menu(event: Union[Message, CallbackQuery], message_text: str, state: FSMContext=None):
    if state:
        await state.clear()

    keyboard = RetailerKeyboards().create_main_keyboard()

    if isinstance(event, CallbackQuery):
        await event.message.edit_reply_markup(reply_markup=disable_buttons(event.message.reply_markup))
        await event.message.answer(
            text=message_text,
            reply_markup=keyboard
        )
    elif isinstance(event, Message):
        # await event.message.edit_reply_markup(reply_markup=disable_buttons(event.message.reply_markup))
        await event.answer(
            text=message_text,
            reply_markup=keyboard
        )
    else:
        raise ValueError("Unsupported event type passed to return_to_main_menu.")


class GeneralControlHandler:
    def __init__(self, dp: Dispatcher):
        self.dp = dp
        self.register_handlers()


    def register_handlers(self):
        @self.dp.message(Command("activate_menu"))
        @user_permission
        async def activate_menu(message: Message) -> None:
            """Handler for showing retailers"""
            main_keyboard = RetailerKeyboards().create_main_keyboard()
            await message.answer(
                "Главное меню",
                reply_markup=main_keyboard
            )

        @self.dp.callback_query(CancelActionCallback.filter(F.foo == 'cancel_action'))
        async def command_cancel_action(
                query: CallbackQuery,
                state: FSMContext,
        ):
            await return_to_main_menu(query, message_text='Действие отменено. Возвращение в главное меню:', state=state)

        @self.dp.message(Command("id"))
        async def command_id(message: types.Message) -> None:
            """
            This handler receives messages with `/id` command
            """
            if message.chat.id == message.from_user.id:
                response_text = f"Ваш id: {hbold(message.from_user.id)}"
            else:
                response_text = (
                    f"ID Группы: {hbold(message.chat.id)}\n"
                    f"Ваш id: {hbold(message.from_user.id)}"
                )

            await message.answer(text=response_text, parse_mode='HTML')

        @self.dp.callback_query(RetailerCallback.filter(F.foo == 'remove_data_menu'))
        @user_permission
        async def command_remove_data_menu(
                query: CallbackQuery,
                state: FSMContext,
        ):
            message = "Добро пожаловать в меню удаления данных"
            keyboard = SalesDataKeyboards().delete_data_keyboard()
            await query.message.edit_text(
                text=message,
                reply_markup=keyboard
            )

        @self.dp.callback_query(RetailerCallback.filter(F.foo == 'download_data_menu'))
        @user_permission
        async def command_download_data_menu(
                query: CallbackQuery,
                state: FSMContext,
        ):
            message = "Добро пожаловать в меню выгрузки данных!"
            keyboard = SalesDataKeyboards().unload_data_keyboard()
            await query.message.edit_text(
                text=message,
                reply_markup=keyboard
            )

        @self.dp.callback_query(RetailerCallback.filter(F.foo == 'upload_specification'))
        @user_permission
        async def uploading_specification(
                query: CallbackQuery,
                state: FSMContext
        ) -> None:
            await query.message.edit_reply_markup(reply_markup=None)
            await query.message.answer("Пожалуйста загрузите спецификацию!")
            await state.set_state(Form.uploading_specification)


        @self.dp.message(Form.uploading_specification)
        @user_permission
        async def handle_document(message: Message, state: FSMContext):
            file_path = None
            try:
                document = message.document
                if not document.file_name.endswith(('.xls', '.xlsx')):
                    await message.answer(
                        "Формат файла не соответствует Excel. Проверьте, что отправили правильный формат.")
                    await return_to_main_menu(message, "Возвращение в главное меню:", state=state)
                    return

                bot = message.bot
                file_id = message.document.file_id
                file = await bot.get_file(file_id)
                file_path = f'databases/specification.xls'

                await bot.download_file(file.file_path, destination=file_path)

                await message.answer(
                    text=f"Загрузка спецификации прошла успешно!",
                    parse_mode='HTML'
                )

            except Exception as e:
                await message.answer(f"Произошла непредвиденная ошибка: {e}")
                if file_path and os.path.isfile(file_path):
                    try:
                        os.remove(file_path)
                        print(f"File {file_path} successfully deleted.")
                    except Exception as e:
                        print(f"Error deleting file {file_path}: {e}")
            finally:
                await return_to_main_menu(message, message_text='Главное меню.', state=state)