uzbekgpt/callbacks.py

import random

from aiogram import F
from aiogram.types import (
    CallbackQuery,
    InlineKeyboardButton,
    InlineKeyboardMarkup,
)

from commands import *
from config import *
from supergenerator import *


@router.callback_query(F.data.startswith("prov%"))
async def select_provider_callback(callback: CallbackQuery):
    current_user_id = str(callback.from_user.id)
    data = callback.data.split("%", 3)
    user_id, provider = data[1], data[2]

    if user_id != current_user_id:
        await callback.answer("не для тебя.")
        return

    config = get_user_config(user_id)
    user_model = config.get("model")

    buttons = []

    i = 0
    shown = set()

    for model in MODELS.get(provider):
        base_model = model.split("*")[0] if "*" in model else model
        if base_model in shown:
            continue
        shown.add(base_model)

        i += 1
        full_model = f"{provider}*{base_model}"
        if full_model == user_model or user_model.startswith(full_model + "*"):
            text = f"{base_model} ✅"
        else:
            text = base_model

        if MODELS[provider][model].get("alias"):
            base_model = MODELS[provider][model].get("alias")

        if not i % 2:
            buttons[len(buttons)-1] +=[
                InlineKeyboardButton(
                    text=text, callback_data=f"set_model%{user_id}%{provider}*{base_model}"
                )
            ]
        else:
            buttons.append(
                [
                    InlineKeyboardButton(
                        text=text, callback_data=f"set_model%{user_id}%{provider}*{base_model}"
                    )
                ]
            )

    if not buttons:
        buttons = [
            [
                InlineKeyboardButton(
                    text="🚫 нет моделей", callback_data=f"models%{user_id}", style="danger"
                )
            ]
        ]

    buttons.append(
        [InlineKeyboardButton(text="⬅️ назад", callback_data=f"models%{user_id}", style="primary")]
    )

    await callback.message.edit_text(
        f"выбран провайдер: {PROVIDERS.get(provider).get('name')}\nвыбери модель:",
        reply_markup=InlineKeyboardMarkup(inline_keyboard=buttons),
    )
    await callback.answer()


@router.callback_query(F.data.startswith("models%"))
async def models_callback(callback: CallbackQuery, alo=""):
    current_user_id = str(callback.from_user.id)
    if alo:
        data = alo.split("%", 1)
    else:
        data = callback.data.split("%", 1)
    user_id = data[1]
    if user_id == current_user_id:
        config = get_user_config(user_id)

        buttons = []

        i = 0

        if AUTO_MODEL and AUTO_MODELS:
            if config["model"] == "all*auto":
                buttons.append(
                    [InlineKeyboardButton(text="✅ автовыбор", callback_data=f"set_model%{user_id}%{DEFAULT_MODEL}", style="success")]
                )
            else:
                buttons.append(
                    [InlineKeyboardButton(text="😱 автовыбор", callback_data=f"set_model%{user_id}%all*auto", style="success")]
                )
        
        for provider in MODELS:
            i += 1
            if not i % 2:
                buttons[len(buttons)-1] +=[
                    InlineKeyboardButton(
                        text=PROVIDERS.get(provider).get("name"), 
                        callback_data=f"prov%{user_id}%{provider}"
                    )
                ]
            else:
                buttons.append(
                    [
                        InlineKeyboardButton(
                            text=PROVIDERS.get(provider).get("name"),
                            callback_data=f"prov%{user_id}%{provider}",
                        )
                    ]
                )

        if not buttons:
            buttons.append(
                [
                    InlineKeyboardButton(
                        text="🚫 нет провайдеров!", callback_data=f"settings%{user_id}", style="danger"
                    )
                ]
            )

        buttons.append(
            [InlineKeyboardButton(text="⬅️ назад", callback_data=f"settings%{user_id}", style="primary")]
        )

        await callback.message.edit_text(
            "выбери провайдера:",
            reply_markup=InlineKeyboardMarkup(inline_keyboard=buttons),
        )
        await callback.answer()
    else:
        await callback.answer("не тыкай. это не для тебя.")


