bot.py

import logging
import asyncio
import json
import re
import time
import os
import sqlite3
from functools import partial
from telethon import TelegramClient, events, Button
from telethon.errors.rpcerrorlist import QueryIdInvalidError

import bot_state
from modules.reformer import *
from modules.keyboardbuilder import *
from modules.articlesbuilder import *
from modules.parserengine import inlineq, googler
from modules.config import *
from modules.utils import getban
from modules.fuzzengine import load_data as reload_fuzz_index, fuzzsearch as local_fuzz_search
from modules.db import (
    get_device_by_id,
    create_device_submission,
    list_pending_submissions,
    get_device_submission,
    update_submission_status,
    update_submission_data,
    save_device,
    add_role,
    remove_role,
    get_user_roles,
    get_role_users,
    is_device_stale_for_update
)

logging.basicConfig(level=logging.INFO)
BASE_DIR = os.path.dirname(os.path.abspath(__file__))

def _build_session_name():
    base = os.getenv('TELETHON_SESSION')
    if base:
        return base
    return 'gsmarbot_session_test' if TESTING else 'gsmarbot_session'

def _start_telegram_client():
    require_telegram_settings()
    session_name = _build_session_name()
    try:
        return TelegramClient(session_name, API_ID, API_HASH).start(bot_token=TOKEN)
    except sqlite3.OperationalError as e:
        if "database is locked" not in str(e).lower():
            raise
        fallback_session = f"{session_name}_{os.getpid()}"
        logging.warning(
            "Telethon session '%s' is locked. Retrying with fallback session '%s'.",
            session_name,
            fallback_session
        )
        return TelegramClient(fallback_session, API_ID, API_HASH).start(bot_token=TOKEN)

client = _start_telegram_client()

class TextManager:
    def __init__(self, path=None):
        self.locales = {}
        path = path or os.path.join(BASE_DIR, 'misc', 'locales.json')
        try:
            with open(path, 'r', encoding='utf-8') as f:
                self.locales = json.load(f)
        except (FileNotFoundError, json.JSONDecodeError):
            self.locales = {}

    def get_user_lang(self, uid, tele_lang=None):
        sett = bot_state.get_sett(uid)
        db_lang = sett[8] if sett and len(sett) > 8 else 'None'
        if db_lang != 'None' and db_lang in self.locales: return db_lang
        if tele_lang == 'ru': return 'ru'
        return 'en'

    def get(self, key, uid, tele_lang=None, **kwargs):
        lang = self.get_user_lang(uid, tele_lang)
        text = self.locales.get(lang, self.locales.get('en', {})).get(key, key)
        try:
            return text.format(**kwargs)
        except (KeyError, IndexError, ValueError):
            return text

tm = TextManager()

ADMIN_ROLE = 'admin'
SUBMIT_STATE = 2
UPDATING_DEVICE_IDS = set()
DEFAULT_SETTINGS = [1, 0, None, 0, 0, 1, 0, 0, 'None', 1]
INLINE_LOCAL_TIMEOUT = 0.35
INLINE_SEARCH_TIMEOUT = 3.5
INLINE_FETCH_TIMEOUT = 3.0
INLINE_FETCH_LIMIT = 3

def _with_powered_by(text, uid, tele_lang=None):
    footer = tm.get('powered_by', uid, tele_lang, source_url=SOURCE_REPOSITORY)
    return f"{text}\n\n{footer}"

def _next_forced_lang(uid):
    sett = bot_state.get_sett(uid)
    current = sett[8] if sett and len(sett) > 8 else 'None'
    try:
        curr_idx = languages.index(current)
    except ValueError:
        curr_idx = 0
    return languages[(curr_idx + 1) % len(languages)]

async def _refresh_settings_message(event, uid, tele_lang):
    ui_lang = tm.get_user_lang(uid, tele_lang)
    kb = build_settru(uid) if ui_lang == 'ru' else build_setten(uid)
    await event.edit(_with_powered_by(tm.get('settings_header', uid, tele_lang), uid, tele_lang),
                     buttons=kb,
                     parse_mode='html')

