import datetime

from aiogram import types
from aiogram.dispatcher.storage import FSMContext
from aiogram.types import ReplyKeyboardRemove
from sqlalchemy import delete
from sqlalchemy.dialects.postgresql import insert
from sqlalchemy.future import select

from button import actions_encryption
from config import MAX_VALUE_IN_KEY
from db import async_session, Key_table, Key_value
from func import create_key
from func import filtr_view_key_with_
from language import language
from loader import dp, bot
from middleware import anti_flood
from states import CreateKey

# the main mechanism
'''@anti_flood(1)
@dp.message_handler(content_types='any')
async def hi_tag(message):
    # Переводим любой медиафайл в вид json
    copy = message.to_python()
    await message.answer(f'cope = message.to_python()' + f'\n{copy}')
    # Переводим json в объект message
    copy = types.Message.to_object(copy)
    # С помощью метода copy_to, переводим объект в медифайл
    await copy.copy_to(chat_id=message.chat.id)'''

number_list = {1: '1️⃣', 2: '2️⃣', 3: '3️⃣', 4: '4️⃣', 5: '5️⃣',
               6: '6️⃣', 7: '7️⃣', 8: '8️⃣', 9: '9️⃣', 10: '🔟'}


# command cancel process,del key
@anti_flood(3)
@dp.message_handler(state=CreateKey.media_upload, text=['🚫Cancel', '🚫Отмена'])
async def cancel(message: types.Message, state: FSMContext, lang):
    await state.reset_state(with_data=False)

    data = await state.get_data()

    if 'message_tag_count' in data:
        await bot.delete_message(
            chat_id=message.from_user.id,
            message_id=data['message_tag_count']
        )

    if 'message_tag_finish' not in data:
        message_tag_finish = await message.answer(language['message_tag_cancel'][lang])
        message_tag_finish = message_tag_finish.message_id
    else:
        message_tag_finish = data['message_tag_finish']

    if 'message_null' not in data:
        message_null = await message.answer('⚙️',
                                            reply_markup=ReplyKeyboardRemove())
        message_null = message_null.message_id

        await bot.delete_message(
            chat_id=message.from_user.id,
            message_id=message_null
        )

    async with async_session() as session:
        try:
            await session.execute(delete(Key_table).where(
                Key_table.key == data['key']
                and Key_table.user_id == message.from_user.id
            ))
            await session.commit()
        except Exception as e:
            await session.rollback()
            await bot.edit_message_text(
                chat_id=message.from_user.id,
                message_id=message_tag_finish,
                text='Error in cancel db\n'
                     f'{e}')

    await state.reset_data()


# command create key,create values
# noinspection PyArgumentList
@anti_flood(3)
@dp.message_handler(state=CreateKey.media_upload, text=['🔑Create key', '🔑Создать ключ'])
async def completed(message: types.Message, state: FSMContext, lang):
    await state.reset_state(with_data=False)

    user_id = message.from_user.id
    data = await state.get_data()

    await bot.delete_message(
        chat_id=message.from_user.id,
        message_id=data['message_tag_count']
    )

    async with state.proxy() as data:
        del data['message_tag_count']

    if 'value1' not in data:
        message_tag_finish = await message.answer(language['message_tag_data'][lang])
        message_tag_finish = message_tag_finish.message_id

        async with state.proxy() as data:
            data['message_tag_finish'] = message_tag_finish

        await cancel(message, state, lang)
        return

    message_tag_finish = await message.answer(language['message_tag_key'][lang])
    message_tag_finish = message_tag_finish.message_id

    async with state.proxy() as data:
        data['message_tag_finish'] = message_tag_finish

    message_null = await message.answer('⚙️',
                                        reply_markup=ReplyKeyboardRemove())
    message_null = message_null.message_id

    await bot.delete_message(
        chat_id=user_id,
        message_id=message_null
    )

    async with state.proxy() as data:
        data['message_null'] = True

    async with async_session() as session:
        try:
            for count_value in range(1, data['count'] + 1):
                value = data[f"value{count_value}"]
                await session.execute(insert(Key_value).values(
                    key=data['key'],
                    value=value,
                    by_order=count_value
                ))
            await session.commit()
        except Exception as e:
            await session.rollback()
            await bot.edit_message_text(
                chat_id=message.from_user.id,
                message_id=message_tag_finish,
                text='Error in value\n'
                     f'{e}')
            await cancel(message, state, lang)
            return

    await bot.edit_message_text(
        message_id=message_tag_finish,
        chat_id=user_id,
        text=f"🔑{await filtr_view_key_with_(data['key'])}"
    )

    await state.reset_data()


# noinspection PyTypeChecker,PyBroadException
# state start,create key
@anti_flood(6, key='key')
@dp.message_handler(commands=['key'])
async def encryption(message: types.Message, state: FSMContext, lang):
    await message.answer(language['encryption'][lang],
                         reply_markup=actions_encryption[lang])

    message_tag_count = await message.answer(f"{language['count_media'][lang]}\n0️⃣◀️🔟")
    message_tag_count = message_tag_count.message_id

    async with state.proxy() as data:
        data['message_tag_count'] = message_tag_count
        data['count'] = 0

    count = message.text.split()[-1]

    try:
        count = int(count)
    except ValueError:
        count = 1

    if count > 100:
        count = 100
    elif count < 1:
        count = 1

    async with async_session() as session:
        try:
            while True:

                # Генерируем ключ
                key = await create_key()

                # Ищем ключ в базе
                result = await session.execute(select(Key_table.key).
                                               where(Key_table.key == key))

                # .scalar() возвращает None или первую запись с таким ключом
                result = result.scalar()

                # Если ключ найден в базе,запускаем цикл с начала
                if result is not None:
                    continue

                # Если ключ не найден,покидаем цикл
                else:
                    break

            await session.execute(insert(Key_table).values(
                user_id=message.from_user.id,
                key=key,
                count=count,
                status=True,
                date=datetime.datetime.utcnow()
            ))
            await session.commit()
        except Exception as e:
            await session.rollback()
            await message.answer('Error in key create\n'
                                 f'{e}')

            await bot.delete_message(
                message_id=message_tag_count
            )
            await state.finish()
            return

    async with state.proxy() as data:
        data['key'] = key

    await CreateKey.media_upload.set()


@anti_flood(0)
@dp.message_handler(state=CreateKey.media_upload,
                    content_types=types.ContentTypes.ANY)
async def media_upload(message: types.Message, state: FSMContext, lang):
    data = await state.get_data()
    message_tag_count = data['message_tag_count']
    count = message.message_id - message_tag_count

    if message.message_id - message_tag_count > 10:
        return

    async with state.proxy() as data:
        data[f"value{count}"] = str(message.to_python())
        data['count'] = count

    print(f'{message.from_user.username} - {count}')
    '''if count < MAX_VALUE_IN_KEY:
        try:
            await bot.edit_message_text(
                chat_id=message.from_user.id,
                message_id=message_tag_count,
                text=f"{language['count_media'][lang]}\n"
                     f'{number_list[count]}◀️🔟'
            )
        except Exception as e:
            await message.answer('Error in media upload\n'
                                 f'{e}')'''

    if count == MAX_VALUE_IN_KEY:
        await state.reset_state(with_data=False)
        await completed(message, state, lang)