@router.callback_query(F.data.startswith("set_model%"))
async def set_model_callback(callback: CallbackQuery):
    current_user_id = str(callback.from_user.id)
    data = callback.data.split("%", 2)
    user_id, new_model = data[1], data[2]
    provider = data[2].split("*", 1)[0]
    amodel = data[2].split("*", 1)[1]

    if amodel == "auto" and provider == "all":
        new_model = "all*auto"
    else:
        new_model = provider + "*" + amodel
        for model in MODELS.get(provider, {}):
            nmodel = MODELS[provider][model].get("alias") or None
            if nmodel == amodel:
                new_model = provider + "*" + model
                break
            
    if user_id == current_user_id:
        current_config = get_user_config(user_id)
        set_user_config(
            user_id, 
            new_model, 
            current_config.get("stream", True), 
            current_config.get("call"), 
            current_config.get("prompt"), 
            current_config.get("notify"),
            current_config.get("markdown"),
            current_config.get("prompts")
        )
        await callback.message.edit_text(
            f"выбрана модель: `{new_model}`", 
            reply_markup=InlineKeyboardMarkup(inline_keyboard=
                [
                    [InlineKeyboardButton(text="⬅️ назад", callback_data=f"models%{user_id}", style="primary")]
                ]
            )
        )
        await callback.answer(f"выбрано: {new_model}")
    else:
        await callback.answer("нет, не трогай")


@router.callback_query(F.data.startswith("prompts%"))
async def prompts_callback(callback: CallbackQuery):
    current_user_id = str(callback.from_user.id)
    data = callback.data.split("%", 1)
    user_id = data[1]
    if user_id == current_user_id:
        config = get_user_config(user_id)

        user_prompts_count = len(config["prompts"])
        system_prompts_count = len(SYSTEM_PROMPTS)
        
        buttons = [
            [
                InlineKeyboardButton(text=f"✅ стандартные промпты ({system_prompts_count})", callback_data=f"system_prompts%{user_id}"),
            ],
            [
                InlineKeyboardButton(text=f"🤝 твои промпты ({user_prompts_count})", callback_data=f"user_prompts%{user_id}"),
            ],
            [
                InlineKeyboardButton(text="⬅️ назад", callback_data=f"settings%{user_id}", style="primary"),
            ]
        ]

        await callback.message.edit_text(
            "da:",
            reply_markup=InlineKeyboardMarkup(inline_keyboard=buttons),
        )
        await callback.answer()
    else:
        await callback.answer("не тыкай. это не для тебя.")


@router.callback_query(F.data.startswith("vps%"))
async def view_system_prompt_callback(callback: CallbackQuery, dataalo=""):
    current_user_id = str(callback.from_user.id)
    if dataalo != "":
        data = dataalo
    else:
        data = callback.data

    data = data.split("%", 3)
        
    user_id = data[1]
    prompt_id = data[2]
    if user_id != current_user_id:
        await callback.answer("pashol naxxuy")
        return
    
    config = get_user_config(user_id)
    prompt = config.get("prompt", "")

    if prompt_id in SYSTEM_PROMPTS:
        p = SYSTEM_PROMPTS.get(prompt_id)
    else:
        await callback.answer("не нашёл такого промпта!")
        return

    prompt_name = p.get("name")
    prompt_text = p.get("text")

    if prompt == prompt_id:
        prompt_apply_t = "✅ установлен"
    else:
        prompt_apply_t = "✅ установить"        

    buttons = [
        [
            InlineKeyboardButton(text=prompt_apply_t, callback_data=f"sp%{user_id}%0%{prompt_id}%3"),
        ],
        [
            InlineKeyboardButton(text="⬅️ назад", callback_data=f"system_prompts%{user_id}", style="primary"),
        ]
    ]

    await callback.message.edit_text(
        f"название: `{prompt_name}`\n"
        f"id: `{prompt_id}`\n"
        f"```prompt\n{prompt_text}\n```",
        reply_markup=InlineKeyboardMarkup(inline_keyboard=buttons),
    )
    await callback.answer()