async def _run_blocking(func, *args, timeout=None, default=None, **kwargs):
    loop = asyncio.get_running_loop()
    bound = partial(func, *args, **kwargs)
    try:
        future = loop.run_in_executor(None, bound)
        if timeout is not None:
            return await asyncio.wait_for(future, timeout)
        return await future
    except asyncio.TimeoutError:
        logging.warning("%s timed out after %.2fs", getattr(func, '__name__', repr(func)), timeout)
    except Exception:
        logging.exception("%s failed", getattr(func, '__name__', repr(func)))
    return default

async def _safe_answer_inline(event, results, uid, tele_lang):
    lang = tm.get_user_lang(uid, tele_lang)
    pm = PMTEXT_RU if lang == 'ru' else PMTEXT_EN
    try:
        await event.answer(results, switch_pm=pm, switch_pm_param="start")
    except QueryIdInvalidError:
        logging.warning("Inline query expired before answer for uid=%s, query=%r", uid, event.text)

def _escape_html(text):
    if text is None:
        return ''
    return (str(text)
            .replace('&', '&')
            .replace('<', '&lt;')
            .replace('>', '&gt;'))

def _truncate(text, limit=2000):
    if not text:
        return ''
    return text if len(text) <= limit else (text[:limit - 3] + '...')

def _is_admin(uid):
    return ADMIN_ROLE in get_user_roles(uid)

def _has_any_admin():
    return len(get_role_users(ADMIN_ROLE)) > 0

def _get_submission_notify_targets():
    targets = list(get_role_users(ADMIN_ROLE))
    deduped = []
    seen = set()
    for target in targets:
        try:
            normalized = int(target)
        except Exception:
            continue
        if normalized in seen:
            continue
        seen.add(normalized)
        deduped.append(normalized)
    return deduped

def _parse_submission_text(raw_text):
    cleaned = raw_text.strip()
    lines = [ln.strip() for ln in cleaned.splitlines() if ln.strip()]
    title = lines[0] if lines else cleaned[:80] if cleaned else "Unknown device"
    links = re.findall(r'https?://\\S+', cleaned)
    data = {
        "title": title,
        "links": links
    }
    return title, data

