Создай фабрику
ботов-визиток за 15 минут

cat > bot.py << 'ENDOFFILE'
#!/usr/bin/env python3
"""
🪪 Bot-Vizitka Factory v3
Telegram Bot API 9.6 (Managed Bots) + OpenRouter (Nano Banana 2) + SQLite
Клуб Вайбкодеров | 2026
"""

import asyncio, aiohttp, json, logging, time, io, os, sqlite3, qrcode, base64
from datetime import datetime

# ═══════════════════════════════════════════
#  КОНФИГ
# ═══════════════════════════════════════════
MANAGER_BOT_TOKEN = "ВСТАВЬ_ТОКЕН_МЕНЕДЖЕРА"
OPENROUTER_API_KEY = "ВСТАВЬ_КЛЮЧ_OPENROUTER"
CHAT_MODEL = "google/gemini-2.5-flash"
IMAGE_MODEL = "google/gemini-3.1-flash-image-preview"
TG = "https://api.telegram.org/bot{token}/{method}"
OR_API = "https://openrouter.ai/api/v1/chat/completions"

log = logging.getLogger("vizitka")
logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")

# ═══════════════════════════════════════════
#  БАЗА ДАННЫХ
# ═══════════════════════════════════════════
DB = "factory.db"

def init_db():
    conn = sqlite3.connect(DB)
    c = conn.cursor()
    c.execute("""CREATE TABLE IF NOT EXISTS bots (
        bot_id INTEGER PRIMARY KEY, bot_username TEXT, bot_token TEXT,
        owner_id INTEGER, template TEXT, data TEXT, created_at TEXT)""")
    c.execute("""CREATE TABLE IF NOT EXISTS leads (
        id INTEGER PRIMARY KEY AUTOINCREMENT, bot_id INTEGER, client_id INTEGER,
        client_name TEXT, message TEXT, created_at TEXT)""")
    c.execute("""CREATE TABLE IF NOT EXISTS visitors (
        id INTEGER PRIMARY KEY AUTOINCREMENT, bot_id INTEGER, user_id INTEGER,
        first_seen TEXT, UNIQUE(bot_id, user_id))""")
    conn.commit(); conn.close()
    log.info("📦 БД готова")

def db_save_bot(bot_id, uname, token, owner, tpl, data):
    conn = sqlite3.connect(DB); c = conn.cursor()
    c.execute("INSERT OR REPLACE INTO bots VALUES (?,?,?,?,?,?,?)",
        (bot_id, uname, token, owner, tpl, json.dumps(data, ensure_ascii=False), datetime.now().isoformat()))
    conn.commit(); conn.close()

def db_get_bot(bot_id):
    conn = sqlite3.connect(DB); c = conn.cursor()
    c.execute("SELECT * FROM bots WHERE bot_id=?", (bot_id,))
    r = c.fetchone(); conn.close()
    if r: return {"bot_id":r[0],"bot_username":r[1],"bot_token":r[2],"owner_id":r[3],
                  "template":r[4],"data":json.loads(r[5]),"created_at":r[6]}
    return None

def db_get_bots_by_owner(owner_id):
    conn = sqlite3.connect(DB); c = conn.cursor()
    c.execute("SELECT bot_id, bot_username, template, created_at FROM bots WHERE owner_id=?", (owner_id,))
    rows = c.fetchall(); conn.close(); return rows

def db_get_all_bots():
    conn = sqlite3.connect(DB); c = conn.cursor()
    c.execute("SELECT bot_id, bot_username, bot_token, owner_id, template, data FROM bots")
    rows = c.fetchall(); conn.close()
    return [{"bot_id":r[0],"bot_username":r[1],"bot_token":r[2],"owner_id":r[3],
             "template":r[4],"data":json.loads(r[5])} for r in rows]

def db_update_bot_data(bot_id, data):
    conn = sqlite3.connect(DB); c = conn.cursor()
    c.execute("UPDATE bots SET data=? WHERE bot_id=?", (json.dumps(data, ensure_ascii=False), bot_id))
    conn.commit(); conn.close()

def db_save_lead(bot_id, cid, name, msg):
    conn = sqlite3.connect(DB); c = conn.cursor()
    c.execute("INSERT INTO leads (bot_id,client_id,client_name,message,created_at) VALUES (?,?,?,?,?)",
        (bot_id, cid, name, msg, datetime.now().isoformat()))
    conn.commit(); conn.close()

def db_get_leads(bot_id):
    conn = sqlite3.connect(DB); c = conn.cursor()
    c.execute("SELECT client_name,message,created_at FROM leads WHERE bot_id=? ORDER BY created_at DESC LIMIT 20", (bot_id,))
    rows = c.fetchall(); conn.close(); return rows

def db_track_visitor(bot_id, uid):
    conn = sqlite3.connect(DB); c = conn.cursor()
    try:
        c.execute("INSERT INTO visitors (bot_id,user_id,first_seen) VALUES (?,?,?)",
            (bot_id, uid, datetime.now().isoformat()))
        conn.commit()
    except sqlite3.IntegrityError: pass
    conn.close()

def db_count_visitors(bot_id):
    conn = sqlite3.connect(DB); c = conn.cursor()
    c.execute("SELECT COUNT(*) FROM visitors WHERE bot_id=?", (bot_id,)); total = c.fetchone()[0]
    today = datetime.now().strftime("%Y-%m-%d")
    c.execute("SELECT COUNT(*) FROM visitors WHERE bot_id=? AND first_seen LIKE ?", (bot_id, today+"%"))
    td = c.fetchone()[0]; conn.close(); return total, td

def db_count_leads(bot_id):
    conn = sqlite3.connect(DB); c = conn.cursor()
    c.execute("SELECT COUNT(*) FROM leads WHERE bot_id=?", (bot_id,))
    t = c.fetchone()[0]; conn.close(); return t

