"""Каркас Telegram-бота «магазин + запись» на aiogram 3.

Тот же сценарий, что в симуляторе index.html: меню -> каталог -> корзина ->
заказ, и запись на услугу (услуга -> день -> время -> имя -> подтверждение).

Это каркас, а не готовый продукт: каталог в памяти, заказ только отправляется
владельцу сообщением. Токена в коде нет. Каркас проверен только компиляцией
(py_compile); с живым Telegram он не запускался.

Запуск:
    pip install "aiogram>=3.4"
    set BOT_TOKEN=...      (Linux/macOS: export BOT_TOKEN=...)  # токен из @BotFather
    set ADMIN_ID=...       # числовой id владельца, куда приходят заявки
    python bot_example.py
"""
import asyncio
import logging
import os
from datetime import date, timedelta

from aiogram import Bot, Dispatcher, F, Router
from aiogram.filters import Command, CommandStart
from aiogram.filters.callback_data import CallbackData
from aiogram.fsm.context import FSMContext
from aiogram.fsm.state import State, StatesGroup
from aiogram.fsm.storage.memory import MemoryStorage
from aiogram.types import CallbackQuery, InlineKeyboardMarkup, Message
from aiogram.utils.keyboard import InlineKeyboardBuilder

# Примерный каталог. Цены и товары заказчик присылает свои.
CATALOG = {
    "beans_a": "Кофе в зёрнах «Утро» (пример)",
    "beans_b": "Кофе в зёрнах «Вечер» (пример)",
    "tea": "Чай «Лист» (пример)",
}
SERVICES = {"tasting": "Дегустация (пример)", "consult": "Консультация (пример)"}
SLOTS = ["10:00", "12:00", "15:00"]  # пример, в проекте берутся из расписания

router = Router()


class Menu(CallbackData, prefix="m"):
    action: str          # catalog | cart | clear | checkout | book | home | add | svc | day | slot
    arg: str = ""


class Flow(StatesGroup):
    order_name = State()
    book_name = State()


def kb_home() -> InlineKeyboardMarkup:
    b = InlineKeyboardBuilder()
    b.button(text="Каталог", callback_data=Menu(action="catalog"))
    b.button(text="Корзина", callback_data=Menu(action="cart"))
    b.button(text="Записаться", callback_data=Menu(action="book"))
    b.adjust(2, 1)
    return b.as_markup()


def kb_catalog() -> InlineKeyboardMarkup:
    b = InlineKeyboardBuilder()
    for key, title in CATALOG.items():
        b.button(text="+ " + title, callback_data=Menu(action="add", arg=key))
    b.button(text="Корзина", callback_data=Menu(action="cart"))
    b.button(text="Меню", callback_data=Menu(action="home"))
    b.adjust(1)
    return b.as_markup()


def cart_text(cart: dict) -> str:
    if not cart:
        return "Корзина пуста."
    lines = ["%s x %d" % (CATALOG[k], q) for k, q in cart.items()]
    return "В корзине:\n" + "\n".join(lines)


@router.message(CommandStart())
@router.message(Command("menu"))
async def cmd_start(message: Message, state: FSMContext) -> None:
    await state.clear()
    await message.answer("Привет! Это демо-бот магазина. Что хотите сделать?", reply_markup=kb_home())


@router.callback_query(Menu.filter(F.action == "home"))
async def on_home(cb: CallbackQuery, state: FSMContext) -> None:
    await state.clear()
    await cb.message.edit_text("Главное меню:", reply_markup=kb_home())
    await cb.answer()


@router.callback_query(Menu.filter(F.action == "catalog"))
async def on_catalog(cb: CallbackQuery) -> None:
    await cb.message.edit_text("Каталог:", reply_markup=kb_catalog())
    await cb.answer()


@router.callback_query(Menu.filter(F.action == "add"))
async def on_add(cb: CallbackQuery, callback_data: Menu, state: FSMContext) -> None:
    data = await state.get_data()
    cart = dict(data.get("cart", {}))
    if callback_data.arg in CATALOG:
        cart[callback_data.arg] = cart.get(callback_data.arg, 0) + 1
    await state.update_data(cart=cart)
    await cb.answer("Добавлено в корзину")


@router.callback_query(Menu.filter(F.action == "cart"))
async def on_cart(cb: CallbackQuery, state: FSMContext) -> None:
    cart = (await state.get_data()).get("cart", {})
    b = InlineKeyboardBuilder()
    if cart:
        b.button(text="Оформить заказ", callback_data=Menu(action="checkout"))
        b.button(text="Очистить", callback_data=Menu(action="clear"))
    b.button(text="Каталог", callback_data=Menu(action="catalog"))
    b.adjust(1)
    await cb.message.edit_text(cart_text(cart), reply_markup=b.as_markup())
    await cb.answer()


