import logging
import random
import aiohttp
from aiogram import Bot, Dispatcher, executor, types
from aiogram.contrib.fsm_storage.memory import MemoryStorage
from aiogram.contrib.middlewares.logging import LoggingMiddleware
from aiogram.dispatcher import FSMContext
from aiogram.dispatcher.filters.state import State, StatesGroup
from aiogram.utils.callback_data import CallbackData
from aiogram.utils.exceptions import MessageNotModified
import string
import json

with open('settings.json') as settings:
    json_body = json.load(settings)
TELEGRAM_TOKEN = json_body['tg_token']

QIWI_TOKEN = f"Bearer {json_body['qiwi_token']}"
SUMMA = json_body['sum']
headers = {
    'Accept': 'application/json',
    'Authorization': QIWI_TOKEN
}
qiwi_content = {
        'rows': 10,
        'operation': 'IN'
    }


logging.basicConfig(level=logging.INFO)
if json_body['proxy_url'] is None:
    bot = Bot(token=TELEGRAM_TOKEN, parse_mode=types.ParseMode.HTML)
else:
    if json_body['proxy_auth']['user'] is None and json_body['proxy_auth']['password'] is None:
        PROXY_URL = json_body['proxy_url']
        bot = Bot(token=TELEGRAM_TOKEN, parse_mode=types.ParseMode.HTML, proxy=PROXY_URL)
    else:
        PROXY_AUTH = aiohttp.BasicAuth(login=json_body['proxy_auth']['user'], password=json_body['proxy_auth']['password'])
        PROXY_URL = json_body['proxy_url']
        bot = Bot(token=TELEGRAM_TOKEN, parse_mode=types.ParseMode.HTML, proxy=PROXY_URL, proxy_auth=PROXY_AUTH)
storage = MemoryStorage()
dp = Dispatcher(bot, storage=storage)
dp.middleware.setup(LoggingMiddleware())


keyboard = CallbackData('key', 'id', 'action')


class Form(StatesGroup):
    comment = State()
    sum = State()
    count = State()
    status = State()


def confirm_keyboard(sum, comment):
        markup = types.InlineKeyboardMarkup()
        markup.add(types.InlineKeyboardButton(text='Оплатить',
                                       url=f'https://qiwi.com/payment/form/99?extra%5B%27account%27%5D=79991234567&amountInteger={sum}&amountFraction=0&extra%5B%27comment%27%5D={comment}&currency=643&blocked[0]=sum&blocked[1]=account&blocked[2]=comment')
                   )
        markup.row(
            types.InlineKeyboardButton(text='Отменить оплату', callback_data=keyboard.new(id='payment', action='cancel')),
            types.InlineKeyboardButton(text='Я оплатил', callback_data=keyboard.new(id='payment', action='confirm')),

        )
        return markup


def reply_keyboard():
    markup = types.ReplyKeyboardMarkup(row_width=2, resize_keyboard=True)
    markup.row(
        types.KeyboardButton('Оформить заказ'),
        types.KeyboardButton("Как пользоваться?"))
    markup.add(
        types.KeyboardButton('Поддержка')
    )
    return markup


def repeat_confirm_keyboard():
    return types.InlineKeyboardMarkup().row(
        types.InlineKeyboardButton(text='Повторить попытку', callback_data=keyboard.new(id='payment', action='repeat')),
        types.InlineKeyboardButton(text='Написать в тех. поддержку', url='t.me/themida'),

    )


def incorrect_amount_keyboard():
    return types.InlineKeyboardMarkup().row(
        types.InlineKeyboardButton(text='Написать в тех. поддержку', url='t.me/themida'),
    )


def contact_keyboard():
    return types.InlineKeyboardMarkup().row(
        types.InlineKeyboardButton(text='Support', url='t.me/themida'),
        types.InlineKeyboardButton(text='Чат', url='ya.ru')
    )