def _normalize_submission_to_spec(raw_text, sub_id):
    cleaned = (raw_text or '').strip()
    lines = [ln.strip() for ln in cleaned.splitlines() if ln.strip()]
    title = lines[0] if lines else "Unknown device"

    urls = re.findall(r'https?://\\S+', cleaned)
    img_url = ''
    for url in urls:
        lower = url.lower()
        if any(lower.endswith(ext) for ext in ('.jpg', '.jpeg', '.png', '.webp')):
            img_url = url
            break

    def find_value(keys):
        for line in lines:
            for key in keys:
                prefix = key.lower() + ':'
                if line.lower().startswith(prefix):
                    return line.split(':', 1)[1].strip()
                prefix = key.lower() + ' -'
                if line.lower().startswith(prefix):
                    return line.split('-', 1)[1].strip()
        return ''

    def find_list_value(keys):
        val = find_value(keys)
        if not val:
            return []
        parts = re.split(r'[;,]\\s*|\\s+\\+\\s+', val)
        parts = [p.strip() for p in parts if p.strip()]
        return parts if parts else [val]

    status = find_value(['status', 'статус'])
    os_val = find_value(['os', 'операционная система', 'система'])
    cpu_arch = find_value(['cpu arch', 'cpu architecture', 'архитектура', 'ядра'])
    cpu = find_value(['cpu', 'chipset', 'процессор', 'чипсет'])
    gpu = find_value(['gpu', 'гп'])
    memory = find_value(['memory', 'ram', 'память'])
    screen = find_value(['screen', 'display', 'экран'])
    screenmod = find_value(['screenmod', 'display other', 'доп. экран', 'экран доп', 'особенности экрана'])
    battery = find_value(['battery', 'аккумулятор', 'батарея'])
    colors = find_value(['colors', 'color', 'цвета', 'цвет'])
    sim = find_value(['sim', 'сим', 'сим-карта', 'симкарта'])
    wifi = find_value(['wifi', 'wi-fi', 'вайфай'])
    bluetooth = find_value(['bluetooth', 'bt', 'блютуз'])
    cameras = find_list_value(['cameras', 'camera', 'камера', 'камеры'])
    selfie = find_list_value(['selfie', 'front camera', 'фронталка', 'фронтальная камера'])
    cameravid = find_value(['camera video', 'video', 'видео камеры', 'видео'])
    selfievid = find_value(['selfie video', 'front video', 'видео фронт', 'видео фронталки'])
    models = find_value(['models', 'model', 'модели', 'модель'])

    if not status:
        status = "User submitted"

    if not cameras:
        cameras = ["Not specified"]
    if not selfie:
        selfie = ["Not specified"]

    if not cpu and lines:
        for line in lines[1:]:
            if len(line) > 6 and not line.startswith(('http://', 'https://')):
                cpu = cpu or line
                break

    descr_left = screen if screen else "User submitted device"
    descr_right = cpu if cpu else "Specs not provided"
    descr = f"{descr_left} | {descr_right}"

    spec = {
        "link": f"https://gsmarbot.ru/submitted?id={sub_id}",
        "infodate": str(int(time.time())),
        "id": f"sub_{sub_id}",
        "title": title,
        "status": status,
        "OS": os_val or "Not specified",
        "cpuArch": cpu_arch or "Not specified",
        "CPU": cpu or "Not specified",
        "GPU": gpu or "Not specified",
        "memory": memory or "Not specified",
        "descr": descr,
        "screen": screen or "Not specified",
        "screenmod": screenmod or "",
        "battery": battery or "Not specified",
        "colors": colors or "Not specified",
        "sim": sim or "Not specified",
        "wifi": wifi or "Not specified",
        "bluetooth": bluetooth or "Not specified",
        "cameras": cameras,
        "selfie": selfie,
        "cameravid": cameravid or "Not specified",
        "selfievid": selfievid or "Not specified",
        "models": models or "",
        "img": img_url
    }
    return title, spec

def _build_submission_kb(sub_id, ru=False):
    t_ok = "Одобрить" if ru else "Approve"
    t_no = "Отклонить" if ru else "Reject"
    return [[
        Button.inline(t_ok, data=f"subapprove_{sub_id}".encode()),
        Button.inline(t_no, data=f"subreject_{sub_id}".encode())
    ]]

def _format_submission(sub, ru=False):
    uid = sub.get('user_id')
    title = _escape_html(sub.get('title') or "Unknown")
    status = sub.get('status', 'pending')
    raw_text = _escape_html(_truncate(sub.get('raw_text') or '', 2600))
    header = f"Предложение #{sub['id']}" if ru else f"Submission #{sub['id']}"
    from_line = (f"От: <a href=\"tg://user?id={uid}\">{uid}</a>"
                 if ru else f"From: <a href=\"tg://user?id={uid}\">{uid}</a>")
    status_line = (f"Статус: {status}" if ru else f"Status: {status}")
    title_line = (f"Устройство: {title}" if ru else f"Device: {title}")
    text_label = "Текст:" if ru else "Text:"

    return f"<b>{header}</b>\n{from_line}\n{status_line}\n{title_line}\n\n{text_label}\n{raw_text}"