@router.callback_query(F.data.startswith("vp%"))
async def view_prompt_callback(callback: CallbackQuery, dataalo=""):
    current_user_id = str(callback.from_user.id)
    if dataalo != "":
        data = dataalo
    else:
        data = callback.data
    data = data.split("%", 2)
    user_id = data[1]
    prompt_id = data[2]
    if user_id != current_user_id:
        await callback.answer("pashol naxxuy")
        return
    
    config = get_user_config(user_id)
    prompt = config.get("prompt", "")
    prompts = config.get("prompts", {})

    if prompt_id in prompts:
        p = prompts.get(prompt_id)
    else:
        await callback.answer("промпта нет у тебя такого")
        return

    prompt_pub = p.get("public")
    prompt_f = p.get("filer")
    prompt_name = p.get("name")

    if prompt == prompt_id:
        prompt_apply_t = "✅ установлен"
    else:
        prompt_apply_t = "✅ установить"        

    if prompt_pub:
        prompt_pub_t = "✅ публичный"
        prompt_pub_t2 = "🚫 сделать приватным"
    else:
        prompt_pub_t = "🚫 приватный"
        prompt_pub_t2 = "✅ сделать публичным"

    if prompt_f:
        prompt_f_t = "как файл"
    else:
        prompt_f_t = "как сообщение"

    buttons = [
        [
            InlineKeyboardButton(text="✏️ изменить", callback_data=f"ed%{user_id}%{prompt_id}"),
            InlineKeyboardButton(text="❌ удалить", callback_data=f"dp%{user_id}%{prompt_id}"),
            
        ],
        [
            InlineKeyboardButton(text=prompt_pub_t2, callback_data=f"eds%{user_id}%{prompt_id}"),
            InlineKeyboardButton(text=f"📂 {prompt_f_t}", callback_data=f"edf%{user_id}%{prompt_id}"),
        ],
        [
            InlineKeyboardButton(text="💬 текст", callback_data=f"vt%{user_id}%{prompt_id}"),
            InlineKeyboardButton(text=prompt_apply_t, callback_data=f"sp%{user_id}%0%{prompt_id}%1"),
        ],
        [
            InlineKeyboardButton(text="⬅️ назад", callback_data=f"user_prompts%{user_id}", style="primary"),
        ]
    ]

    try:
        await callback.message.edit_text(
            f"название: `{prompt_name}`\n"
            f"id: `{prompt_id}`\n"
            f"url: `t.me/{BOT_USERNAME}?start=prompt-{user_id}-{prompt_id}`\n"
            f"отправка: `{prompt_f_t}`\n"
            f"статус: `{prompt_pub_t}`\n",
            reply_markup=InlineKeyboardMarkup(inline_keyboard=buttons),
        )
    except:
        pass
    await callback.answer()



@router.callback_query(F.data.startswith("user_prompts%"))
async def user_prompts_callback(callback: CallbackQuery, dataalo=""):
    current_user_id = str(callback.from_user.id)
    if dataalo != "":
        data = dataalo
    else:
        data = callback.data

    data = data.split("%", 1)
    
    user_id = data[1]
    if user_id == current_user_id:
        config = get_user_config(user_id)
        prompt = config.get("prompt", "")
        prompts = config.get("prompts", {})

        buttons = []
        i = 0
        
        for name in prompts:
            alo = name
            name = prompts[name].get("name") + " (" + alo[:4] + ")"
            i += 1
            text = name
            if prompt == alo:
                text += " ✅"

            if not i % 2:
                buttons[len(buttons)-1] +=[
                    InlineKeyboardButton(
                        text=f"{text}",
                        callback_data=f"vp%{user_id}%{alo}"
                    )
                ]
            else:
                buttons.append(
                    [
                        InlineKeyboardButton(
                            text=f"{text}",
                            callback_data=f"vp%{user_id}%{alo}",
                        )
                    ]
                )

        if not buttons:
            buttons.append(
                [
                    InlineKeyboardButton(
                        text="🚫 нет промптов!", callback_data=f"prompts%{user_id}", style="danger"
                    )
                ]
            )

        buttons.append(
            [
                InlineKeyboardButton(text="⬅️ назад", callback_data=f"prompts%{user_id}", style="primary"),
                InlineKeyboardButton(text="📝 создать", callback_data=f"create%{user_id}", style="primary"),
            ]
        )

        await callback.message.edit_text(
            "выбери пользовательский системный промпт:",
            reply_markup=InlineKeyboardMarkup(inline_keyboard=buttons),
        )
        await callback.answer()
    else:
        await callback.answer("не тыкай. это не для тебя.")


@router.callback_query(F.data.startswith("p_cancel%"))
async def cancel_prompt_callback(callback: CallbackQuery):
    current_user_id = str(callback.from_user.id)
    data = callback.data.split("%", 1)
    user_id = data[1]
    if user_id != current_user_id:
        return await callback.answer("pashol naxxuy. иди наxuy.")

    alo_command[int(user_id)] = {"action": None, "chat_id": callback.message.chat.id, "message_id": callback.message.message_id}

    await user_prompts_callback(callback, dataalo=f"user_prompts%{user_id}")


