import ssl, requests, logging, re, dpath, time, json
#import dpath.util as dp
from aiogram.contrib.fsm_storage.memory import MemoryStorage
from aiogram.contrib.middlewares.logging import LoggingMiddleware
from configuration import *
from aiohttp import web
from aiogram.dispatcher.webhook import get_new_configured_app
from aiogram.dispatcher import FSMContext
from aiogram.dispatcher.filters import Text
from aiogram.dispatcher.filters.state import State, StatesGroup
from aiogram import Bot, types
from aiogram.dispatcher import Dispatcher
from aiogram.types import ReplyKeyboardRemove, \
    ReplyKeyboardMarkup, KeyboardButton, \
    InlineKeyboardMarkup, InlineKeyboardButton

API_TOKEN = '1xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
WEBHOOK_HOST = 'xxxxxx.ru'
WEBHOOK_PORT = 443
WEBHOOK_URL_PATH = '/xxxxxxxxxxx'
WEBHOOK_URL = f"https://{WEBHOOK_HOST}:{WEBHOOK_PORT}{WEBHOOK_URL_PATH}"
WEBAPP_HOST = '0.0.0.0'
WEBAPP_PORT = xxxxxxx
WEBHOOK_SSL_CERT = '/root/howtostydu-end3.8/webhook_cert.pem'  # Path to the ssl certificate
WEBHOOK_SSL_PRIV = '/root/howtostydu-end3.8/webhook_pkey.pem'  # Path to the ssl private key

#logging.basicConfig(level=logging.INFO)

API_TOKEN = API_TOKEN

bot = Bot(token=API_TOKEN)

storage = MemoryStorage()
dp = Dispatcher(bot, storage=storage)

###################################### меню ################################################
def main_menu(message):
    user_id = message.chat.id
    r = requests.post(http_getusertoken, json={"password": "1488", "telegram_id": int(user_id)})
    print(r.json())
    print(r.status_code)
    if r.json()['msg'] == "ok":
        inline_kb = InlineKeyboardMarkup(row_width=2)
        btn_registration = InlineKeyboardButton('Пройти тест', callback_data='test')
        btn_auth = InlineKeyboardButton('Личная информация', callback_data='personal_information')
        btn_url_site = InlineKeyboardButton('Перейти на сайт', url="https://xxxxxx.ru/home")
        btn_exit = InlineKeyboardButton('Выйти', callback_data='exit')
        inline_kb.add(btn_registration)
        inline_kb.add(btn_auth)
        inline_kb.add(btn_url_site)
        inline_kb.add(btn_exit)
        return inline_kb

    else:
        inline_kb1 = InlineKeyboardMarkup(row_width=2)
        btn_registration = InlineKeyboardButton('Регистрация', callback_data='registration')
        btn_auth = InlineKeyboardButton('Авторизация', callback_data='auth')
        btn_url_site = InlineKeyboardButton('Перейти на сайт', url="https://xxxxx.ru/home")
        inline_kb1.add(btn_registration)
        inline_kb1.add(btn_auth)
        inline_kb1.add(btn_url_site)
        return inline_kb1


def personal_information_menu():
    inline_kb = InlineKeyboardMarkup(row_width=2)
    btn_edit_name = InlineKeyboardButton(text="Изменить имя", callback_data="edit_name")
    btn_edit_secondName = InlineKeyboardButton(text="Изменить фамилию", callback_data="edit_secondName")
    btn_edit_phone = InlineKeyboardButton(text="Изменить номер телефона", callback_data="edit_phone")
    btn_edit_email = InlineKeyboardButton(text="Изменить email", callback_data="edit_email")
    btn_edit_group = InlineKeyboardButton(text="Изменить группу", callback_data="edit_group")
    btn_main_menu = InlineKeyboardButton(text="Назад", callback_data="send_welcome")
    inline_kb.add(btn_edit_name, btn_edit_secondName)
    inline_kb.add(btn_edit_phone, btn_edit_email)
    inline_kb.add(btn_edit_group)
    inline_kb.add(btn_main_menu)
    return inline_kb


#################################################### начало ##########################################
async def send_welcome(message: types.Message):
    user_id = message.from_user.id
    r = requests.post(http_getusertoken, json={"password": "1488", "telegram_id": int(user_id)})
    if r.json()['msg'] == "ok":
        await bot.send_message(message.chat.id, "Добро пожаловать на платформу онлайн тестирования",
                   reply_markup=main_menu(message))
    else:
        img = open("/root/howtostydu-end3.8/logo.jpg", "rb")
        await bot.send_photo(message.chat.id, img,
                       caption="Добро пожаловать на платформу онлайн тестирования",
                       reply_markup=main_menu(message))


