import logging
import sqlite3
import asyncio
from aiogram import Bot, Dispatcher, types
from aiogram.contrib.middlewares.logging import LoggingMiddleware
from aiogram.dispatcher.filters import Command
from aiogram.dispatcher import FSMContext
from aiogram.dispatcher.filters.state import State, StatesGroup
from aiogram.types import ReplyKeyboardMarkup, KeyboardButton, InlineKeyboardMarkup, InlineKeyboardButton

# Устанавливаем уровень логов
logging.basicConfig(level=logging.INFO)

# Подключаемся к базе данных SQLite
conn = sqlite3.connect("answers.db")
cursor = conn.cursor()

# Создание таблицы для хранения ответов
cursor.execute("""
CREATE TABLE IF NOT EXISTS answers (
    user_id INTEGER,
    question_id INTEGER,
    answer TEXT
)
""")
conn.commit()

# Заменить на свой токен
API_TOKEN = '7472030348:AAGI53nX-ON-WBmEhd_qBC6EnZsHOqp_2kE'
GROUP_ID = '-1001961537659'

# Инициализация бота и диспетчера
bot = Bot(token=API_TOKEN)
dp = Dispatcher(bot)
dp.middleware.setup(LoggingMiddleware())

# Словарь для хранения вопросов и ответов
questions = {
    1: "Как вас зовут?",
    2: "Укажите номер телефона для связи",
    3: "Укажите район, улицу, дом",
    4: "Какая уборка нужна, влажная или сухая?",
    5: "На какое время?",
    6: "Оплата наличными или картой?"
}

answer_map = {
    'wet_cleaning': 'Влажная уборка',
    'dry_cleaning': 'Сухая уборка',
    'morning_time': 'Утро',
    'day_time': 'День',
    'evening_time': 'Вечер',
    'cash_payment': 'Наличные',
    'card_payment': 'Карта'
}

# Обработчик команды /start
@dp.message_handler(commands=['start'])
async def start(message: types.Message):
    if message.chat.id != int(GROUP_ID):
        await message.answer("Привет! Я задам тебе 6 вопросов Чтобы создать заказ. Давай начнем.")
        await ask_question(message.chat.id, 1)

@dp.message_handler(Command("start"))
async def show_menu(message: types.Message):
    await message.reply("Выбери действие:", reply_markup=ReplyKeyboardMarkup(
        resize_keyboard=True).add(KeyboardButton("Создать заказ")))

# Функция для задания вопроса
async def ask_question(user_id, question_id):
    if question_id in [4, 5, 6]:
        if question_id == 4:
            keyboard = InlineKeyboardMarkup(inline_keyboard=[
                [InlineKeyboardButton(text="Влажная", callback_data="wet_cleaning")],
                [InlineKeyboardButton(text="Сухая", callback_data="dry_cleaning")]
            ])
        elif question_id == 5:
            keyboard = InlineKeyboardMarkup(inline_keyboard=[
                [InlineKeyboardButton(text="Утро", callback_data="morning_time")],
                [InlineKeyboardButton(text="День", callback_data="day_time")],
                [InlineKeyboardButton(text="Вечер", callback_data="evening_time")]
            ])
        elif question_id == 6:
            keyboard = InlineKeyboardMarkup(inline_keyboard=[
                [InlineKeyboardButton(text="Наличные", callback_data="cash_payment")],
                [InlineKeyboardButton(text="Карта", callback_data="card_payment")]
            ])
        await bot.send_message(user_id, text=questions[question_id], reply_markup=keyboard)
    else:
        await bot.send_message(user_id, text=questions[question_id])

# Обработчик текстовых ответов на первые три вопроса
@dp.message_handler(lambda message: message.text not in ["Переписать", "Отправить"])
async def handle_text_answer(message: types.Message):
    if message.chat.id != int(GROUP_ID):
        user_id = message.chat.id
        cursor.execute("SELECT MAX(question_id) FROM answers WHERE user_id=?", (user_id,))
        prev_question_id = cursor.fetchone()[0]

        if prev_question_id is None:
            question_id = 1
        else:
            question_id = prev_question_id + 1
        answer = message.text

        await save_answer(user_id, question_id, answer)

        if question_id < 6:
            await ask_question(user_id, question_id + 1)
        else:
            await show_confirmation_options(user_id)

# Обработчик inline-кнопок
@dp.callback_query_handler(lambda query: query.data in answer_map.keys())
async def handle_callback_answer(query: types.CallbackQuery):
    user_id = query.from_user.id
    cursor.execute("SELECT MAX(question_id) FROM answers WHERE user_id=?", (user_id,))
    prev_question_id = cursor.fetchone()[0]

    if prev_question_id is None:
        question_id = 1
    else:
        question_id = prev_question_id + 1

    await save_answer(user_id, question_id, answer_map[query.data])
    await query.answer()

    if question_id < 6:
        await ask_question(user_id, question_id + 1)
    else:
        await show_confirmation_options(user_id)