@router.callback_query(F.data.startswith("vt%"))
async def view_text_callback(callback: CallbackQuery, dataalo=""):
    current_user_id = str(callback.from_user.id)
    if dataalo != "":
        data = dataalo
    else:
        data = callback.data

    data = data.split("%", 2)
        
    user_id = data[1]
    prompt_id = data[2]
    if user_id != current_user_id:
        await callback.answer("нет, не трогай это не твое")
        return

    config = get_user_config(user_id)
    
    prompts = config["prompts"]

    prompt = prompts.get(prompt_id)
    

    buttons = [
        [
            InlineKeyboardButton(
                text="⬅️ назад", callback_data=f"vp%{user_id}%{prompt_id}", style="primary"
            )
        ]
    ]

    await callback.message.edit_text(
        f"текст промпта `{prompt['name']}`:\n```prompt\n{prompt['text'][:3980]}\n```",
        reply_markup=InlineKeyboardMarkup(inline_keyboard=buttons),
    )


@router.callback_query(F.data.startswith("dp%"))
async def delete_prompt_callback(callback: CallbackQuery, dataalo=""):
    current_user_id = str(callback.from_user.id)
    if dataalo != "":
        data = dataalo
    else:
        data = callback.data

    data = data.split("%", 2)
        
    user_id = data[1]
    prompt_id = data[2]
    if user_id != current_user_id:
        await callback.answer("нет, не трогай это не твое")
        return

    config = get_user_config(user_id)
    
    prompts = config["prompts"]

    del prompts[prompt_id]
    
    new_prompts = prompts
        
    set_user_config(
        user_id, 
        config.get("model"), 
        config.get("stream"), 
        config.get("call"), 
        DEFAULT_PROMPT,
        config.get("notify"),
        config.get("markdown"),
        new_prompts
    )

    return await user_prompts_callback(callback, dataalo=f"0%{user_id}")


@router.callback_query(F.data.startswith("edf%"))
async def edit_filer_callback(callback: CallbackQuery, dataalo=""):
    current_user_id = str(callback.from_user.id)
    if dataalo != "":
        data = dataalo
    else:
        data = callback.data

    data = data.split("%", 2)
        
    user_id = data[1]
    prompt_id = data[2]
    if user_id != current_user_id:
        await callback.answer("нет, не трогай это не твое")
        return

    config = get_user_config(user_id)
    
    prompts = config["prompts"]

    prompt = prompts.get(prompt_id)

    if prompt["filer"]:
        prompt["filer"] = False
    else:
        prompt["filer"] = True
    
    new_prompts = prompts | {prompt_id: prompt}
        
    set_user_config(
        user_id, 
        config.get("model"), 
        config.get("stream"), 
        config.get("call"), 
        config.get("prompt"),
        config.get("notify"),
        config.get("markdown"),
        new_prompts
    )

    return await view_prompt_callback(callback, dataalo=f"0%{user_id}%{prompt_id}")

@router.callback_query(F.data.startswith("eds%"))
async def edit_status_callback(callback: CallbackQuery, dataalo=""):
    current_user_id = str(callback.from_user.id)
    if dataalo != "":
        data = dataalo
    else:
        data = callback.data

    data = data.split("%", 2)
        
    user_id = data[1]
    prompt_id = data[2]
    if user_id != current_user_id:
        await callback.answer("нет, не трогай это не твое")
        return

    config = get_user_config(user_id)
    
    prompts = config["prompts"]

    prompt = prompts.get(prompt_id)

    if prompt["public"]:
        prompt["public"] = False
    else:
        prompt["public"] = True
    
    new_prompts = prompts | {prompt_id: prompt}
        
    set_user_config(
        user_id, 
        config.get("model"), 
        config.get("stream"), 
        config.get("call"), 
        config.get("prompt"),
        config.get("notify"),
        config.get("markdown"),
        new_prompts
    )

    return await view_prompt_callback(callback, dataalo=f"0%{user_id}%{prompt_id}")


@router.callback_query(F.data.startswith("edn%"))
async def edit_prompt_name_callback(callback: CallbackQuery):
    current_user_id = str(callback.from_user.id)
    data = callback.data.split("%", 2)
    user_id = data[1]
    prompt_id = data[2]
    if user_id != current_user_id:
        return await callback.answer("pashol naxxuy. иди наxuy.")

    config = get_user_config(user_id)

    buttons = [
        [
            InlineKeyboardButton(
                text="❌ отменить", callback_data=f"p_cancel%{user_id}", style="danger"
            )
        ]
    ]

    alo_command[int(user_id)] = {"action": "p_e_name", "chat_id": callback.message.chat.id, "message_id": callback.message.message_id, "prompt_id": prompt_id}

    await callback.message.edit_text(
        "установи новое название:",
        reply_markup=InlineKeyboardMarkup(inline_keyboard=buttons),
    )