@client.on(events.NewMessage(pattern='/start'))
async def start_handler(event):
    uid = event.sender_id
    lang = getattr(event.sender, 'lang_code', 'en')

    if event.is_private:
        bot_state.set_sett(uid, 'news', bot_state.get_sett(uid)[5])
        bot_state.set_sett(uid, 'state', 0)

        param = event.message.message.partition(' ')[2]

        if 'survey' in param:
            await event.reply(_with_powered_by(tm.get('welcome_survey', uid, lang), uid, lang),
                              buttons=build_kbsurvey(),
                              parse_mode='html')
        elif 'from_switch' in param:
            kb = swkbaru if tm.get_user_lang(uid, lang) == 'ru' else swkba
            await event.reply(_with_powered_by(tm.get('welcome_switch', uid, lang), uid, lang),
                              buttons=kb,
                              parse_mode='html')
        elif 'settings' in param:
            kb = build_settru(uid) if tm.get_user_lang(uid, lang) == 'ru' else build_setten(uid)
            await event.reply(_with_powered_by(tm.get('settings_header', uid, lang), uid, lang),
                              buttons=kb,
                              parse_mode='html')
        else:
            kb = swkbdru if tm.get_user_lang(uid, lang) == 'ru' else swkbd
            await event.reply(_with_powered_by(tm.get('welcome_default', uid, lang), uid, lang),
                              buttons=kb,
                              parse_mode='html')

@client.on(events.NewMessage(pattern='/settings'))
async def settings_handler(event):
    if not event.is_private: return
    bot_state.set_sett(event.sender_id, 'state', 0)
    uid = event.sender_id
    lang = getattr(event.sender, 'lang_code', 'en')

    kb = build_settru(uid) if tm.get_user_lang(uid, lang) == 'ru' else build_setten(uid)
    await event.reply(_with_powered_by(tm.get('settings_header', uid, lang), uid, lang),
                      buttons=kb,
                      parse_mode='html')

@client.on(events.NewMessage(pattern='/dev'))
async def dev_cmd(event):
    if not event.is_private:
        return
    uid = event.sender_id
    lang = getattr(event.sender, 'lang_code', 'en')
    text = tm.get('dev_info', uid, lang, ver=version)
    kb = swkbaru if tm.get_user_lang(uid, lang) == 'ru' else swkba
    await event.reply(_with_powered_by(text, uid, lang), buttons=kb, parse_mode='html')

@client.on(events.NewMessage(pattern='/submit'))
async def submit_cmd(event):
    if event.is_private: await submit_new_device_logic(event)

@client.on(events.NewMessage(pattern='/cancel'))
async def cancel_cmd(event):
    if not event.is_private: return
    uid = event.sender_id
    lang = getattr(event.sender, 'lang_code', 'en')
    bot_state.set_sett(uid, 'state', 0)
    await event.reply(_with_powered_by(tm.get('submit_cancelled', uid, lang), uid, lang),
                      parse_mode='html')

@client.on(events.NewMessage(pattern=r'/admin'))
async def admin_cmd(event):
    if not event.is_private: return
    uid = event.sender_id
    lang = getattr(event.sender, 'lang_code', 'en')
    text = event.message.message.strip()
    parts = text.split()

    if not _has_any_admin():
        add_role(uid, ADMIN_ROLE, created_by=uid)
        await event.reply(tm.get('admin_bootstrap', uid, lang))
        return

    if not _is_admin(uid):
        await event.reply(tm.get('admin_only', uid, lang))
        return

    if len(parts) == 1 or parts[1] in ('list', 'ls'):
        admins = get_role_users(ADMIN_ROLE)
        admins_txt = ', '.join(str(a) for a in admins) if admins else '—'
        await event.reply(tm.get('admin_list', uid, lang, admins=admins_txt))
        return

    cmd = parts[1].lower()
    if cmd in ('add', 'remove', 'rm', 'del'):
        target_id = None
        if len(parts) >= 3:
            try:
                target_id = int(parts[2])
            except ValueError:
                target_id = None

        if not target_id:
            reply = await event.get_reply_message()
            if reply:
                target_id = reply.sender_id

        if not target_id:
            await event.reply(tm.get('admin_usage', uid, lang))
            return

        if cmd == 'add':
            add_role(target_id, ADMIN_ROLE, created_by=uid)
            await event.reply(tm.get('admin_added', uid, lang, uid=target_id))
        else:
            remove_role(target_id, ADMIN_ROLE)
            await event.reply(tm.get('admin_removed', uid, lang, uid=target_id))
    else:
        await event.reply(tm.get('admin_usage', uid, lang))