@router.callback_query(Menu.filter(F.action == "clear"))
async def on_clear(cb: CallbackQuery, state: FSMContext) -> None:
    await state.update_data(cart={})
    await cb.message.edit_text("Корзина очищена.", reply_markup=kb_home())
    await cb.answer()


@router.callback_query(Menu.filter(F.action == "checkout"))
async def on_checkout(cb: CallbackQuery, state: FSMContext) -> None:
    await state.set_state(Flow.order_name)
    await cb.message.answer("Как к вам обращаться? Напишите имя сообщением.")
    await cb.answer()


@router.message(Flow.order_name, F.text)
async def got_order_name(message: Message, state: FSMContext, bot: Bot) -> None:
    cart = (await state.get_data()).get("cart", {})
    text = "Новый заказ\nКлиент: %s (id %s)\n%s" % (
        message.text.strip()[:60], message.from_user.id, cart_text(cart))
    await notify_admin(bot, text)
    await state.clear()
    await message.answer("Заказ принят, мы свяжемся с вами.", reply_markup=kb_home())


# --- запись на услугу -------------------------------------------------------
@router.callback_query(Menu.filter(F.action == "book"))
async def on_book(cb: CallbackQuery) -> None:
    b = InlineKeyboardBuilder()
    for key, title in SERVICES.items():
        b.button(text=title, callback_data=Menu(action="svc", arg=key))
    b.button(text="Меню", callback_data=Menu(action="home"))
    b.adjust(1)
    await cb.message.edit_text("Выберите услугу:", reply_markup=b.as_markup())
    await cb.answer()


@router.callback_query(Menu.filter(F.action == "svc"))
async def on_service(cb: CallbackQuery, callback_data: Menu, state: FSMContext) -> None:
    await state.update_data(service=callback_data.arg)
    b = InlineKeyboardBuilder()
    for i in range(1, 4):
        d = date.today() + timedelta(days=i)
        b.button(text=d.strftime("%d.%m"), callback_data=Menu(action="day", arg=d.isoformat()))
    b.adjust(3)
    await cb.message.edit_text("Выберите день:", reply_markup=b.as_markup())
    await cb.answer()


@router.callback_query(Menu.filter(F.action == "day"))
async def on_day(cb: CallbackQuery, callback_data: Menu, state: FSMContext) -> None:
    await state.update_data(day=callback_data.arg)
    b = InlineKeyboardBuilder()
    for s in SLOTS:
        b.button(text=s, callback_data=Menu(action="slot", arg=s))
    b.adjust(3)
    await cb.message.edit_text("Выберите время:", reply_markup=b.as_markup())
    await cb.answer()


@router.callback_query(Menu.filter(F.action == "slot"))
async def on_slot(cb: CallbackQuery, callback_data: Menu, state: FSMContext) -> None:
    await state.update_data(slot=callback_data.arg)
    await state.set_state(Flow.book_name)
    await cb.message.answer("Как к вам обращаться? Напишите имя сообщением.")
    await cb.answer()


@router.message(Flow.book_name, F.text)
async def got_book_name(message: Message, state: FSMContext, bot: Bot) -> None:
    d = await state.get_data()
    text = "Новая запись\nКлиент: %s (id %s)\nУслуга: %s\nКогда: %s %s" % (
        message.text.strip()[:60], message.from_user.id,
        SERVICES.get(d.get("service"), "?"), d.get("day"), d.get("slot"))
    await notify_admin(bot, text)
    await state.clear()
    await message.answer("Запись принята. Напоминание придёт заранее.", reply_markup=kb_home())


async def notify_admin(bot: Bot, text: str) -> None:
    admin_id = os.environ.get("ADMIN_ID")
    if admin_id:
        await bot.send_message(int(admin_id), text)
    else:
        logging.warning("ADMIN_ID не задан, уведомление не отправлено:\n%s", text)


async def main() -> None:
    token = os.environ.get("BOT_TOKEN")
    if not token:
        raise SystemExit("Задайте переменную окружения BOT_TOKEN (токен из @BotFather)")
    logging.basicConfig(level=logging.INFO)
    bot = Bot(token=token)
    dp = Dispatcher(storage=MemoryStorage())
    dp.include_router(router)
    await dp.start_polling(bot)


if __name__ == "__main__":
    asyncio.run(main())