@router.callback_query(F.data.startswith("edp%"))
async def edit_prompt_prompt_callback(callback: CallbackQuery):
    current_user_id = str(callback.from_user.id)
    data = callback.data.split("%", 2)
    user_id = data[1]
    prompt_id = data[2]
    if user_id != current_user_id:
        return await callback.answer("pashol naxxuy. иди наxuy.")

    config = get_user_config(user_id)

    buttons = [
        [
            InlineKeyboardButton(
                text="❌ отменить", callback_data=f"p_cancel%{user_id}", style="danger"
            )
        ]
    ]

    alo_command[int(user_id)] = {"action": "p_e_prompt", "chat_id": callback.message.chat.id, "message_id": callback.message.message_id, "prompt_id": prompt_id}

    await callback.message.edit_text(
        "установи новый промпт:",
        reply_markup=InlineKeyboardMarkup(inline_keyboard=buttons),
    )


@router.callback_query(F.data.startswith("ed%"))
async def edit_prompt_callback(callback: CallbackQuery):
    current_user_id = str(callback.from_user.id)
    data = callback.data.split("%", 2)
    user_id = data[1]
    prompt_id = data[2]
    if user_id != current_user_id:
        return await callback.answer("pashol naxxuy. иди наxuy.")

    config = get_user_config(user_id)

    buttons = [
        [
            InlineKeyboardButton(
                text="💬 промпт", callback_data=f"edp%{user_id}%{prompt_id}"
            ),
            InlineKeyboardButton(
                text="📝 название", callback_data=f"edn%{user_id}%{prompt_id}"
            ),
        ],
        [
            InlineKeyboardButton(
                text="⬅️ назад", callback_data=f"vp%{user_id}%{prompt_id}", style="primary"
            ),
        ]
    ]

    alo_command[int(user_id)] = {"action": "p_e_name", "chat_id": callback.message.chat.id, "message_id": callback.message.message_id, "prompt_id": prompt_id}

    await callback.message.edit_text(
        "установи новый промпт:",
        reply_markup=InlineKeyboardMarkup(inline_keyboard=buttons),
    )


@router.callback_query(F.data.startswith("create%"))
async def create_prompt_callback(callback: CallbackQuery):
    current_user_id = str(callback.from_user.id)
    data = callback.data.split("%", 1)
    user_id = data[1]
    if user_id != current_user_id:
        return await callback.answer("pashol naxxuy. иди наxuy.")

    config = get_user_config(user_id)
    if len(config["prompts"]) >= MAX_PROMPTS:
        return await callback.answer("ты превысил максимальное количество промптов!!!")

    buttons = [
        [
            InlineKeyboardButton(
                text="❌ отменить", callback_data=f"p_cancel%{user_id}", style="danger"
            )
        ]
    ]

    alo_command[int(user_id)] = {"action": "p_name", "chat_id": callback.message.chat.id, "message_id": callback.message.message_id}

    await callback.message.edit_text(
        "установи отображаемое имя промпта:",
        reply_markup=InlineKeyboardMarkup(inline_keyboard=buttons),
    )


@router.callback_query(F.data.startswith("system_prompts%"))
async def system_prompts_callback(callback: CallbackQuery):
    current_user_id = str(callback.from_user.id)
    data = callback.data.split("%", 1)
    user_id = data[1]
    if user_id == current_user_id:
        config = get_user_config(user_id)
        prompt  = config.get("prompt")

        buttons = []
        i = 0
        
        for name in SYSTEM_PROMPTS:
            alo = name
            name = SYSTEM_PROMPTS[name].get("name")
            i += 1
            text = name
            if prompt == alo:
                text += " ✅"

            if not i % 2:
                buttons[len(buttons)-1] +=[
                    InlineKeyboardButton(
                        text=text, 
                        callback_data=f"vps%{user_id}%{alo}"
                    )
                ]
            else:
                buttons.append(
                    [
                        InlineKeyboardButton(
                            text=text,
                            callback_data=f"vps%{user_id}%{alo}",
                        )
                    ]
                )

        if not buttons:
            buttons.append(
                [
                    InlineKeyboardButton(
                        text="🚫 нет промптов!", callback_data=f"prompts%{user_id}", style="danger"
                    )
                ]
            )

        buttons.append(
            [
                InlineKeyboardButton(text="⬅️ назад", callback_data=f"prompts%{user_id}", style="primary"),
            ]
        )

        await callback.message.edit_text(
            "выбери системный промпт:",
            reply_markup=InlineKeyboardMarkup(inline_keyboard=buttons),
        )
        await callback.answer()
    else:
        await callback.answer("не тыкай. это не для тебя.")