@client.on(events.NewMessage(pattern=r'/(review|submissions)'))
async def review_cmd(event):
    if not event.is_private: return
    uid = event.sender_id
    lang = getattr(event.sender, 'lang_code', 'en')
    ru = tm.get_user_lang(uid, lang) == 'ru'

    if not _is_admin(uid):
        await event.reply(tm.get('admin_only', uid, lang))
        return

    subs = list_pending_submissions(limit=10)
    if not subs:
        await event.reply(tm.get('mod_queue_empty', uid, lang))
        return

    for sub in subs:
        await event.reply(_format_submission(sub, ru=ru),
                          buttons=_build_submission_kb(sub['id'], ru=ru),
                          parse_mode='html')

async def submit_new_device_logic(event):
    uid = event.sender_id
    lang = getattr(event.sender, 'lang_code', 'en')
    text = event.message.message or ''
    payload = text.partition(' ')[2].strip()

    if payload:
        await _handle_submission_text(event, payload)
        return

    bot_state.set_sett(uid, 'state', SUBMIT_STATE)
    await event.reply(_with_powered_by(tm.get('submit_prompt', uid, lang), uid, lang),
                      parse_mode='html')

async def _handle_submission_text(event, text):
    uid = event.sender_id
    lang = getattr(event.sender, 'lang_code', 'en')
    cleaned = (text or '').strip()

    if len(cleaned) < 20:
        bot_state.set_sett(uid, 'state', SUBMIT_STATE)
        await event.reply(_with_powered_by(tm.get('submit_too_short', uid, lang), uid, lang),
                          parse_mode='html')
        return

    title = cleaned.splitlines()[0].strip() if cleaned.splitlines() else "Unknown device"
    sub_id = create_device_submission(uid, title, {"title": title}, raw_text=cleaned)
    title, spec = _normalize_submission_to_spec(cleaned, sub_id)
    update_submission_data(sub_id, title=title, data=spec)
    bot_state.set_sett(uid, 'state', 0)

    await event.reply(_with_powered_by(tm.get('submit_received', uid, lang, sub_id=sub_id), uid, lang),
                      parse_mode='html')
    await _notify_admins(sub_id)

async def _notify_admins(sub_id):
    sub = get_device_submission(sub_id)
    if not sub:
        return

    targets = _get_submission_notify_targets()
    if not targets:
        logging.warning("No recipients found for submission notification: %s", sub_id)
        return

    for admin_id in targets:
        ru = tm.get_user_lang(admin_id) == 'ru' if admin_id > 0 else False
        try:
            await client.send_message(admin_id,
                                      _format_submission(sub, ru=ru),
                                      buttons=_build_submission_kb(sub_id, ru=ru),
                                      parse_mode='html')
        except Exception:
            logging.exception("Failed to notify %s about submission %s", admin_id, sub_id)

@client.on(events.NewMessage())
async def text_handler(event):
    if not event.is_private: return
    if event.text.startswith('/'): return

    uid = event.sender_id
    state = bot_state.get_sett(uid)[1]

    if state == SUBMIT_STATE:
        await _handle_submission_text(event, event.text.strip())