@dp.message_handler(state='*', commands=["start", "cancel"])
@dp.message_handler(Text(equals=['начать', 'отмена'], ignore_case=True), state='*')
async def cancel_handler(message: types.Message, state: FSMContext):
    await state.finish()
    await send_welcome(message)

##################################################### выход ###########################################
@dp.callback_query_handler(lambda c: c.data == 'exit')
async def exit_user(callback_query: types.CallbackQuery):
    await bot.answer_callback_query(callback_query.id)
    user_id = callback_query.from_user.id
    r = requests.post(http_getusertoken, json={"password": "1488", "telegram_id": int(user_id)})
    TOKEN_USER = r.json()["access_token"]
    headers = {"Authorization": "Bearer " + TOKEN_USER}
    requests.post('https://howtostudy.ru/api/telegram4ik/removeusertelegram',
                  json={"password": "1488", "telegram_id": user_id}, headers=headers)
    await send_welcome(callback_query.message)

##################################### персональная информация #########################################
class Form_edit(StatesGroup):
    edit_name = State()
    edit_secondName = State()
    edit_phone = State()
    edit_email = State()
    edit_email_passward = State()
    edit_group = State()


@dp.callback_query_handler(lambda c: c.data == 'personal_information')
async def personal_information(callback_query: types.CallbackQuery):
    await callback_query.answer()
    r = requests.post(http_getusertoken, json={"password": "1488", "telegram_id": callback_query.from_user.id})
    TOKEN_USER = r.json()["access_token"]
    headers = {"Authorization": "Bearer " + TOKEN_USER}
    r = requests.get(http_getown, headers=headers)
    # {'personals': {'email': '148@.com', 'firstName': 'fsdf', 'group': 'ИС-18', 'phone': 84354543543, 'secondName': 'f'}}
    #img = open("/root/howtostydu-end3.8/logo.jpg", "rb")  # D:\Inf\python\\telegramBot\HowToDo\main\\logo.jpg
    output = "Настройка персональной информация\n"

    if 'email' in r.json()['personals']:
        output = output + f"\nВаш email: {r.json()['personals']['email']}"

    if 'firstName' in r.json()['personals']:
        output = output + f"\nИмя: {r.json()['personals']['firstName']}"

    if 'secondName' in r.json()['personals']:
        output = output + f"\nФамилия: {r.json()['personals']['secondName']}"

    if 'phone' in r.json()['personals']:
        output = output + f"\nТелефон: {r.json()['personals']['phone']}"

    if 'group' in r.json()['personals']:
        output = output + f"\nГруппа: {r.json()['personals']['group']}"

    await callback_query.message.edit_text(output, reply_markup=personal_information_menu())

async def send_personal_information(message,http, json):
    r = requests.post(http_getusertoken, json={"password": "1488", "telegram_id": message.chat.id})
    TOKEN_USER = r.json()["access_token"]
    headers = {"Authorization": "Bearer " + TOKEN_USER}
    requests.post(http, json=json,headers=headers)
    return await bot.send_message(message.chat.id, "Данные сохранены")


@dp.callback_query_handler(lambda c: c.data == 'edit_name') #Изменить имя
async def edit_name(callback_query: types.CallbackQuery):
    await callback_query.answer()
    await Form_edit.edit_name.set()
    await callback_query.message.answer("Укажите имя: ")

@dp.message_handler(state=Form_edit.edit_name)
async def edit_name_save(message: types.Message, state: FSMContext):
    async with state.proxy() as data:
        data['name'] = message.text
    r = {"firstName": message.text}
    await send_personal_information(message, http_setown, r)
    await state.finish()
    await send_welcome(message)

@dp.callback_query_handler(lambda c: c.data == 'edit_secondName') #Изменить фамилию
async def edit_secondName(callback_query: types.CallbackQuery):
    await callback_query.answer()
    await Form_edit.edit_secondName.set()
    await callback_query.message.answer("Укажите фамилию: ")

@dp.message_handler(state=Form_edit.edit_secondName)
async def edit_secondName_save(message: types.Message, state: FSMContext):
    async with state.proxy() as data:
        data['secondName'] = message.text
    r = {"secondName": message.text}
    await send_personal_information(message, http_setown, r)
    print(send_personal_information(message, http_setown, r))
    await state.finish()
    await send_welcome(message)

@dp.callback_query_handler(lambda c: c.data == 'edit_phone') #Изменить телефон
async def edit_phone(callback_query: types.CallbackQuery):
    await callback_query.answer()
    await Form_edit.edit_phone.set()
    await callback_query.message.answer("Укажите номер телефона: ")