@router.callback_query(F.data.startswith("sp%"))
async def set_prompt_callback(callback: CallbackQuery):
    # КАЛбек: sp%айди%промпт_айди%промпт%тип
    # 0 - answer + настройки
    # 1 - answer + открыть prompt view
    # 2 - answer
    # 3 - answer + открыть system prompt view
    
    current_user_id = str(callback.from_user.id)
    data = callback.data.split("%", 4)
    user_id = data[1]
    prompt_user_id = int(data[2])
    msg_type = 0
    new_status = data[3]
    
    if len(data) == 5:
        msg_type = int(data[4])
        
    if user_id != current_user_id:
        await callback.answer("нет, не трогай это не твое")
        return

    
            
    config = get_user_config(user_id)

    if prompt_user_id != 0:
        if len(config["prompts"]) >= MAX_PROMPTS:
            return await callback.answer("достигнуто максимальное количество промптов врат")
        else:
            await add_prompt_callback(callback, f"0%{user_id}%{prompt_user_id}%{data[3]}", alo=False)
    
    set_user_setting(
        user_id,  
        prompt=new_status, 
        prompts=get_user_config(user_id).get("prompts")
    )
    
    if msg_type == 0:
        await callback.answer("da поменял на " + new_status)
        await settings_handler(callback)
    elif msg_type == 1:
        await callback.answer("установил промпт " + new_status)
        await view_prompt_callback(callback, dataalo=f"0%{user_id}%{new_status}")
    elif msg_type == 2:
        await callback.answer("установил " + new_status)
    elif msg_type == 3:
        await callback.answer("установил промпт " + new_status)
        await view_system_prompt_callback(callback, dataalo=f"0%{user_id}%{new_status}")


@router.callback_query(F.data.startswith("ap%"))
async def add_prompt_callback(callback: CallbackQuery, dataalo="", alo=True):
    current_user_id = str(callback.from_user.id)
    if dataalo != "":
        data = dataalo
    else:
        data = callback.data

    data = data.split("%", 3)
        
    user_id = data[1]
    prompt_user_id = int(data[2])
    if user_id != current_user_id:
        await callback.answer("нет, не трогай это не твое")
        return

    if prompt_user_id == 0:
        return await callback.answer("это стандартный промпт suka.")

    config = get_user_config(user_id)

    if len(config["prompts"]) >= MAX_PROMPTS:
        return await callback.answer("достигнуто максимальное количество промптов врат")
    
    new_prompts = config["prompts"]

    prompt = get_user_config(prompt_user_id)["prompts"].get(data[3], {})
    if not prompt:
        return await callback.answer("pashol naxxuy промпта нет")
    prompt_pub = prompt.get("public", False)
    if not prompt_pub: 
        return await callback.answer("pashol naxxuy промпт стал приватным")
    new_prompt = prompt
    new_prompt["public"] = False
    new_prompts = new_prompts | {data[3]: new_prompt}

    set_user_setting(
        user_id, 
        prompts=new_prompts
    )

    if alo:
        return await callback.answer("добавил твой промпт da.")


@router.callback_query(F.data.startswith("settings%"))
async def settings_callback(callback: CallbackQuery):
    current_user_id = str(callback.from_user.id)
    data = callback.data.split("%", 1)
    user_id = data[1]
    if user_id != current_user_id:
        await callback.answer("нет, не трогай")
        return

    await settings_handler(callback)


@router.callback_query(F.data.startswith("set%"))
async def set_setting_callback(callback: CallbackQuery):
    current_user_id = str(callback.from_user.id)
    data = callback.data.split("%", 3)
    user_id = data[2]
    if user_id != current_user_id:
        await callback.answer("нет, не трогай это не твое")
        return

    new_status = callback.data.split("%")[3]

    config = get_user_config(user_id)

    alo = {
        data[1]: new_status
    }
    
    set_user_setting(
        user_id, 
        **alo
    )
    await settings_handler(callback)