@client.on(events.InlineQuery)
async def inline_handler(event):
    sender = await event.get_sender()
    tele_lang = getattr(sender, 'lang_code', 'en')
    if sender.username in getban():
        await _safe_answer_inline(event, [build_article_banned(event)], sender.id, tele_lang)
        return

    q = event.text.strip()
    flags = []
    if "-" in q:
        for p in q.split():
            if p.startswith('-'):
                flags.append(p)
                q = q.replace(p, '')
    q = q.strip()

    results = []
    sett = await _run_blocking(bot_state.get_sett, sender.id, timeout=0.5, default=list(DEFAULT_SETTINGS))
    if q:
        if 'child po' in q:
            results.append(build_article_childpo(event, q))
        else:
            gss = await _run_blocking(local_fuzz_search, q, timeout=INLINE_LOCAL_TIMEOUT, default=[])
            if not gss:
                gss = await _run_blocking(googler, q, timeout=INLINE_SEARCH_TIMEOUT, default=[])

            if not gss:
                results.append(build_article_notfound_CRITICAL(event))
                await _safe_answer_inline(event, results, sender.id, tele_lang)
                return

            await _run_blocking(bot_state.new_data, sender.id, gss[0], timeout=0.5, default=None)
            cnt = 0

            if sett[0] and 'samsung' in q.lower() and 'k9' in q.lower():
                results.append(build_article_samsungk9(event, str(cnt)))
                cnt+=1

            parse_links = gss[:INLINE_FETCH_LIMIT]
            parsed_specs = await asyncio.gather(*[
                _run_blocking(inlineq, lnk, timeout=INLINE_FETCH_TIMEOUT, default=None)
                for lnk in parse_links
            ])

            for lnk, rt in zip(parse_links, parsed_specs):
                if rt:
                    swkb = build_swkb(event, rt, lnk)
                    swkbm = build_swkbm(event, rt, lnk)

                    if '-d' in flags or sett[3]:
                        res = build_article_desktop(event, str(cnt), rt, build_swkbf(event, rt, lnk))
                    elif '-t' in flags or sett[4]:
                        res = build_article_full(event, str(cnt), rt, swkbm)
                    elif flags:
                        res = build_article_custom(str(cnt), rt, flags)
                    else:
                        res = build_article_default(event, str(cnt), rt, swkb)
                    results.append(res)
                    cnt+=1

            results.append(build_article_features(event, str(cnt)))
    else:
        lnk = await _run_blocking(bot_state.get_link, sender.id, timeout=0.5, default=None)
        if lnk:
            rt = await _run_blocking(inlineq, lnk, timeout=INLINE_FETCH_TIMEOUT, default=None)
            if rt:
                swkb = build_swkb(event, rt, lnk)
                res = build_article_default(event, "0", rt, swkb)
                results.append(res)
        results.append(build_article_basic(event))

    await _safe_answer_inline(event, results, sender.id, tele_lang)