# ═══════════════════════════════════════════
#  ШАБЛОНЫ
# ═══════════════════════════════════════════
TEMPLATES = {
    "photographer": {
        "emoji": "📸", "name": "Фотограф",
        "questions": [
            "Как тебя зовут? (Имя и фамилия)",
            "Какие жанры съёмки? (свадьбы, портреты, предметка...)",
            "Услуги и цены подробно",
            "О себе: опыт, стиль, регалии",
            "Рабочий график",
            "Контакты (телефон, Instagram, сайт)",
            "Ссылка на портфолио"
        ],
        "system_tpl": "Ты — бот-визитка фотографа {name}.\n\nЖанры: {q1}\nУслуги и цены: {q2}\nО мастере: {q3}\nГрафик: {q4}\nКонтакты: {q5}\nПортфолио: {q6}\n\nОтвечай дружелюбно, по делу, на языке клиента."
    },
    "tutor": {
        "emoji": "📚", "name": "Репетитор",
        "questions": [
            "Как тебя зовут? (Имя и фамилия)",
            "Предметы и уровни (классы, ЕГЭ, студенты...)",
            "Услуги и цены подробно",
            "О себе: образование, опыт, достижения учеников",
            "График и формат (онлайн/офлайн)",
            "Контакты (телефон, Telegram, email)",
            "Ссылка на отзывы"
        ],
        "system_tpl": "Ты — бот-визитка репетитора {name}.\n\nПредметы: {q1}\nУслуги и цены: {q2}\nО преподавателе: {q3}\nГрафик: {q4}\nКонтакты: {q5}\nОтзывы: {q6}\n\nОтвечай доброжелательно, на языке клиента."
    },
    "designer": {
        "emoji": "🎨", "name": "Дизайнер",
        "questions": [
            "Как тебя зовут? (Имя и фамилия)",
            "Направления дизайна (веб, UI/UX, интерьер, брендинг...)",
            "Услуги и цены подробно",
            "О себе: опыт, клиенты, стиль",
            "График и сроки",
            "Контакты (Telegram, Behance, сайт)",
            "Ссылка на портфолио"
        ],
        "system_tpl": "Ты — бот-визитка дизайнера {name}.\n\nНаправления: {q1}\nУслуги и цены: {q2}\nО мастере: {q3}\nГрафик: {q4}\nКонтакты: {q5}\nПортфолио: {q6}\n\nОтвечай профессионально, на языке клиента."
    },
    "nailmaster": {
        "emoji": "💅", "name": "Мастер маникюра",
        "questions": [
            "Как тебя зовут? (Имя и фамилия)",
            "Какие услуги? (маникюр, педикюр, наращивание, дизайн...)",
            "Услуги и цены подробно",
            "О себе: опыт, обучение, сертификаты",
            "График и адрес студии",
            "Контакты (телефон, Instagram, Telegram)",
            "Ссылка на примеры работ"
        ],
        "system_tpl": "Ты — бот-визитка мастера маникюра {name}.\n\nУслуги: {q1}\nЦены: {q2}\nО мастере: {q3}\nГрафик и адрес: {q4}\nКонтакты: {q5}\nРаботы: {q6}\n\nОтвечай тепло и дружелюбно, на языке клиента."
    },
    "psychologist": {
        "emoji": "🧠", "name": "Психолог / Коуч",
        "questions": [
            "Как тебя зовут? (Имя и фамилия)",
            "С какими запросами работаешь?",
            "Услуги и цены подробно",
            "О себе: образование, подход, сертификации",
            "График и формат (онлайн/офлайн)",
            "Контакты (Telegram, сайт, email)",
            "Ссылка на отзывы или публикации"
        ],
        "system_tpl": "Ты — бот-визитка психолога/коуча {name}.\n\nНаправления: {q1}\nУслуги и цены: {q2}\nО специалисте: {q3}\nГрафик: {q4}\nКонтакты: {q5}\nПубликации: {q6}\n\nОтвечай бережно. Не давай терапевтических советов — только информацию. На языке клиента."
    },
    "developer": {
        "emoji": "💻", "name": "Разработчик",
        "questions": [
            "Как тебя зовут? (Имя и фамилия)",
            "Технологии и направления (боты, сайты, AI, приложения...)",
            "Услуги и цены подробно",
            "О себе: опыт, проекты, стек",
            "График и сроки",
            "Контакты (Telegram, GitHub, сайт)",
            "Ссылка на портфолио или GitHub"
        ],
        "system_tpl": "Ты — бот-визитка разработчика {name}.\n\nТехнологии: {q1}\nУслуги и цены: {q2}\nО разработчике: {q3}\nГрафик: {q4}\nКонтакты: {q5}\nПортфолио: {q6}\n\nОтвечай технически грамотно но понятно, на языке клиента."
    }
}

# ═══════════════════════════════════════════
#  TELEGRAM HELPERS
# ═══════════════════════════════════════════
async def tg(session, token, method, **params):
    url = TG.format(token=token, method=method)
    async with session.post(url, json={k:v for k,v in params.items() if v is not None}) as r:
        d = await r.json()
        if not d.get("ok"): log.error(f"TG {method}: {d}")
        return d.get("result")