@router.callback_query(F.data.startswith("new_md%"))
async def set_markdown_callback(callback: CallbackQuery, message=None):
    current_user_id = str(callback.from_user.id)
    data = callback.data.split("%", 2)
    user_id = data[1]
    if user_id != current_user_id:
        await callback.answer("нет, не трогай это не твое")
        return
    config = get_user_config(user_id)
    set_user_setting(
        user_id, 
        markdown="new"
    )
    if message:
        await message.delete()
    await callback.answer("выбран новый стиль!!")
    await callback.message.delete()


@router.callback_query(F.data.startswith("old_md%"))
async def set_markdown_callback(callback: CallbackQuery, message=None):
    current_user_id = str(callback.from_user.id)
    data = callback.data.split("%", 2)
    user_id = data[1]
    if user_id != current_user_id:
        await callback.answer("нет, не трогай это не твое")
        return
    config = get_user_config(user_id)
    set_user_setting(
        user_id, 
        markdown="old"
    )
    if message:
        await message.delete()
    await callback.answer("выбран старый стиль!!")
    await callback.message.delete()


@router.callback_query(F.data == "start")
async def start_callback(callback: CallbackQuery):
    await callback.message.edit_text(
        "✅ я рад что вас заинтересовать✅✅ а теперь напише любое сообщение и свободный узбек вам ответит✅\n\n"
        "/start - ага старт\n"
        "/clear - очистить контекст✅\n"
        "/settings - настройки✅\n"
        "/prompt - системный промпт узбека"
    )
    await callback.answer()


@router.callback_query(F.data.startswith("about%"))
async def about_callback(callback: CallbackQuery):
    current_user_id = str(callback.from_user.id)
    data = callback.data.split("%", 1)
    user_id = data[1]
    if user_id != current_user_id:
        await callback.answer("нет, не трогай")
        return

    buttons = [
        [InlineKeyboardButton(text="назад", callback_data=f"settings%{user_id}", style="primary")]
    ]

    await callback.message.edit_text(
        ABOUT_BOT,
        reply_markup=InlineKeyboardMarkup(inline_keyboard=buttons),
    )

    await callback.answer()


@router.callback_query(F.data.startswith("donate%"))
async def donate_callback(callback: CallbackQuery):
    current_user_id = str(callback.from_user.id)
    data = callback.data.split("%", 1)
    user_id = data[1]
    if user_id != current_user_id:
        await callback.answer("нет, не трогай")
        return

    buttons = [
        [InlineKeyboardButton(text="назад", callback_data=f"settings%{user_id}", style="primary")],
    ]

    await callback.message.edit_text(
        "слушай сюда✅ если хочешь чтобы я не сдох от голода и не начал "
        "писать на китайском✅ кидай сюда монеты👍\n\n"
        "наполни чан узбекгпта на плов✅ а то мозги скрипят как старый таган ✅\n\n"
        "ссылка внизу👍 whoever хочет быть красавчиком✅ кидай сколько не жалко👍\n\n"
        f"{DONATE_LINK}",
        reply_markup=InlineKeyboardMarkup(inline_keyboard=buttons),
    )

    await callback.answer()


@router.callback_query(F.data.startswith("gset%"))
async def group_set_callback(callback: CallbackQuery):
    current_user_id = str(callback.from_user.id)
    data = callback.data.split("%", 4)
    group_id, user_id, key, val = data[1], data[2], data[3], data[4]
    if user_id != current_user_id:
        await callback.answer("нет, не трогай это не для тебя")
        return

    if key in ["post_reply", "polls", "lurk"]:
        set_group_setting(group_id, **{key: val})
    elif key in ["lurk_chance", "lurk_reply_chance"]:
        g_config = get_group_config(group_id)
        new_val = g_config[key] + int(val)
        max_val = 30 if key == "lurk_chance" else 10
        if new_val < 0:
            new_val = 0
        if new_val > max_val:
            new_val = max_val
        set_group_setting(group_id, **{key: new_val})

    await group_settings_handler(callback, dataalo=f"group%{group_id}")