@client.on(events.CallbackQuery)
async def cb_handler(event):
    d = event.data.decode()
    uid = event.sender_id
    lang_obj = getattr(event.sender, 'lang_code', 'en')

    if d.startswith('subapprove_') or d.startswith('subreject_'):
        if not _is_admin(uid):
            await event.answer(tm.get('admin_only', uid, lang_obj), alert=True)
            return

        sub_id = d.split('_', 1)[1]
        sub = get_device_submission(sub_id)
        if not sub:
            await event.answer(tm.get('mod_not_found', uid, lang_obj), alert=True)
            return

        if sub.get('status') != 'pending':
            await event.answer(tm.get('mod_already_done', uid, lang_obj), alert=True)
            return

        status = 'approved' if d.startswith('subapprove_') else 'rejected'
        update_submission_status(sub_id, status, reviewer_id=uid)
        sub['status'] = status
        sub['reviewed_by'] = uid

        if status == 'approved':
            try:
                spec = sub.get('data') or {}
                save_device(spec)
                reload_fuzz_index(force_reload=True)
            except Exception:
                pass

        ru = tm.get_user_lang(uid, lang_obj) == 'ru'
        try:
            await event.edit(_format_submission(sub, ru=ru), buttons=None, parse_mode='html')
        except Exception:
            pass

        try:
            if status == 'approved':
                await client.send_message(sub['user_id'], tm.get('submit_approved', sub['user_id']))
                await event.answer(tm.get('mod_approved', uid, lang_obj, sub_id=sub_id), alert=False)
            else:
                await client.send_message(sub['user_id'], tm.get('submit_rejected', sub['user_id']))
                await event.answer(tm.get('mod_rejected', uid, lang_obj, sub_id=sub_id), alert=False)
        except Exception:
            await event.answer(tm.get('mod_done', uid, lang_obj), alert=False)
        return

    if 'page2_' in d or 'page1_' in d or 'qupdate_' in d:
        pid = d.split('_')[1].split()[0]
        suffix = b' d' if ' d' in d else b''

        if 'qupdate_' in d:
            res_temp = get_device_by_id(pid)
            ru = tm.get_user_lang(uid, lang_obj) == 'ru'
            if not res_temp:
                await event.answer("Устройство не найдено." if ru else "Device data not found.", alert=True)
                return

            if pid in UPDATING_DEVICE_IDS:
                await event.answer("Устройство уже обновляется." if ru else "Device is already updating.", alert=False)
                return

            if not is_device_stale_for_update(device_id=pid, url=res_temp.get('link')):
                msg = (
                    "Обновление доступно только для устройств из GSMArena и не чаще раза в 30 дней."
                    if ru else
                    "Update is available only for GSMArena devices and no more than once every 30 days."
                )
                await event.answer(msg, alert=True)
                return

            UPDATING_DEVICE_IDS.add(pid)
            try:
                is_d = ' d' in d
                preview_formatter = reform1d if is_d else reform1
                preview_txt = preview_formatter(res_temp, lang_obj, uid)
                preview_kb = build_kbpage2(event, res_temp, force_hide_update=True)
                try:
                    await event.edit(preview_txt, buttons=preview_kb(suffix), parse_mode='html')
                except Exception:
                    pass

                refreshed = inlineq(res_temp['link'], iid=pid, inrec=1)
                if not refreshed:
                    restore_kb = build_kbpage2(event, res_temp)
                    try:
                        await event.edit(preview_txt, buttons=restore_kb(suffix), parse_mode='html')
                    except Exception:
                        pass
                    await event.answer("Не удалось обновить данные." if ru else "Failed to update device data.", alert=True)
                    return
                await event.answer("Данные обновлены." if ru else "Updated!", alert=False)
            finally:
                UPDATING_DEVICE_IDS.discard(pid)

        res = get_device_by_id(pid)
        if not res:
            await event.answer("Device data not found.", alert=True)
            return

        is_page2 = 'page2' in d
        if 'qupdate' in d: is_page2 = False

        if is_page2:
            txt = reform2(res, lang_obj)
            kb_func = build_kbpage1(event, res)
        else:
            is_d = ' d' in d
            f = reform1d if is_d else reform1
            txt = f(res, lang_obj, uid)
            kb_func = build_kbpage2(event, res)

        await event.edit(txt, buttons=kb_func(suffix), parse_mode='html')

    elif d in ['eeg', 'dflag', 'tflag', 'news']:
        idx = {'eeg':0, 'dflag':3, 'tflag':4, 'news':5}[d]
        curr = bot_state.get_sett(uid)[idx]
        new_value = 0 if curr else 1
        bot_state.set_sett(uid, d, new_value)

        if new_value and d == 'dflag':
            bot_state.set_sett(uid, 'tflag', 0)
        elif new_value and d == 'tflag':
            bot_state.set_sett(uid, 'dflag', 0)

        await _refresh_settings_message(event, uid, lang_obj)
        await event.answer()

    elif d == 'fuzzsearch':
        await event.answer("Параметр больше не используется." if tm.get_user_lang(uid, lang_obj) == 'ru'
                           else "This setting is no longer used.", alert=False)

    elif d == 'chlang':
        bot_state.set_sett(uid, 'forcelang', _next_forced_lang(uid))
        await _refresh_settings_message(event, uid, lang_obj)
        await event.answer()

if __name__ == '__main__':
    print("Telethon Bot Running...")
    client.run_until_disconnected()