async def tg_upload(session, token, method, field, fbytes, fname="photo.jpg", **params):
    from PIL import Image
    url = TG.format(token=token, method=method)
    if method == "setMyProfilePhoto":
        try:
            pil_img = Image.open(io.BytesIO(fbytes)).convert("RGB")
            buf = io.BytesIO()
            pil_img.save(buf, format="JPEG", quality=90)
            fbytes = buf.getvalue()
            log.info(f"🖼️ Конвертировано в JPEG: {len(fbytes)} bytes")
        except Exception as e:
            log.error(f"Конвертация: {e}")
        form = aiohttp.FormData()
        photo_obj = json.dumps({"type": "static", "photo": "attach://file"})
        form.add_field("photo", photo_obj)
        form.add_field("file", fbytes, filename="photo.jpg", content_type="image/jpeg")
        async with session.post(url, data=form) as r:
            d = await r.json()
            if d.get("ok"):
                log.info("🖼️ Аватарка установлена!")
            else:
                log.error(f"setMyProfilePhoto: {d}")
            return d.get("result")
    form = aiohttp.FormData()
    form.add_field(field, fbytes, filename=fname, content_type="image/jpeg")
    for k,v in params.items():
        if v is not None: form.add_field(k, str(v) if not isinstance(v,str) else v)
    async with session.post(url, data=form) as r:
        d = await r.json()
        if not d.get("ok"): log.error(f"TG upload {method}: {d}")
        return d.get("result")

async def send(session, token, chat_id, text, reply_markup=None):
    return await tg(session, token, "sendMessage", chat_id=chat_id, text=text,
        parse_mode="HTML", reply_markup=json.dumps(reply_markup) if reply_markup else None)

async def send_photo(session, token, chat_id, photo_bytes, caption="", reply_markup=None):
    url = TG.format(token=token, method="sendPhoto")
    form = aiohttp.FormData()
    form.add_field("photo", photo_bytes, filename="photo.jpg", content_type="image/jpeg")
    form.add_field("chat_id", str(chat_id))
    if caption: form.add_field("caption", caption); form.add_field("parse_mode", "HTML")
    if reply_markup: form.add_field("reply_markup", json.dumps(reply_markup))
    async with session.post(url, data=form) as r:
        d = await r.json()
        if not d.get("ok"): log.error(f"TG sendPhoto: {d}")
        return d.get("result")

async def download_tg_photo(session, token, file_id):
    f = await tg(session, token, "getFile", file_id=file_id)
    if not f: return None
    url = f"https://api.telegram.org/file/bot{token}/{f['file_path']}"
    async with session.get(url) as r:
        if r.status == 200: return await r.read()
    return None

# ═══════════════════════════════════════════
#  OPENROUTER
# ═══════════════════════════════════════════
async def or_chat(session, messages, model=None):
    model = model or CHAT_MODEL
    headers = {"Authorization": f"Bearer {OPENROUTER_API_KEY}", "Content-Type": "application/json"}
    body = {"model": model, "messages": messages, "max_tokens": 1024}
    try:
        async with session.post(OR_API, headers=headers, json=body) as r:
            d = await r.json()
            if "choices" in d: return d["choices"][0]["message"]["content"].strip()
            log.error(f"OR chat: {d}"); return None
    except Exception as e: log.error(f"OR error: {e}"); return None