def count_keyboard():
    n = 5
    markup = types.InlineKeyboardMarkup(row_width=5)
    for i in range(1, 11):
        markup.insert(
            types.InlineKeyboardButton(f'{n}', callback_data=keyboard.new(id='count', action=n))
        )
        n += 5
    return markup


def read(count):
    strings = []
    with open("good_promo.txt") as f:
        for s in range(count):
            q = f.readline()
            strings.append(q)
        with open("good_promo.txt", "r+") as g:
            g.writelines(f)
            g.truncate()
    return '\n'.join(strings)


async def qiwi_connect(state: FSMContext):
    async with state.proxy() as data:
        comment = data['comment']
        sum = data['sum']
        async with aiohttp.ClientSession() as session:
            async with session.get('https://edge.qiwi.com/payment-history/v2/persons/79991234567/payments', headers=headers, params=qiwi_content) as get:
                json_body = await get.json()
                for i in json_body['data']:
                    if i['comment'] is not None and i['comment'] == comment and i['status'] == 'SUCCESS':
                        if i['sum']['amount'] == sum:
                            data['status'] = 2  # Accept
                            break
                        else:
                            data['status'] = 1  # Incorrect amount
                            break
                    else:
                        data['status'] = 0  # not found transaction


async def result_check(query, state: FSMContext):
    await qiwi_connect(state)
    async with state.proxy() as data:
        status = data['status']
        count = data['count']
        if status == 2:
            await bot.edit_message_text(f'Оплата прошла успешно\n'
                                        f'{read(count)}', query.from_user.id, query.message.message_id)
        elif status == 1:
            try:
                await bot.edit_message_text(f'Некорректная сумма', query.from_user.id, query.message.message_id, reply_markup=incorrect_amount_keyboard())
            except MessageNotModified:
                pass
        else:
            try:
                await bot.edit_message_text(f'Транзакция не обнаружена', query.from_user.id, query.message.message_id, reply_markup=repeat_confirm_keyboard())
            except MessageNotModified:
                pass


@dp.message_handler(commands='start')
async def send_welcome(message: types.Message):
    await bot.send_message(message.from_user.id, 'text', reply_markup=reply_keyboard())


@dp.message_handler()
async def get_count(message: types.Message):
    text_of_button = message.text
    logging.debug(text_of_button)
    if text_of_button == 'Оформить заказ':
        await bot.send_message(message.from_user.id, 'Укажите необходимое количество купонов', reply_markup=count_keyboard())
    elif text_of_button == 'Как пользоваться?':
        await bot.send_message(message.from_user.id, 'HELP')
    elif text_of_button == 'Поддержка':
        await bot.send_message(message.from_user.id, text='Контакты', reply_markup=contact_keyboard())
    else:
        pass


@dp.callback_query_handler(keyboard.filter(id='count'))
async def get_payment_with_count(query: types.CallbackQuery, callback_data: dict, state: FSMContext):
    logging.info(callback_data)
    count = int(callback_data['action'])
    sum = count * SUMMA
    comment = ''.join(random.sample(string.ascii_letters + string.digits, 12))
    async with state.proxy() as data:
        data['sum'] = sum
        data['comment'] = comment
        data['count'] = count
    await bot.edit_message_text('После оплаты нажмите кнопку "Я оплатил"', query.from_user.id, query.message.message_id, reply_markup=confirm_keyboard(sum, comment))


@dp.callback_query_handler(keyboard.filter(action='cancel'))
async def cancel_payment(query: types.CallbackQuery, callback_data: dict):
    logging.info(callback_data)
    await bot.edit_message_text('Вы отменили оплату', query.from_user.id, query.message.message_id)


@dp.callback_query_handler(keyboard.filter(action=['confirm', 'repeat']))
async def check_payment(query: types.CallbackQuery, callback_data: dict, state: FSMContext):
    logging.info(callback_data)
    await result_check(query, state)


if __name__ == '__main__':
    executor.start_polling(dp, skip_updates=True)