import logging
from aiogram import types
from aiogram.dispatcher import FSMContext
from aiogram.dispatcher.filters.state import State, StatesGroup
from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
from database import add_order, get_order_history
from logger import log_action

logging.basicConfig(level=logging.INFO)

class OrderForm(StatesGroup):
    waiting_for_name = State()
    waiting_for_phone = State()
    waiting_for_address = State()
    waiting_for_cleaning_time = State()
    waiting_for_cleaning_type = State()
    waiting_for_payment_method = State()
    confirmation = State()

def main_menu_keyboard():
    keyboard = InlineKeyboardMarkup()
    keyboard.add(InlineKeyboardButton('Учетные данные', callback_data='account_data'))
    keyboard.add(InlineKeyboardButton('Сделать заказ', callback_data='make_order'))
    keyboard.add(InlineKeyboardButton('История заказов', callback_data='order_history'))
    keyboard.add(InlineKeyboardButton('Заказать звонок', callback_data='request_call'))
    keyboard.add(InlineKeyboardButton('Начать разговор с оператором', callback_data='talk_operator'))
    return keyboard

def account_data_keyboard():
    keyboard = InlineKeyboardMarkup()
    keyboard.add(InlineKeyboardButton('Изменить ФИО', callback_data='change_name'))
    keyboard.add(InlineKeyboardButton('Изменить номер телефона', callback_data='change_phone'))
    keyboard.add(InlineKeyboardButton('Добавить адрес', callback_data='add_address'))
    keyboard.add(InlineKeyboardButton('Удалить адрес', callback_data='delete_address'))
    keyboard.add(InlineKeyboardButton('Поделиться контактом', callback_data='share_contact'))
    keyboard.add(InlineKeyboardButton('Назад', callback_data='back_to_main'))
    return keyboard

def order_confirmation_keyboard():
    keyboard = InlineKeyboardMarkup()
    keyboard.add(InlineKeyboardButton('Подтвердить', callback_data='confirm_order'))
    return keyboard