@dp.message_handler(state=Form_edit.edit_phone)
async def edit_phone_save(message: types.Message, state: FSMContext):
    message.text = message.text.replace("+7", "8")
    if len(str(message.text)) == 11 and str(message.text).isdigit():
        async with state.proxy() as data:
            data['phone'] = message.text
        r = {"phone": message.text}
        await send_personal_information(message, http_setown, r)
        await state.finish()
        await send_welcome(message)
    else:
        await message.answer("Некоректный номер телефона\nУкажите номер телефона: ")

@dp.callback_query_handler(lambda c: c.data == 'edit_email') #Изменить email
async def edit_email(callback_query: types.CallbackQuery):
    await callback_query.answer()
    await Form_edit.edit_email.set()
    await callback_query.message.answer("Укажите новый email: ")

@dp.message_handler(
    lambda message: ('@' not in message.text) or (('.com' not in message.text) and ('.ru' not in message.text)),
    state=Form_edit.edit_email)
async def check_email(message: types.Message):
    return await message.reply("Некоректно введен email.\nУкажите email: ")

@dp.message_handler(state=Form_edit.edit_email)
async def edit_email_save(message: types.Message, state: FSMContext):
    async with state.proxy() as data:
        data['email'] = message.text
        await Form_edit.next()
        await message.answer("Введите пароль: ")

@dp.message_handler(state=Form_edit.edit_email_passward)
async def edit_email_passward(message: types.Message, state: FSMContext):
    async with state.proxy() as data:
        data['password'] = message.text
        print(data["email"],data['password'])
        r = requests.post(http_getusertoken, json={"password": "1488", "telegram_id": message.chat.id})
        TOKEN_USER = r.json()["access_token"]
        headers = {"Authorization": "Bearer " + TOKEN_USER}
        r = requests.post(http_email, json={"newEmail": data["email"], "password": data['password']}, headers=headers)
        #r = {"newEmail": data["email"], "password": data['password']}
        await send_personal_information(message, http_email, r)
        if r.json()['msg'] == "ok":
            await message.answer("Вы успешно изменили email")
            await state.finish()
            await send_welcome(message)
        else:
            await message.answer("Неверно указан пароль\nВведите пароль: ")

@dp.callback_query_handler(lambda c: c.data == 'edit_group') #Изменить группу
async def edit_group(callback_query: types.CallbackQuery):
    await callback_query.answer()
    await Form_edit.edit_group.set()
    markup = types.ReplyKeyboardMarkup(resize_keyboard=True, selective=True, one_time_keyboard=True)
    markup.add("ИС-16", "ИС-17", "ИС-18")
    markup.add("ИС-19", "ИЭ-17", "ИЭ-19")
    await callback_query.message.answer("Укажите вашу группу: ", reply_markup=markup)

@dp.message_handler(lambda message: message.text not in ["ИС-16", "ИС-17", "ИС-18", "ИС-19", "ИЭ-17", "ИЭ-19"],
                    state=Form_edit.edit_group)
async def process_gender_invalid(message: types.Message):
    return await message.reply("Неверно указана группа\nПожалуйства выберите группу из списка")

@dp.message_handler(state=Form_edit.edit_group)
async def edit_secondName_save(message: types.Message, state: FSMContext):
    async with state.proxy() as data:
        data['group'] = message.text
    r = {"group": message.text}
    await send_personal_information(message, http_setown, r)
    await state.finish()
    await send_welcome(message)


@dp.callback_query_handler(lambda c: c.data == 'send_welcome') #назад
async def back(callback_query):
    await callback_query.message.edit_text("Добро пожаловать на платформу онлайн тестирования", reply_markup=main_menu(callback_query.message))

##################################### авторизация #####################################################
class Form_auth(StatesGroup):
    name_aut = State()
    password_aut = State()

@dp.callback_query_handler(lambda c: c.data == 'auth')
async def send_name(callback_query: types.CallbackQuery):
    await bot.answer_callback_query(callback_query.id)
    await Form_auth.name_aut.set()
    await bot.send_message(callback_query.from_user.id, 'Укажите логин: ')


@dp.message_handler(state=Form_auth.name_aut)
async def send_password(message: types.Message, state: FSMContext):
    async with state.proxy() as data:
        data['name'] = message.text
    await Form_auth.next()
    await message.answer("Укажите пароль: ")


@dp.message_handler(state=Form_auth.password_aut)
async def process_gender(message: types.Message, state: FSMContext):
    try:
        async with state.proxy() as data:
            data['password'] = message.text
            print("Авторизация: ",data['name'], data['password'])
            user_id = message.chat.id
            r = requests.post(http_auth, json={
                "login": data["name"],
                "password": data['password']})
            headers = {"Authorization": "Bearer " + r.json()['access_token']}
            requests.post(http_addidtelegram,
                          json={"password": "1488", "telegram_id": user_id}, headers=headers)
            await bot.send_message(message.chat.id, "Вы успешно авторизовались.")
            await send_welcome(message)
        await state.finish()
    except Exception as e:
        await message.answer("Такого пользователя нет\nУкажите логин: ")
        await Form_auth.first()