async def generate_image(session, prompt, aspect="1:1", size="1K", ref_photo_b64=None):
    headers = {"Authorization": f"Bearer {OPENROUTER_API_KEY}", "Content-Type": "application/json"}
    if ref_photo_b64:
        content = [
            {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{ref_photo_b64}"}},
            {"type": "text", "text": prompt}
        ]
    else:
        content = prompt
    body = {
        "model": IMAGE_MODEL,
        "messages": [{"role": "user", "content": content}],
        "modalities": ["image", "text"],
        "image_config": {"aspect_ratio": aspect, "image_size": size}
    }
    try:
        async with session.post(OR_API, headers=headers, json=body) as r:
            d = await r.json()
            if "choices" in d:
                msg = d["choices"][0].get("message", {})
                images = msg.get("images", [])
                if images:
                    b64url = images[0]["image_url"]["url"]
                    if "," in b64url: b64data = b64url.split(",", 1)[1]
                    else: b64data = b64url
                    img_bytes = base64.b64decode(b64data)
                    log.info(f"🎨 Изображение: {len(img_bytes)} bytes ({aspect}, {size})")
                    return img_bytes
                content_str = msg.get("content", "")
                if content_str and len(content_str) > 1000:
                    try:
                        img_bytes = base64.b64decode(content_str)
                        log.info(f"🎨 Изображение (content): {len(img_bytes)} bytes")
                        return img_bytes
                    except: pass
                if content_str and content_str.startswith("data:image"):
                    b64data = content_str.split(",", 1)[1] if "," in content_str else content_str
                    try:
                        img_bytes = base64.b64decode(b64data)
                        log.info(f"🎨 Изображение (data-url): {len(img_bytes)} bytes")
                        return img_bytes
                    except: pass
                fr = d["choices"][0].get("finish_reason", "")
                log.error(f"OR image: нет картинки, finish_reason={fr}")
                return None
            log.error(f"OR image: {d}"); return None
    except Exception as e: log.error(f"OR image error: {e}"); return None

# ═══════════════════════════════════════════
#  QR-КОД
# ═══════════════════════════════════════════
def make_qr(bot_username):
    qr = qrcode.QRCode(version=1, error_correction=qrcode.constants.ERROR_CORRECT_H, box_size=10, border=2)
    qr.add_data(f"https://t.me/{bot_username}"); qr.make(fit=True)
    img = qr.make_image(fill_color="black", back_color="white")
    buf = io.BytesIO(); img.save(buf, format="PNG"); return buf.getvalue()

# ═══════════════════════════════════════════
#  СОСТОЯНИЯ
# ═══════════════════════════════════════════
states = {}

# ═══════════════════════════════════════════
#  МЕНЕДЖЕР-БОТ
# ═══════════════════════════════════════════
async def handle_manager(session, update):

    # ─── Managed Bot создан ───
    if "managed_bot" in update:
        mb = update["managed_bot"]
        user_id = mb["user"]["id"]
        bot_user = mb["bot"]
        bot_id = bot_user["id"]
        bot_uname = bot_user.get("username", "unknown")
        log.info(f"🤖 managed_bot: @{bot_uname} (ID:{bot_id}) от {user_id}")

        token_result = await tg(session, MANAGER_BOT_TOKEN, "getManagedBotToken", user_id=bot_id)
        if not token_result:
            await send(session, MANAGER_BOT_TOKEN, user_id, "❌ Не получил токен бота."); return
        bot_token = token_result
        log.info(f"🔑 Токен: {bot_token[:25]}...")

        state = states.get(user_id, {})
        tpl_key = state.get("template", "photographer")
        tpl = TEMPLATES[tpl_key]
        answers = state.get("answers", [])

        bot_data = {
            "name": answers[0] if answers else "Без имени",
            "answers": answers, "template": tpl_key,
            "welcome_photo": None
        }

        fields = {"name": bot_data["name"]}
        for i, a in enumerate(answers[1:], 1): fields[f"q{i}"] = a
        bot_data["system_prompt"] = tpl["system_tpl"].format(
            **{k: fields.get(k,"") for k in ["name","q1","q2","q3","q4","q5","q6"]})
        bot_data["welcome"] = f"{tpl['emoji']} Привет! Я — бот-визитка: {bot_data['name']}\n\nВыбери что интересует 👇"

        db_save_bot(bot_id, bot_uname, bot_token, user_id, tpl_key, bot_data)
        await send(session, MANAGER_BOT_TOKEN, user_id, f"✅ Бот @{bot_uname} создан!\n⏳ Генерирую аватарку...")

        # Аватарка
        avatar_prompt = await or_chat(session, [
            {"role": "system", "content": "You create short image prompts for icons. Output ONLY the prompt. Max 30 words. Rules: NO people, NO faces, NO names, NO text. Only objects and symbols."},
            {"role": "user", "content": f"Icon with objects symbolizing the profession: {tpl['name']}. Only tools and symbols of this job. Flat vector style, bright colors, white background."}
        ])
        if not avatar_prompt:
            avatar_prompt = f"Flat vector icon of tools for {tpl['name']}, bright colors, white background, no text, no people"
        log.info(f"🎨 Avatar prompt: {avatar_prompt[:80]}...")
        avatar = await generate_image(session, avatar_prompt, aspect="1:1", size="1K")
        if avatar:
            await tg_upload(session, bot_token, "setMyProfilePhoto", "photo", avatar)
            await send(session, MANAGER_BOT_TOKEN, user_id, "🖼️ Аватарка установлена!")
        else:
            await send(session, MANAGER_BOT_TOKEN, user_id, "⚠️ Аватарка не сгенерировалась, продолжаем.")

        # Фото-визитка: спрашиваем
        states[user_id] = {"step": "photo_choice", "bot_id": bot_id, "bot_uname": bot_uname,
                           "template": tpl_key, "answers": answers}
        await send(session, MANAGER_BOT_TOKEN, user_id,
            "📸 Фото-визитка\n\n"
            "Картинка, которую клиенты увидят при открытии бота.\n\n"
            "Два варианта:",
            reply_markup={"inline_keyboard": [
                [{"text": "🎨 Сгенерировать по описанию", "callback_data": "photo:gen"}],
                [{"text": "📷 Загрузить своё фото", "callback_data": "photo:own"}],
                [{"text": "⏭ Пропустить", "callback_data": "photo:skip"}]
            ]})
        return

    # ─── Сообщение ───
    msg = update.get("message")
    if not msg:
        cb = update.get("callback_query")
        if cb: await handle_manager_cb(session, cb)
        return

    chat_id = msg["chat"]["id"]
    user_id = msg["from"]["id"]
    text = msg.get("text", "")
    photo = msg.get("photo")
    state = states.get(user_id, {})

    # Фото от пользователя
    if photo and state.get("step") in ("photo_wait", "edit_photo_wait", "edit_avatar_wait"):
        file_id = photo[-1]["file_id"]
        await send(session, MANAGER_BOT_TOKEN, chat_id, "⏳ Обрабатываю фото...")
        photo_bytes = await download_tg_photo(session, MANAGER_BOT_TOKEN, file_id)
        if not photo_bytes:
            await send(session, MANAGER_BOT_TOKEN, chat_id, "❌ Не скачалось. Попробуй ещё раз."); return

        photo_b64 = base64.b64encode(photo_bytes).decode()
        bot_id = state["bot_id"]
        bot_info = db_get_bot(bot_id)
        if not bot_info: return
        data = bot_info["data"]; tpl = TEMPLATES[bot_info["template"]]

        if state["step"] == "edit_avatar_wait":
            prompt = f"Transform this photo into a professional, modern avatar icon for a {tpl['name']}. Vibrant, clean, round composition. Keep recognizable but stylized. No text."
            img = await generate_image(session, prompt, aspect="1:1", size="1K", ref_photo_b64=photo_b64)
            if img:
                await tg_upload(session, bot_info["bot_token"], "setMyProfilePhoto", "photo", img)
                await send(session, MANAGER_BOT_TOKEN, chat_id, "✅ Аватарка обновлена!")
            else:
                await send(session, MANAGER_BOT_TOKEN, chat_id, "❌ Не получилось. Попробуй другое фото.")
        else:
            prompt = f"Transform this photo into a professional, stylish business card image for a {tpl['name']}. Business: {data['name']}. Premium, modern feel. Keep recognizable. No text."
            img = await generate_image(session, prompt, aspect="4:3", size="2K", ref_photo_b64=photo_b64)
            if img:
                data["welcome_photo"] = base64.b64encode(img).decode()
                db_update_bot_data(bot_id, data)
                await send_photo(session, MANAGER_BOT_TOKEN, chat_id, img, caption="✅ Фото-визитка установлена!")
            else:
                await send(session, MANAGER_BOT_TOKEN, chat_id, "❌ Не получилось. Попробуй другое фото.")

        if state["step"] == "photo_wait":
            await finalize_bot(session, user_id, bot_id)
        states.pop(user_id, None)
        return

    # Команды
    if text == "/start":
        states.pop(user_id, None)
        buttons = [[{"text": f"{t['emoji']} {t['name']}", "callback_data": f"tpl:{k}"}] for k,t in TEMPLATES.items()]
        await send(session, MANAGER_BOT_TOKEN, chat_id,
            "🪪 Bot-Vizitka Factory\n\n"
            "Создам тебе бота-визитку за 2 минуты.\n"
            "Аватарка, кнопки, запись клиентов, QR-код, AI-ответы.\n\n"
            "Выбери профессию 👇",
            reply_markup={"inline_keyboard": buttons})
        return

    if text == "/mybots":
        bots = db_get_bots_by_owner(user_id)
        if not bots: await send(session, MANAGER_BOT_TOKEN, chat_id, "Нет ботов. Жми /start!"); return
        lines = ["📋 Твои боты:\n"]
        for b in bots:
            t = TEMPLATES.get(b[2], {}); lines.append(f"🟢 {t.get('emoji','')} @{b[1]} — {t.get('name','')}")
        await send(session, MANAGER_BOT_TOKEN, chat_id, "\n".join(lines))
        return

    if text == "/leads":
        bots = db_get_bots_by_owner(user_id)
        if not bots: await send(session, MANAGER_BOT_TOKEN, chat_id, "Нет ботов."); return
        all_l = []
        for b in bots:
            for l in db_get_leads(b[0]): all_l.append(f"📩 @{b[1]}: {l[0]} — {l[1]} ({l[2][:10]})")
        await send(session, MANAGER_BOT_TOKEN, chat_id,
            ("📋 Заявки:\n\n" + "\n".join(all_l[:20])) if all_l else "Заявок пока нет.")
        return

    if text == "/stats":
        bots = db_get_bots_by_owner(user_id)
        if not bots: await send(session, MANAGER_BOT_TOKEN, chat_id, "Нет ботов."); return
        lines = ["📊 Статистика:\n"]
        for b in bots:
            total, td = db_count_visitors(b[0]); leads = db_count_leads(b[0])
            lines.append(f"{TEMPLATES.get(b[2],{}).get('emoji','')} @{b[1]}: 👥 {total} (+{td}) | 📩 {leads}")
        await send(session, MANAGER_BOT_TOKEN, chat_id, "\n".join(lines))
        return

    if text == "/qr":
        bots = db_get_bots_by_owner(user_id)
        if not bots: await send(session, MANAGER_BOT_TOKEN, chat_id, "Нет ботов."); return
        for b in bots:
            await tg_upload(session, MANAGER_BOT_TOKEN, "sendPhoto", "photo", make_qr(b[1]),
                fname="qr.png", chat_id=chat_id, caption=f"📱 @{b[1]}")
        return

    if text == "/edit":
        bots = db_get_bots_by_owner(user_id)
        if not bots: await send(session, MANAGER_BOT_TOKEN, chat_id, "Нет ботов."); return
        buttons = [[{"text": f"{TEMPLATES.get(b[2],{}).get('emoji','')} @{b[1]}",
            "callback_data": f"edit:{b[0]}"}] for b in bots]
        await send(session, MANAGER_BOT_TOKEN, chat_id, "Какого бота редактировать?",
            reply_markup={"inline_keyboard": buttons})
        return

    # Анкета
    if state.get("step") == "answering":
        answers = state["answers"]; answers.append(text)
        tpl = TEMPLATES[state["template"]]
        idx = len(answers)
        if idx < len(tpl["questions"]):
            await send(session, MANAGER_BOT_TOKEN, chat_id,
                f"✅ Записал!\n\nВопрос {idx+1}/{len(tpl['questions'])}:\n{tpl['questions'][idx]}")
        else:
            state["step"] = "ready"
            summary = "📝 Всё заполнено!\n\n"
            for i,q in enumerate(tpl["questions"]): summary += f"{i+1}. {answers[i]}\n"
            summary += "\nЕсли всё верно — жми кнопку ниже 👇"
            suggested = answers[0].lower().replace(" ","_").replace(".","")[:20] + "_vizitka_bot"
            await send(session, MANAGER_BOT_TOKEN, chat_id, summary)
            await tg(session, MANAGER_BOT_TOKEN, "sendMessage",
                chat_id=chat_id, text="Нажми кнопку чтобы создать бота 👇",
                reply_markup=json.dumps({"keyboard": [
                    [{"text": "🤖 Создать бота-визитку!", "request_managed_bot": {
                        "request_id": 1, "suggested_username": suggested,
                        "suggested_name": f"{tpl['emoji']} {answers[0]}"}}]
                ], "resize_keyboard": True, "one_time_keyboard": True}))
        return

    # Редактирование текста
    if state.get("step") == "editing":
        bot_id = state["edit_bot_id"]; fidx = state["edit_field"]
        bot_info = db_get_bot(bot_id)
        if bot_info:
            data = bot_info["data"]; data["answers"][fidx] = text
            tpl = TEMPLATES[bot_info["template"]]
            fields = {"name": data["answers"][0]}
            for i,a in enumerate(data["answers"][1:],1): fields[f"q{i}"] = a
            data["system_prompt"] = tpl["system_tpl"].format(
                **{k: fields.get(k,"") for k in ["name","q1","q2","q3","q4","q5","q6"]})
            db_update_bot_data(bot_id, data)
            await send(session, MANAGER_BOT_TOKEN, chat_id, f"✅ Обновлено! @{bot_info['bot_username']} уже использует новые данные.")
        states.pop(user_id, None); return

    await send(session, MANAGER_BOT_TOKEN, chat_id,
        "/start — создать бота\n/mybots — мои боты\n/edit — редактировать\n/leads — заявки\n/stats — статистика\n/qr — QR-код")

async def finalize_bot(session, user_id, bot_id):
    bot_info = db_get_bot(bot_id)
    if not bot_info: return
    uname = bot_info["bot_username"]
    qr = make_qr(uname)
    await tg_upload(session, MANAGER_BOT_TOKEN, "sendPhoto", "photo", qr,
        fname="qr.png", chat_id=user_id, caption=f"📱 QR-код: @{uname}\nРаспечатай на визитке!")
    await send(session, MANAGER_BOT_TOKEN, user_id,
        f"🎉 Готово!\n\n"
        f"🔗 https://t.me/{uname}\n\n"
        f"Админка:\n"
        f"/mybots — список ботов\n"
        f"/edit — изменить тексты, фото, аватарку\n"
        f"/leads — заявки клиентов\n"
        f"/stats — статистика\n"
        f"/qr — QR-код повторно")
    asyncio.create_task(run_child(session, bot_id))
    states.pop(user_id, None)

async def handle_manager_cb(session, cb):
    user_id = cb["from"]["id"]; chat_id = cb["message"]["chat"]["id"]; data = cb.get("data","")
    await tg(session, MANAGER_BOT_TOKEN, "answerCallbackQuery", callback_query_id=cb["id"])

    if data.startswith("tpl:"):
        key = data[4:]
        if key not in TEMPLATES: return
        tpl = TEMPLATES[key]
        states[user_id] = {"step": "answering", "template": key, "answers": []}
        await send(session, MANAGER_BOT_TOKEN, chat_id,
            f"{tpl['emoji']} Делаем визитку: {tpl['name']}\n\n"
            f"Отвечай на {len(tpl['questions'])} вопросов.\n\n"
            f"Вопрос 1/{len(tpl['questions'])}:\n{tpl['questions'][0]}")
        return

    if data == "photo:gen":
        state = states.get(user_id, {})
        bot_id = state.get("bot_id")
        if not bot_id: return
        bot_info = db_get_bot(bot_id)
        if not bot_info: return
        d = bot_info["data"]; tpl = TEMPLATES[bot_info["template"]]
        await send(session, MANAGER_BOT_TOKEN, chat_id, "⏳ Генерирую фото-визитку (10-15 сек)...")
        prompt = await or_chat(session, [
            {"role": "system", "content": "You create short image prompts for business hero images. Output ONLY the prompt. Max 50 words. Style: professional, warm lighting, premium feel. NO text on image, NO people, NO faces."},
            {"role": "user", "content": f"Business: {tpl['name']} — {d['name']}\nDetails: {'; '.join(d['answers'][:4])}\n\nCreate a hero image with objects and atmosphere of this business."}
        ])
        if not prompt: prompt = f"Professional business image for {tpl['name']}, tools and workspace, warm lighting, no text, no people"
        img = await generate_image(session, prompt, aspect="4:3", size="2K")
        if img:
            d["welcome_photo"] = base64.b64encode(img).decode()
            db_update_bot_data(bot_id, d)
            await send_photo(session, MANAGER_BOT_TOKEN, chat_id, img, caption="✅ Фото-визитка готова!")
        else:
            await send(session, MANAGER_BOT_TOKEN, chat_id, "⚠️ Не удалось сгенерировать, продолжаем без фото.")
        await finalize_bot(session, user_id, bot_id)
        return

    if data == "photo:own":
        state = states.get(user_id, {})
        if not state.get("bot_id"): return
        states[user_id] = {**state, "step": "photo_wait"}
        await send(session, MANAGER_BOT_TOKEN, chat_id, "📷 Отправь фото. Я стилизую его под визитку.")
        return

    if data == "photo:skip":
        state = states.get(user_id, {})
        bot_id = state.get("bot_id")
        if bot_id: await finalize_bot(session, user_id, bot_id)
        return

    # Редактирование
    if data.startswith("edit:"):
        bot_id = int(data[5:]); bot_info = db_get_bot(bot_id)
        if not bot_info: return
        tpl = TEMPLATES.get(bot_info["template"], {})
        buttons = []
        for i,q in enumerate(tpl.get("questions",[])):
            short = q[:35] + "..." if len(q) > 35 else q
            buttons.append([{"text": f"✏️ {i+1}. {short}", "callback_data": f"ef:{bot_id}:{i}"}])
        buttons.append([{"text": "🎨 Заменить аватарку", "callback_data": f"ea:{bot_id}"}])
        buttons.append([{"text": "📸 Заменить фото-визитку", "callback_data": f"ep:{bot_id}"}])
        await send(session, MANAGER_BOT_TOKEN, chat_id,
            f"🛠 Редактирование @{bot_info['bot_username']}\n\nЧто изменить?",
            reply_markup={"inline_keyboard": buttons})
        return

    if data.startswith("ef:"):
        parts = data.split(":"); bot_id = int(parts[1]); fidx = int(parts[2])
        bot_info = db_get_bot(bot_id)
        if not bot_info: return
        old = bot_info["data"]["answers"][fidx] if fidx < len(bot_info["data"]["answers"]) else ""
        states[user_id] = {"step": "editing", "edit_bot_id": bot_id, "edit_field": fidx}
        await send(session, MANAGER_BOT_TOKEN, chat_id, f"Сейчас:\n{old}\n\nВведи новое значение:")
        return

    if data.startswith("ea:"):
        bot_id = int(data[3:])
        buttons = [
            [{"text": "🎨 Сгенерировать новую", "callback_data": f"eag:{bot_id}"}],
            [{"text": "📷 Загрузить своё фото", "callback_data": f"eao:{bot_id}"}]
        ]
        await send(session, MANAGER_BOT_TOKEN, chat_id, "Как обновить аватарку?",
            reply_markup={"inline_keyboard": buttons})
        return

    if data.startswith("eag:"):
        bot_id = int(data[4:]); bot_info = db_get_bot(bot_id)
        if not bot_info: return
        d = bot_info["data"]; tpl = TEMPLATES[bot_info["template"]]
        await send(session, MANAGER_BOT_TOKEN, chat_id, "⏳ Генерирую новую аватарку...")
        prompt = await or_chat(session, [
            {"role": "system", "content": "You create short image prompts for icons. Output ONLY the prompt. Max 30 words. NO people, NO faces, NO names, NO text. Only objects and symbols."},
            {"role": "user", "content": f"NEW creative icon for {tpl['name']}. Tools and symbols. Flat vector, bright colors, white background."}
        ])
        if not prompt: prompt = f"Creative icon for {tpl['name']}, flat vector, bright colors"
        img = await generate_image(session, prompt, aspect="1:1", size="1K")
        if img:
            await tg_upload(session, bot_info["bot_token"], "setMyProfilePhoto", "photo", img)
            await send(session, MANAGER_BOT_TOKEN, chat_id, "✅ Аватарка обновлена!")
        else:
            await send(session, MANAGER_BOT_TOKEN, chat_id, "❌ Не получилось, попробуй ещё раз.")
        return

    if data.startswith("eao:"):
        bot_id = int(data[4:])
        states[user_id] = {"step": "edit_avatar_wait", "bot_id": bot_id}
        await send(session, MANAGER_BOT_TOKEN, chat_id, "📷 Отправь фото для аватарки.")
        return

    if data.startswith("ep:"):
        bot_id = int(data[3:])
        buttons = [
            [{"text": "🎨 Сгенерировать новую", "callback_data": f"epg:{bot_id}"}],
            [{"text": "📷 Загрузить своё фото", "callback_data": f"epo:{bot_id}"}],
            [{"text": "🗑 Удалить фото", "callback_data": f"epd:{bot_id}"}]
        ]
        await send(session, MANAGER_BOT_TOKEN, chat_id, "Как обновить фото-визитку?",
            reply_markup={"inline_keyboard": buttons})
        return

    if data.startswith("epg:"):
        bot_id = int(data[4:]); bot_info = db_get_bot(bot_id)
        if not bot_info: return
        d = bot_info["data"]; tpl = TEMPLATES[bot_info["template"]]
        await send(session, MANAGER_BOT_TOKEN, chat_id, "⏳ Генерирую новую фото-визитку...")
        prompt = await or_chat(session, [
            {"role": "system", "content": "You create image prompts for business hero images. ONLY the prompt. Max 50 words. Professional, warm lighting, no text, no people."},
            {"role": "user", "content": f"Business: {tpl['name']} — {d['name']}\nDetails: {'; '.join(d['answers'][:4])}\n\nCreate a NEW different hero image."}
        ])
        if not prompt: prompt = f"Professional hero image for {tpl['name']}, no text, no people"
        img = await generate_image(session, prompt, aspect="4:3", size="2K")
        if img:
            d["welcome_photo"] = base64.b64encode(img).decode()
            db_update_bot_data(bot_id, d)
            await send_photo(session, MANAGER_BOT_TOKEN, chat_id, img, caption="✅ Фото-визитка обновлена!")
        else:
            await send(session, MANAGER_BOT_TOKEN, chat_id, "❌ Не получилось.")
        return

    if data.startswith("epo:"):
        bot_id = int(data[4:])
        states[user_id] = {"step": "edit_photo_wait", "bot_id": bot_id}
        await send(session, MANAGER_BOT_TOKEN, chat_id, "📷 Отправь фото для визитки.")
        return

    if data.startswith("epd:"):
        bot_id = int(data[4:]); bot_info = db_get_bot(bot_id)
        if not bot_info: return
        d = bot_info["data"]; d["welcome_photo"] = None
        db_update_bot_data(bot_id, d)
        await send(session, MANAGER_BOT_TOKEN, chat_id, "✅ Фото удалено.")
        return

# ═══════════════════════════════════════════
#  ДОЧЕРНИЙ БОТ
# ═══════════════════════════════════════════
child_data = {}

def get_child(bot_id, chat_id):
    key = (bot_id, chat_id)
    if key not in child_data: child_data[key] = {"history": [], "booking": False}
    return child_data[key]

async def run_child(session, bot_id):
    bot_info = db_get_bot(bot_id)
    if not bot_info: log.error(f"Бот {bot_id} не найден"); return
    token = bot_info["bot_token"]; uname = bot_info["bot_username"]
    log.info(f"🟢 Запуск @{uname}...")
    offset = 0
    while True:
        try:
            updates = await tg(session, token, "getUpdates", offset=offset, timeout=30,
                allowed_updates=json.dumps(["message","callback_query"]))
            if not updates: continue
            for upd in updates:
                offset = upd["update_id"] + 1
                bot_info = db_get_bot(bot_id)
                if not bot_info: continue
                if "callback_query" in upd:
                    await handle_child_cb(session, bot_info, upd["callback_query"])
                elif "message" in upd:
                    await handle_child_msg(session, bot_info, upd["message"])
        except asyncio.CancelledError: break
        except Exception as e:
            log.error(f"[@{uname}] {e}"); await asyncio.sleep(3)

async def handle_child_msg(session, bot_info, msg):
    bot_id = bot_info["bot_id"]; token = bot_info["bot_token"]; uname = bot_info["bot_username"]
    chat_id = msg["chat"]["id"]; user_id = msg["from"]["id"]
    text = msg.get("text",""); user_name = msg["from"].get("first_name","Клиент")
    lang = msg["from"].get("language_code","ru")
    data = bot_info["data"]
    db_track_visitor(bot_id, user_id)
    cd = get_child(bot_id, chat_id)

    if text == "/start":
        cd["history"] = []; cd["booking"] = False
        buttons = [
            [{"text": "💰 Услуги и цены", "callback_data": "v:prices"}],
            [{"text": "👤 Обо мне", "callback_data": "v:about"}],
            [{"text": "🖼 Портфолио", "callback_data": "v:portfolio"}],
            [{"text": "📅 Записаться", "callback_data": "v:book"}],
            [{"text": "🕐 График работы", "callback_data": "v:schedule"}],
            [{"text": "📞 Контакты", "callback_data": "v:contacts"}]
        ]
        welcome_photo = data.get("welcome_photo")
        if welcome_photo:
            try:
                photo_bytes = base64.b64decode(welcome_photo)
                await send_photo(session, token, chat_id, photo_bytes,
                    caption=data.get("welcome","Привет!"), reply_markup={"inline_keyboard": buttons})
            except:
                await send(session, token, chat_id, data.get("welcome","Привет!"),
                    reply_markup={"inline_keyboard": buttons})
        else:
            await send(session, token, chat_id, data.get("welcome","Привет!"),
                reply_markup={"inline_keyboard": buttons})
        return

    if cd["booking"]:
        db_save_lead(bot_id, user_id, user_name, text)
        await send(session, MANAGER_BOT_TOKEN, bot_info["owner_id"],
            f"📩 Новая заявка!\n\nБот: @{uname}\nКлиент: {user_name}\nСообщение: {text}")
        await send(session, token, chat_id, f"✅ Заявка отправлена! {data.get('name','Мастер')} свяжется с тобой.")
        cd["booking"] = False
        log.info(f"📩 [@{uname}] {user_name}: {text[:50]}")
        return

    cd["history"].append({"role": "user", "content": text})
    if len(cd["history"]) > 10: cd["history"] = cd["history"][-10:]
    lang_note = f" Answer in {lang}." if lang != "ru" else ""
    messages = [{"role":"system","content": data.get("system_prompt","Ты бот-визитка.") + lang_note}] + cd["history"]
    await tg(session, token, "sendChatAction", chat_id=chat_id, action="typing")
    answer = await or_chat(session, messages)
    if answer:
        cd["history"].append({"role":"assistant","content": answer})
        await send(session, token, chat_id, answer)
        log.info(f"[@{uname}] {user_name}: {text[:40]} → {answer[:40]}")
    else:
        await send(session, token, chat_id, "Извините, попробуйте позже.")

async def handle_child_cb(session, bot_info, cb):
    bot_id = bot_info["bot_id"]; token = bot_info["bot_token"]
    chat_id = cb["message"]["chat"]["id"]; data_str = cb.get("data","")
    await tg(session, token, "answerCallbackQuery", callback_query_id=cb["id"])
    data = bot_info["data"]; answers = data.get("answers",[])
    cd = get_child(bot_id, chat_id)

    if data_str == "v:prices":
        await send(session, token, chat_id, f"💰 Услуги и цены\n\n{answers[2] if len(answers)>2 else 'Не указано'}")
    elif data_str == "v:about":
        await send(session, token, chat_id, f"👤 О мастере\n\n{answers[3] if len(answers)>3 else 'Не указано'}")
    elif data_str == "v:portfolio":
        await send(session, token, chat_id, f"🖼 Портфолио\n\n{answers[6] if len(answers)>6 else 'Не указано'}")
    elif data_str == "v:book":
        cd["booking"] = True
        await send(session, token, chat_id, "📅 Запись\n\nНапиши имя, какая услуга нужна и удобное время — передам мастеру!")
    elif data_str == "v:schedule":
        await send(session, token, chat_id, f"🕐 График\n\n{answers[4] if len(answers)>4 else 'Не указан'}")
    elif data_str == "v:contacts":
        await send(session, token, chat_id, f"📞 Контакты\n\n{answers[5] if len(answers)>5 else 'Не указаны'}")

# ═══════════════════════════════════════════
#  MAIN
# ═══════════════════════════════════════════
async def main():
    init_db()
    async with aiohttp.ClientSession() as session:
        me = await tg(session, MANAGER_BOT_TOKEN, "getMe")
        if not me: log.error("❌ Проверь токен!"); return
        cmb = me.get("can_manage_bots", False)
        log.info(f"🤖 Менеджер: @{me.get('username')} | can_manage_bots: {cmb}")
        if not cmb: log.error("❌ Включи Managed Bots в @BotFather!"); return

        for b in db_get_all_bots():
            log.info(f"🔄 Восстанавливаю @{b['bot_username']}...")
            asyncio.create_task(run_child(session, b["bot_id"]))

        log.info("🟢 Polling запущен. Напиши /start боту.")
        offset = 0
        while True:
            try:
                updates = await tg(session, MANAGER_BOT_TOKEN, "getUpdates",
                    offset=offset, timeout=30,
                    allowed_updates=json.dumps(["message","callback_query","managed_bot"]))
                if not updates: continue
                for upd in updates:
                    offset = upd["update_id"] + 1
                    await handle_manager(session, upd)
            except KeyboardInterrupt: break
            except Exception as e: log.error(f"Manager: {e}"); await asyncio.sleep(3)

if __name__ == "__main__":
    print("""
    ╔════════════════════════════════════════╗
    ║  🪪 BOT-VIZITKA FACTORY v3           ║
    ║  Nano Banana 2 + Managed Bots 9.6    ║
    ║  Клуб Вайбкодеров | 2026             ║
    ╚════════════════════════════════════════╝
    """)
    asyncio.run(main())
ENDOFFILE