def register_handlers(dp, OPERATORS_GROUP_ID):
    @dp.message_handler(commands=['start'])
    async def send_welcome(message: types.Message):
        await message.answer("Добро пожаловать в BOTKlining!", reply_markup=main_menu_keyboard())
        log_action(message.from_user.id, 'start')

    @dp.callback_query_handler(lambda c: c.data == 'account_data')
    async def process_account_data(callback_query: types.CallbackQuery):
        await callback_query.answer()
        await callback_query.message.answer("Учетные данные:", reply_markup=account_data_keyboard())
        log_action(callback_query.from_user.id, 'account_data')

    @dp.callback_query_handler(lambda c: c.data == 'make_order')
    async def process_make_order(callback_query: types.CallbackQuery, state: FSMContext):
        await callback_query.answer()
        await callback_query.message.answer("Начнем с ваших учетных данных. Введите ваше ФИО:")
        await OrderForm.waiting_for_name.set()
        log_action(callback_query.from_user.id, 'make_order')

    @dp.callback_query_handler(lambda c: c.data == 'order_history')
    async def process_order_history(callback_query: types.CallbackQuery):
        await callback_query.answer()
        orders = get_order_history(callback_query.from_user.id)
        if orders:
            history_message = "\n\n".join([f"Заказ {order['id']}:\nФИО: {order['name']}\nАдрес: {order['address']}\nТип уборки: {order['cleaning_type']}" for order in orders])
            await callback_query.message.answer(f"История заказов:\n{history_message}")
        else:
            await callback_query.message.answer("История заказов пуста.")
        log_action(callback_query.from_user.id, 'order_history')

    @dp.callback_query_handler(lambda c: c.data == 'request_call')
    async def process_request_call(callback_query: types.CallbackQuery):
        await callback_query.answer()
        await callback_query.message.answer("Заказ звонка оформлен. Ожидайте звонок в течение 30 минут.")
        log_action(callback_query.from_user.id, 'request_call')

    @dp.callback_query_handler(lambda c: c.data == 'talk_operator')
    async def process_talk_operator(callback_query: types.CallbackQuery):
        await callback_query.answer()
        await callback_query.message.answer("Разговор с оператором начат.")
        log_action(callback_query.from_user.id, 'talk_operator')

    @dp.callback_query_handler(lambda c: c.data == 'back_to_main')
    async def process_back_to_main(callback_query: types.CallbackQuery):
        await callback_query.answer()
        await callback_query.message.answer("Главное меню:", reply_markup=main_menu_keyboard())
        log_action(callback_query.from_user.id, 'back_to_main')

    @dp.message_handler(state=OrderForm.waiting_for_name, content_types=types.ContentTypes.TEXT)
    async def process_name(message: types.Message, state: FSMContext):
        async with state.proxy() as data:
            data['name'] = message.text
        await message.answer("Введите ваш номер телефона:")
        await OrderForm.waiting_for_phone.set()

    @dp.message_handler(state=OrderForm.waiting_for_phone, content_types=types.ContentTypes.TEXT)
    async def process_phone(message: types.Message, state: FSMContext):
        async with state.proxy() as data:
            data['phone'] = message.text
        await message.answer("Введите адрес для уборки:")
        await OrderForm.waiting_for_address.set()

    @dp.message_handler(state=OrderForm.waiting_for_address, content_types=types.ContentTypes.TEXT)
    async def process_order_address(message: types.Message, state: FSMContext):
        async with state.proxy() as data:
            data['address'] = message.text
        await message.answer("Выберите время для уборки (утро/день/вечер):")
        await OrderForm.waiting_for_cleaning_time.set()

    @dp.message_handler(state=OrderForm.waiting_for_cleaning_time, content_types=types.ContentTypes.TEXT)
    async def process_cleaning_time(message: types.Message, state: FSMContext):
        async with state.proxy() as data:
            data['cleaning_time'] = message.text
        await message.answer("Выберите тип уборки (влажная/сухая/генеральная):")
        await OrderForm.waiting_for_cleaning_type.set()

    @dp.message_handler(state=OrderForm.waiting_for_cleaning_type, content_types=types.ContentTypes.TEXT)
    async def process_cleaning_type(message: types.Message, state: FSMContext):
        async with state.proxy() as data:
            data['cleaning_type'] = message.text
        await message.answer("Выберите способ оплаты (картой/наличными):")
        await OrderForm.waiting_for_payment_method.set()

    @dp.message_handler(state=OrderForm.waiting_for_payment_method, content_types=types.ContentTypes.TEXT)
    async def process_payment_method(message: types.Message, state: FSMContext):
        async with state.proxy() as data:
            data['payment_method'] = message.text

        await message.answer("Подтвердите заказ:\n"
                             f"ФИО: {data['name']}\n"
                             f"Номер телефона: {data['phone']}\n"
                             f"Адрес: {data['address']}\n"
                             f"Время уборки: {data['cleaning_time']}\n"
                             f"Тип уборки: {data['cleaning_type']}\n"
                             f"Способ оплаты: {data['payment_method']}\n"
                             "Если все верно, нажмите 'Подтвердить'. В противном случае, измените нужные данные.",
                             reply_markup=order_confirmation_keyboard())
        await OrderForm.confirmation.set()

    @dp.callback_query_handler(lambda c: c.data == 'confirm_order', state=OrderForm.confirmation)
    async def process_confirm_order(callback_query: types.CallbackQuery, state: FSMContext):
        await callback_query.answer()
        async with state.proxy() as data:
            order_details = (f"Новый заказ:\n"
                             f"ФИО: {data['name']}\n"
                             f"Номер телефона: {data['phone']}\n"
                             f"Адрес: {data['address']}\n"
                             f"Время уборки: {data['cleaning_time']}\n"
                             f"Тип уборки: {data['cleaning_type']}\n"
                             f"Способ оплаты: {data['payment_method']}")
            await bot.send_message(OPERATORS_GROUP_ID, order_details)
            add_order(data['name'], data['phone'], data['address'], data['cleaning_time'], data['cleaning_type'], data['payment_method'])

        await bot.send_message(callback_query.from_user.id, "Ваш заказ был подтвержден и отправлен операторам.")
        await state.finish()