##################################### регистрация ############################################
class Form_registration(StatesGroup):
    name = State()
    password = State()
    email = State()
    category = State()


@dp.callback_query_handler(lambda c: c.data == 'registration')
async def send_name(callback_query: types.CallbackQuery):
    await bot.answer_callback_query(callback_query.id)
    await Form_registration.name.set()
    await bot.send_message(callback_query.from_user.id, 'Укажите логин: ')

@dp.message_handler(state=Form_registration.name)
async def lan(message, state: FSMContext):
    async with state.proxy() as data:
        data['name'] = message.text
        user_id = message.from_user.id
        r = requests.post(http_reg, json={"login": data['name'], "password": "", "email": "", "category": ""})
        print(r.json()['msg'])
        if r.json()['msg'] != "NOT_ORIGINAL_LOGIN":
            await message.answer("Введите пароль: ")
            await Form_registration.next()
        else:
            await message.answer("Логин занят\nУкажите логин: ")
            await Form_registration.first()

@dp.message_handler(state=Form_registration.name)
async def send_password(message: types.Message, state: FSMContext):
    async with state.proxy() as data:
        data['name'] = message.text
    await Form_registration.next()
    await message.answer("Укажите пароль: ")

@dp.message_handler(lambda message: message.text, state=Form_registration.password)
async def send_emai(message: types.Message, state: FSMContext):
    await Form_registration.next()
    await state.update_data(password=message.text)
    await message.answer("Укажите email: ")


@dp.message_handler(
    lambda message: ('@' not in message.text) or (('.com' not in message.text) and ('.ru' not in message.text)),
    state=Form_registration.email)
async def check_email(message: types.Message):
    return await message.reply("Некоректно введен email.\nУкажите email: ")


@dp.message_handler(lambda message: message.text, state=Form_registration.email)
async def send_group(message: types.Message, state: FSMContext):
    await Form_registration.next()
    await state.update_data(email=message.text)

    markup = types.ReplyKeyboardMarkup(resize_keyboard=True, selective=True, one_time_keyboard=True)
    markup.add("ИС-16", "ИС-17", "ИС-18")
    markup.add("ИС-19", "ИЭ-17", "ИЭ-17")
    await message.answer("Укажите вашу группу: ", reply_markup=markup)


@dp.message_handler(lambda message: message.text not in ["ИС-16", "ИС-17", "ИС-18", "ИС-19", "ИЭ-17", "ИЭ-17"],
                    state=Form_registration.category)
async def process_gender_invalid(message: types.Message):
    return await message.reply("Неверно указана группа, пожалуйства выберите группу")


@dp.message_handler(state=Form_registration.category)
async def process_gender(message: types.Message, state: FSMContext):
    async with state.proxy() as data:
        data['category'] = message.text
        print("Данные регистрации: ",data['name'], data['password'], data['email'], data['category'])
        try:
            user_id = message.chat.id
            r = requests.post(http_reg, json={"login": data['name'], "password":data['password'],"email":data['email'],"category": data['category']})
            await bot.send_message(message.chat.id, "Вы успешно зарегистрированы.")
            headers = {"Authorization": "Bearer " + r.json()['access_token']}
            requests.post(http_addidtelegram,
                          json={"password": "1488", "telegram_id": user_id}, headers=headers)
            await send_welcome(message)
        except Exception as e:
            await message.answer("Ooops")
    await state.finish()








###################################### тесты ################################################
class Form_test(StatesGroup):
    res_id = State()
    index = State()
    questions_list = State()
    user_answers = State()


@dp.callback_query_handler(lambda c: c.data == 'test')
async def edit_secondName(callback_query: types.CallbackQuery):
    await callback_query.answer()



###################################### вебхуки ################################################
async def on_startup(app):
    webhook = await bot.get_webhook_info()
    if webhook.url != WEBHOOK_URL:
        if not webhook.url:
            await bot.delete_webhook()
        await bot.set_webhook(WEBHOOK_URL, certificate=open(WEBHOOK_SSL_CERT, 'rb'))

async def on_shutdown(app):
    await bot.delete_webhook()
    await dp.storage.close()
    await dp.storage.wait_closed()

if __name__ == '__main__':
    app = get_new_configured_app(dispatcher=dp, path=WEBHOOK_URL_PATH)
    app.on_startup.append(on_startup)
    app.on_shutdown.append(on_shutdown)
    context = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2)
    context.load_cert_chain(WEBHOOK_SSL_CERT, WEBHOOK_SSL_PRIV)
    web.run_app(app, host=WEBAPP_HOST, port=WEBAPP_PORT, ssl_context=context)