@router.callback_query(F.data.startswith("gpost%"))
async def group_post_prompt_callback(callback: CallbackQuery):
    current_user_id = str(callback.from_user.id)
    data = callback.data.split("%", 2)
    group_id, user_id = data[1], data[2]
    if user_id != current_user_id:
        await callback.answer("нет, не трогай это не для тебя")
        return

    alo_command[int(user_id)] = {"action": "g_prompt", "chat_id": callback.message.chat.id, "message_id": callback.message.message_id, "group_id": group_id}

    await callback.message.edit_text(
        "установи промпт для ответов на посты канала (просто текст):",
        reply_markup=InlineKeyboardMarkup(
            inline_keyboard=[
                [
                    InlineKeyboardButton(text="❌ отменить", callback_data=f"gcancel%{group_id}%{user_id}", style="danger")
                ]
            ]
        ),
    )
    await callback.answer()


@router.callback_query(F.data.startswith("gcancel%"))
async def group_cancel_callback(callback: CallbackQuery):
    current_user_id = str(callback.from_user.id)
    data = callback.data.split("%", 2)
    group_id, user_id = data[1], data[2]
    if user_id != current_user_id:
        await callback.answer("нет, не трогай это не для тебя")
        return

    alo_command[int(user_id)] = {"action": None, "chat_id": callback.message.chat.id, "message_id": callback.message.message_id}

    await group_settings_handler(callback, dataalo=f"group%{group_id}")


def build_call_menu(user_id):
    config = get_user_config(user_id)
    calling = config.get("calling") or []
    calling_dots = ""
    call_dots = ""

    if config["call"] == "da":
        call_status = "✅"
        call_status2 = "вкл"
        call_style = "success"
        call_cb = "net"
    else:
        call_status = "❌"
        call_status2 = "выкл"
        call_style = "danger"
        call_cb = "da"

    # хуй хуй хуй
    # сиськам сись писькам пись

    if calling == []:
        calling_status = "свои слова отклика ->"
        calling_status2 = ["✅", ""]
    else:
        calling_status = ", ".join(calling)[:35]
        calling_status2 = ["", "✅"]

    if len(", ".join(calling)) > 35:
        calling_dots = "..."

    if len(", ".join(BOT_CALLS)) > 35:
        call_dots = "..."

    buttons = [
        [
            InlineKeyboardButton(
                text=f"{call_status} отклик на слова: {call_status2} {call_status}",
                callback_data=f"set%call%{user_id}%{call_cb}",
                style=call_style
            ),
        ],
    ]

    if config["call"] == "da":
        buttons += [
            [InlineKeyboardButton(
                text=f"{calling_status2[0]} {', '.join(BOT_CALLS)[:35]}{call_dots}",
                callback_data=f"scall%{user_id}%1")
            ],
            [InlineKeyboardButton(
                text=f"{calling_status2[1]} {calling_status}{calling_dots}",
                callback_data=f"scall%{user_id}%0")
            ],
        ]

    buttons += [
        [
            InlineKeyboardButton(
                text="⬅️ назад",
                callback_data=f"settings%{user_id}",
                style="primary"
            )
        ]
    ]

    return (
        "меню выбора на что звать меня дорогой друг",
        InlineKeyboardMarkup(inline_keyboard=buttons),
    )


@router.callback_query(F.data.startswith("call%"))
async def call_callback(callback: CallbackQuery):
    data = callback.data.split("%", 1)
    user_id = data[1]
    if user_id != str(callback.from_user.id):
        await callback.answer("прости но нет")
        return

    text, keyboard = build_call_menu(user_id)

    await callback.message.edit_text(text, reply_markup=keyboard)

    await callback.answer()


@router.callback_query(F.data.startswith("scall%"))
async def scall_callback(callback: CallbackQuery):
    # чем выше забор, тем ниже плинтус
    data = callback.data.split("%", 2)
    user_id = data[1]
    call_type = data[2]
    if user_id != str(callback.from_user.id):
        await callback.answer("прости но нет")
        return

    if call_type == "1":
        set_user_setting(user_id, calling=[])
        text, keyboard = build_call_menu(user_id)
        await callback.message.edit_text(text, reply_markup=keyboard)
        await callback.answer("✅ слова отклика сброшены на стандартные")
        return

    alo_command[int(user_id)] = {
        "action": "calling",
        "chat_id": callback.message.chat.id,
        "message_id": callback.message.message_id,
    }

    buttons = [
        [
            InlineKeyboardButton(
                text="⬅️ назад",
                callback_data=f"call%{user_id}",
                style="primary"
            )
        ]
    ]

    await callback.message.edit_text( # 7 раз измерь 1 хуй неправильно
        "напиши слова для отклика узбекгпт через запятую ✅:",
        reply_markup=InlineKeyboardMarkup(inline_keyboard=buttons),
    )

    await callback.answer()