from aiogram import Router, F
from aiogram.filters import Command
from aiogram.fsm.context import FSMContext
from aiogram.fsm.state import StatesGroup, State
from aiogram.types import Message, CallbackQuery, InlineKeyboardButton
from aiogram.utils.i18n import I18n
from aiogram.utils.keyboard import InlineKeyboardBuilder
from logging import getLogger
from sqlmodel.ext.asyncio.session import AsyncSession

from ....model.settings import Settings
from ....model.user import UserBase
from ..context import ContextData, CallbackCommand, CommandContext

from ..navigation import save_navigation_context, pop_navigation_context


logger = getLogger(__name__)
router = Router()


@router.callback_query(ContextData.filter(F.command == CallbackCommand.MENU_ENTRY_PARAMETERS))
async def menu_entry_parameters(message: CallbackQuery, **kwargs):

    callback_data: ContextData = kwargs["callback_data"]
    state: FSMContext = kwargs["state"]
    state_data = await state.get_data()
    kwargs["state_data"] = state_data

    clear_state(state_data = state_data)
    stack = save_navigation_context(callback_data = callback_data, state_data = state_data)

    await parameters_menu(message = message, navigation_stack = stack, **kwargs)   


async def parameters_menu(message: Message | CallbackQuery,
                          user: UserBase,
                          callback_data: ContextData,
                          navigation_stack: list[ContextData],
                          **kwargs):

    if not await authorize_command(user = user, callback_data = callback_data):
        await message.answer(await Settings.get(Settings.APP_STRINGS_FORBIDDEN))

    settings = await Settings.get_params()
    
    keyboard_builder = InlineKeyboardBuilder()
    for key, value in settings.items():

        if not key.is_visible:
            continue

        if key.caption_value:
            caption = get_callable_str(callable_str = key.caption_value, descriptor = key, entity = None, value = value)
        else:
            if key.caption:
                caption = get_callable_str(callable_str = key.caption, descriptor = key, entity = None, value = value)
            else:
                caption = key.name 
            
            if key.type_ == bool:
                caption = f"{"【✔︎】" if value else "【  】"} {caption}"
            else: 
                caption = f"{caption}: {get_value_repr(value = value, field_descriptor = key, locale = user.lang)}"
            

        keyboard_builder.row(InlineKeyboardButton(text = caption,
                                                    callback_data = ContextData(
                                                        command = CallbackCommand.FIELD_EDITOR,
                                                        context = CommandContext.SETTING_EDIT,
                                                        field_name = key.name).pack()))
    
    context = pop_navigation_context(navigation_stack)
    if context:
        keyboard_builder.row(InlineKeyboardButton(text = (await Settings.get(Settings.APP_STRINGS_BACK_BTN)),
                                                  callback_data = context.pack()))

    state: FSMContext = kwargs["state"]
    state_data = kwargs["state_data"]
    await state.set_data(state_data)

    send_message = get_send_message(message)

    await send_message(text = (await Settings.get(Settings.APP_STRINGS_PARAMETERS)), reply_markup = keyboard_builder.as_markup())


from ..navigation import pop_navigation_context, get_navigation_context, clear_state
from ..common import get_send_message, get_value_repr, get_callable_str, authorize_command