# Функция для сохранения ответа в базе данных
async def save_answer(user_id, question_id, answer):
    cursor.execute("INSERT INTO answers (user_id, question_id, answer) VALUES (?, ?, ?)", (user_id, question_id, answer))
    conn.commit()

# Функция для отображения опций подтверждения
async def show_confirmation_options(user_id):
    cursor.execute("SELECT answer FROM answers WHERE user_id=? ORDER BY question_id", (user_id,))
    answers = cursor.fetchall()
    answer_text = "\n".join([f"{questions[i+1]}: {answers[i][0]}" for i in range(6)])
    await bot.send_message(user_id, text=f"Ваши ответы:\n\n{answer_text}")

    keyboard = InlineKeyboardMarkup(inline_keyboard=[
        [InlineKeyboardButton(text="Отправить", callback_data="send_answers")],
        [InlineKeyboardButton(text="Переписать", callback_data="rewrite_answers")]
    ])
    await bot.send_message(user_id, "Проверьте свои ответы. Выберите действие:", reply_markup=keyboard)

# Обработчик выбора действия подтверждения
@dp.callback_query_handler(lambda query: query.data in ['send_answers', 'rewrite_answers'])
async def handle_confirmation(query: types.CallbackQuery):
    user_id = query.from_user.id
    if query.data == "send_answers":
        await send_answers_to_group(user_id)
    elif query.data == "rewrite_answers":
        await rewrite_answers(user_id)

# Функция для отправки ответов в группу
async def send_answers_to_group(user_id):
    cursor.execute("SELECT * FROM answers WHERE user_id=?", (user_id,))
    answers = cursor.fetchall()

    if answers:
        answer_text = '\n'.join([f"{questions[ans[1]]}: {ans[2]}" for ans in answers])

        # Очищаем таблицу с ответами
        cursor.execute("DELETE FROM answers WHERE user_id=?", (user_id,))
        conn.commit()

        # Отправляем ответы в группу и добавляем ID пользователя
        sent_message = await bot.send_message(GROUP_ID, f"Ответы от пользователя {user_id}:\n\n{answer_text}")
        await bot.send_message(user_id, f"Ваши ответы отправлены. Оператор с вами свяжится)",
                               parse_mode='Markdown')
    else:
        await bot.send_message(user_id, "Ответов нет")

# Функция для переписывания ответов
async def rewrite_answers(user_id):
    # Очищаем таблицу с ответами
    cursor.execute("DELETE FROM answers WHERE user_id=?", (user_id,))
    conn.commit()

    await bot.send_message(user_id, "Ваши ответы удалены. Начнем сначала.")
    await ask_question(user_id, 1)

# Функция для обработки сообщений из группы и пересылки их пользователю
@dp.message_handler(lambda message: message.chat.id == int(GROUP_ID) and message.reply_to_message)
async def handle_group_reply(message: types.Message):
    # Проверяем, что сообщение является ответом на сообщение бота
    if message.reply_to_message.from_user.id == bot.id:
        # Извлекаем ID пользователя из текста сообщения
        try:
            user_id = int(message.reply_to_message.text.split()[2].strip(':'))
            await bot.send_message(user_id, f"Сообщение от администратора:\n\n{message.text}")
            # Сохраняем ответ пользователя для пересылки обратно в группу
            cursor.execute("INSERT INTO admin_user_conversation (user_id, admin_message_id) VALUES (?, ?)",
                           (user_id, message.message_id))
            conn.commit()
        except (IndexError, ValueError):
            await message.reply("Не удалось определить ID пользователя для ответа.")

# Обработчик сообщений от пользователя в ответ на администратора
@dp.message_handler(lambda message: message.chat.id != int(GROUP_ID))
async def handle_user_reply(message: types.Message):
    user_id = message.chat.id
    cursor.execute("SELECT admin_message_id FROM admin_user_conversation WHERE user_id=? ORDER BY admin_message_id DESC LIMIT 1", (user_id,))
    admin_message_id = cursor.fetchone()
    if admin_message_id:
        await bot.send_message(GROUP_ID, f"Сообщение от пользователя {user_id}:\n\n{message.text}", reply_to_message_id=admin_message_id[0])

if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    try:
        loop.create_task(dp.start_polling())
        loop.run_forever()
    except KeyboardInterrupt:
        pass
    finally:
        conn.close()
