#!/usr/bin/env python3
"""
Delta Chat Bot using recommended JSON-RPC bindings.
"""

import base64
import html
import json
import locale
import logging
import os
import re
import smtplib
import ssl
import imaplib
import psutil
import requests
import sys
import tempfile
import threading
import time
import socket
import uuid
import xml.etree.ElementTree as ET
from datetime import datetime, timedelta, timezone
from typing import Optional

from deltachat_rpc_client import Bot, DeltaChat, EventType, Rpc, events, run_bot_cli

import ai_agent

try:
    locale.setlocale(locale.LC_TIME, 'ru_RU.UTF-8')
except locale.Error:
    try:
        locale.setlocale(locale.LC_TIME, 'ru_RU.utf8')
    except locale.Error:
        pass

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

ACCOUNTS_DIR = "/home/alexabudaev/delta-bot/accounts"
CONFIG_DIR = os.path.expanduser("~/.config/deltabot")
SUBSCRIBERS_FILE = os.path.join(CONFIG_DIR, "subscribers.json")
PENDING_TOR_FILE = os.path.join(CONFIG_DIR, "pending_tor.json")
BRIDGES_CACHE_FILE = os.path.join(CONFIG_DIR, "bridges_cache.json")
TG_CHANNELS_FILE = os.path.join(CONFIG_DIR, "telegram_channels.json")
PENDING_SAVE_FILE = os.path.join(CONFIG_DIR, "pending_save.json")
PENDING_CHANNEL_FILE = os.path.join(CONFIG_DIR, "pending_channel.json")
BRIDGES_CACHE_TTL = 6 * 3600

TG_RSS_PROXY = "https://proxy.budaev.org/rss"
TG_RSS_FALLBACK = "https://tg.i-c-a.su/rss"
TG_POLL_INTERVAL = 90

HELP_TEXT = (
    "Доступные команды:\n"
    "/status - Состояние сервера\n"
    "/weather [город] [дни] - Погода. Дни: 3 (по умолч.), 7, 10\n"
    "/bridges [obfs4|vanilla|ipv6] - Запрос Tor мостов\n"
    "/save [путь] - Сохранить файл (прикрепите вложение)\n"
    "/channels list|add|remove|description|image - Управление каналами\n"
    "/telegram username [N] - Посты из TG канала\n"
    "/ai on|off|status|reset|summary - AI чат-бот\n"
    "/model - Сменить AI модель\n"
    "/apikey [ключ] - Ключ OpenRouter (для fallback)\n"
    "/cal today|week|list|add|delete - Управление календарём\n"
    "/note add|list|delete - Заметки\n"
    "/rate [валюта] - Курс валют ЦБ РФ\n"
    "/ip [адрес] - Информация об IP\n"
    "/dns <домен> - DNS-запрос\n"
    "/monitor add|list|remove|check - Мониторинг сайтов\n"
    "/subscribe - Подписаться на ежедневный отчет (09:00 Irkutsk)\n"
    "/unsubscribe - Отписаться от отчетов\n"
    "/qr - QR код для добавления бота\n"
    "/join https://i.delta.chat/#... - Secure join по ссылке\n"
    "/addcontact <email> - Добавить контакт в белый список\n"
    "/contacts list - Список разрешённых контактов\n"
    "/help - Эта справка"
)

DEFAULT_CITY = "Ulan-Ude"
DEFAULT_SAVE_DIRS = ["/tmp/", os.path.expanduser("~/")]
BOT_DIR = os.path.expanduser("~/delta-bot")
SAVE_DIR = os.path.expanduser("~/delta-chat")

CALDAV_URL = os.environ.get("CALDAV_URL", "https://baikal.budaev.org/dav.php/calendars/alex@budaev.org/ai-notifications/")
CALDAV_USER = os.environ.get("CALDAV_USER", "")
CALDAV_PASSWORD = os.environ.get("CALDAV_PASSWORD", "")
CAL_REMINDERS_FILE = os.path.join(CONFIG_DIR, "cal_reminders_sent.json")
CAL_REMINDER_AHEAD = 15 * 60
CAL_REMINDER_INTERVAL = 5 * 60

NOTES_FILE = os.path.join(CONFIG_DIR, "notes.json")
MONITORS_FILE = os.path.join(CONFIG_DIR, "monitors.json")
ALLOWED_CONTACTS_FILE = os.path.join(CONFIG_DIR, "allowed_contacts.json")
MONITOR_INTERVAL = 5 * 60
MONITOR_TIMEOUT = 10

CBR_RATES_URL = "https://www.cbr.ru/scripts/XML_daily.asp"
_rates_cache = {"ts": 0.0, "data": {}}

GMAIL_EMAIL = os.environ.get("GMAIL_EMAIL", "")
GMAIL_APP_PASSWORD = os.environ.get("GMAIL_APP_PASSWORD", "")
GMAIL_IMAP_HOST = "imap.gmail.com"
GMAIL_IMAP_PORT = 993
GMAIL_SMTP_HOST = "smtp.gmail.com"
GMAIL_SMTP_PORT = 465
TOR_EMAIL = "bridges@torproject.org"

IRKUTSK_TZ = timezone(timedelta(hours=8))

os.makedirs(CONFIG_DIR, exist_ok=True)

def load_json(path, default=None):
    if os.path.exists(path):
        try:
            with open(path, 'r') as f:
                return json.load(f)
        except Exception as e:
            logger.error(f"Error loading {path}: {e}")
    return default if default is not None else {}

def save_json(path, data):
    try:
        os.makedirs(os.path.dirname(path), exist_ok=True)
        with open(path, 'w') as f:
            json.dump(data, f, indent=2, default=str)
        logger.info(f"Saved JSON to {path}")
    except Exception as e:
        logger.error(f"Error saving {path}: {e}")

def parse_natural_language(text):
    lower = text.lower().strip()
    m = re.match(r'(?:погод[ауе]|weather|прогноз)\s*(.+)?$', lower)
    if m:
        rest = (m.group(1) or '').strip()
        return f"/weather {rest}".rstrip()
    m = re.match(r'(?:мосты?|bridge|tor)', lower)
    if m:
        for t in ['ipv6', 'vanilla', 'obfs4']:
            if t in lower:
                return f"/bridges {t}"
        return "/bridges obfs4"
    m = re.match(r'(?:дай|дайте|нужны)\s+(?:мосты?|bridge|tor)', lower)
    if m:
        for t in ['ipv6', 'vanilla', 'obfs4']:
            if t in lower:
                return f"/bridges {t}"
        return "/bridges obfs4"
    m = re.match(r'(?:заметка|запомни|note|запиши)\s+(.+)$', lower)
    if m:
        return f"/note add {text[m.start(1):]}"
    m = re.match(r'(?:заметки|мои заметки|list notes)', lower)
    if m:
        return "/note list"
    m = re.match(r'(?:напомни|remind(?:er)?)\s+(.+)$', lower)
    if m:
        return f"/cal add {text[m.start(1):]}"
    # Календарь
    m = re.match(r'(?:события?|calendar|календарь)\s*(?:на\s*)?(сегодня|today)$', lower)
    if m:
        return "/cal today"
    m = re.match(r'(?:события?|calendar|календарь)\s*(?:на\s*)?(неделю?|week)$', lower)
    if m:
        return "/cal week"
    m = re.match(r'(?:события?|calendar|календарь)$', lower)
    if m:
        return "/cal today"
    # Курс валют
    m = re.match(r'(?:курс|валюта|rate|exchange)\s*(.*)$', lower)
    if m:
        rest = m.group(1).strip().upper()
        return f"/rate {rest}".rstrip()
    # IP / DNS
    m = re.match(r'(?:мой\s+)?ip(?:\s+адрес)?$', lower)
    if m:
        return "/ip"
    m = re.match(r'ip\s+(.+)$', lower)
    if m:
        return f"/ip {text[m.start(1):]}"
    m = re.match(r'(?:dns|домен)\s+(.+)$', lower)
    if m:
        return f"/dns {text[m.start(1):]}"
    # Мониторинг
    m = re.match(r'(?:мониторинг|monitor)$', lower)
    if m:
        return "/monitor list"
    m = re.match(r'(?:следи|мониторь|monitor)\s+(?:за\s+)?(.+)$', lower)
    if m:
        return f"/monitor add {text[m.start(1):]}"
    # AI control
    m = re.match(r'(?:включи|вкл)\s+(?:ai|ии|чат)', lower)
    if m:
        return "/ai on"
    m = re.match(r'(?:выключи|выкл|выруби)\s+(?:ai|ии|чат)', lower)
    if m:
        return "/ai off"
    m = re.match(r'(?:ai|ии|чат|chat)\s+(?:статус|status|состояние)', lower)
    if m:
        return "/ai status"
    m = re.match(r'(?:ai|ии|чат|chat)\s+(?:сброс|reset|очисти|clear)', lower)
    if m:
        return "/ai reset"
    # Model
    m = re.match(r'(?:смени\s+)?модель', lower)
    if m:
        return "/model"
    # Telegram feed
    m = re.match(r'(?:telegram|телеграм|посты)\s*(.+)?$', lower)
    if m:
        rest = (m.group(1) or '').strip()
        return f"/telegram {rest}".rstrip()
    # Channels
    m = re.match(r'(?:каналы?|channels?)', lower)
    if m:
        return "/channels list"
    simple = {
        'статус': '/status', 'status': '/status', 'состояние': '/status',
        'сервер': '/status',
        'помощь': '/help', 'help': '/help', 'команды': '/help', 'что умеешь': '/help',
        'бот': '/help', 'инфо': '/help',
        'подпишись': '/subscribe', 'подписаться': '/subscribe', 'subscribe': '/subscribe',
        'отпишись': '/unsubscribe', 'отписаться': '/unsubscribe', 'unsubscribe': '/unsubscribe',
        'qr': '/qr', 'кьюар': '/qr', 'qrcode': '/qr',
    }
    return simple.get(lower) or None

def load_subscribers():
    return set(tuple(x) for x in load_json(SUBSCRIBERS_FILE, []))

def save_subscribers(subscribers):
    save_json(SUBSCRIBERS_FILE, [list(s) for s in subscribers])

def load_pending_tor():
    return load_json(PENDING_TOR_FILE, [])

def save_pending_tor(pending):
    save_json(PENDING_TOR_FILE, pending)

def load_bridges_cache():
    return load_json(BRIDGES_CACHE_FILE, {})

def save_bridges_cache(cache):
    save_json(BRIDGES_CACHE_FILE, cache)

def load_telegram_channels():
    return load_json(TG_CHANNELS_FILE, {}).get('channels', [])

def save_telegram_channels(channels):
    save_json(TG_CHANNELS_FILE, {'channels': channels})

def load_pending_save():
    return load_json(PENDING_SAVE_FILE, {})

def save_pending_save(data):
    save_json(PENDING_SAVE_FILE, data)

def get_pending_save(chat_id):
    return load_pending_save().get(str(chat_id))

def set_pending_save(chat_id, file_name, path, base64_data):
    logger.info(f"set_pending_save called: chat_id={chat_id}")
    data = load_pending_save()
    data[str(chat_id)] = {"file_name": file_name, "path": path, "base64": base64_data}
    logger.info(f"Saving pending: {data}")
    save_pending_save(data)
    logger.info(f"File saved, exists: {os.path.exists(PENDING_SAVE_FILE)}")

def clear_pending_save(chat_id):
    data = load_pending_save()
    if str(chat_id) in data:
        del data[str(chat_id)]
        save_pending_save(data)

def load_pending_channel():
    return load_json(PENDING_CHANNEL_FILE, {})

def save_pending_channel(data):
    save_json(PENDING_CHANNEL_FILE, data)

def get_pending_channel(chat_id):
    return load_pending_channel().get(str(chat_id))

def set_pending_channel(chat_id, username, broadcast_chat_id, action):
    data = load_pending_channel()
    data[str(chat_id)] = {"username": username, "broadcast_chat_id": broadcast_chat_id, "action": action}
    save_pending_channel(data)

def clear_pending_channel(chat_id):
    data = load_pending_channel()
    data.pop(str(chat_id), None)
    save_pending_channel(data)

def get_telegram_feed(username, limit=10, retry_count=1):
    proxies = [TG_RSS_PROXY]
    if TG_RSS_FALLBACK:
        proxies.append(TG_RSS_FALLBACK)

    for proxy in proxies:
        for attempt in range(retry_count):
            try:
                url = f"{proxy}/{username}?limit={limit}"
                resp = requests.get(url, timeout=45, headers={'User-Agent': 'Mozilla/5.0', 'Accept': '*/*'})

                if not resp.text or len(resp.text) < 10:
                    if attempt < retry_count - 1:
                        time.sleep(10)
                    continue

                root = ET.fromstring(resp.text)
                items = root.findall('.//item')
                channel_title = root.findtext('.//title', '')
                channel_description = root.findtext('.//description', '') or f"Ретрансляция канала @{username}"
                channel_image = root.findtext('.//image') or ''
                posts = []
                for item in items:
                    post = {'title': item.findtext('title', ''), 'link': item.findtext('link', ''), 'description': item.findtext('description', '')}
                    enclosure = item.find('enclosure')
                    if enclosure is not None:
                        post['enclosure_url'] = enclosure.get('url', '')
                        post['enclosure_type'] = enclosure.get('type', '')
                        post['enclosure_length'] = enclosure.get('length', '')
                    posts.append(post)
                if posts:
                    logger.info(f"TG Feed: {proxy} -> {username}: {len(posts)} posts")
                    return posts, channel_title, channel_description, channel_image, None

                if attempt < retry_count - 1:
                    time.sleep(5)
                    continue
                return None, None, "", "", f"Нет постов в ленте (@{username})"

            except ET.ParseError:
                if attempt < retry_count - 1:
                    time.sleep(5)
                    continue
            except Exception as e:
                logger.warning(f"TG Feed: {proxy} failed for {username}: {e}")
                if attempt < retry_count - 1:
                    time.sleep(5)
                    continue

    return None, None, "", "", f"Все прокси недоступны для @{username}"

WTTR_CODES = {
    113: "Ясно", 116: "Частично облачно", 119: "Облачно", 122: "Пасмурно",
    143: "Туман", 248: "Туман", 260: "Ледяной туман",
    176: "Небольшой дождь", 185: "Морозная морось",
    200: "Гроза", 227: "Метель", 230: "Буран",
    263: "Лёгкая морось", 266: "Морось", 281: "Ледяная морось", 284: "Сильная ледяная морось",
    293: "Слабый дождь", 296: "Дождь", 299: "Умеренный дождь",
    302: "Сильный дождь", 305: "Сильный дождь", 308: "Очень сильный дождь",
    311: "Мокрый снег", 314: "Умеренный мокрый снег", 317: "Слабый мокрый снег",
    320: "Умеренный снег", 323: "Слабый снег", 326: "Умеренный снег",
    329: "Сильный снег", 332: "Сильный снег", 335: "Очень сильный снег",
    338: "Экстремальный снег", 350: "Ледяная крупа",
    353: "Ливень", 356: "Умеренный ливень", 359: "Сильный ливень",
    362: "Мокрый снег с дождём", 365: "Мокрый снег с дождём",
    368: "Снегопад", 371: "Сильный снегопад",
    386: "Гроза с дождём", 389: "Сильная гроза с дождём",
    392: "Гроза со снегом", 395: "Сильная гроза со снегом",
}

def get_weather_wttr(city=DEFAULT_CITY, forecast_days=3):
    """Запасной источник погоды — wttr.in JSON API."""
    url = f"https://wttr.in/{requests.utils.quote(city)}?format=j1&lang=ru"
    resp = requests.get(url, timeout=25)
    resp.raise_for_status()
    data = resp.json()

    cc = data["current_condition"][0]
    temp = cc["temp_C"]
    feels = cc["FeelsLikeC"]
    humidity = cc["humidity"]
    wind_kmh = float(cc["windspeedKmph"])
    wind_ms = round(wind_kmh / 3.6, 1)
    pressure = cc.get("pressure", "?")
    code = int(cc["weatherCode"])
    desc = WTTR_CODES.get(code, cc.get("weatherDesc", [{}])[0].get("value", f"Код {code}"))

    months_ru = {
        'january': 'января', 'february': 'февраля', 'march': 'марта', 'april': 'апреля',
        'may': 'мая', 'june': 'июня', 'july': 'июля', 'august': 'августа',
        'september': 'сентября', 'october': 'октября', 'november': 'ноября', 'december': 'декабря'
    }
    days_ru = {
        'monday': 'понедельник', 'tuesday': 'вторник', 'wednesday': 'среда',
        'thursday': 'четверг', 'friday': 'пятница', 'saturday': 'суббота', 'sunday': 'воскресенье'
    }

    msg = f"Погода в {city.title()}\n"
    msg += f"Сейчас: {temp}°C, {desc}\n"
    msg += f"Ощущается: {feels}°C\n"
    msg += f"Влажность: {humidity}%, Ветер: {wind_ms} м/с\n"
    msg += f"Давление: {pressure} гПа\n\n"

    days_to_show = min(forecast_days, len(data.get("weather", [])))
    days_label = {3: "3 дня", 7: "7 дней", 10: "10 дней"}.get(forecast_days, f"{forecast_days} дней")
    msg += f"Прогноз на {days_label}:\n"
    for day in data["weather"][:days_to_show]:
        date = datetime.strptime(day["date"], "%Y-%m-%d")
        day_name = date.strftime("%d %B, %A").lower()
        for en, ru in months_ru.items():
            day_name = day_name.replace(en, ru)
        for en, ru in days_ru.items():
            day_name = day_name.replace(en, ru)
        tmax = day["maxtempC"]
        tmin = day["mintempC"]
        noon = day.get("hourly", [{}] * 5)[4]
        day_code = int(noon.get("weatherCode", 0))
        day_desc = WTTR_CODES.get(day_code, noon.get("weatherDesc", [{}])[0].get("value", ""))
        msg += f"{day_name}: {tmin}...{tmax}°C, {day_desc}\n"

    return msg


def get_weather(city=DEFAULT_CITY, lat=None, lon=None, forecast_days=3, retry_count=3):
    try:
        city_name = city
        if lat is None or lon is None:
            geo_url = f"https://geocoding-api.open-meteo.com/v1/search?name={city}&count=1&language=ru"
            geo_resp = requests.get(geo_url, timeout=5)
            if geo_resp.status_code != 200:
                raise RuntimeError(f"геокодинг: код {geo_resp.status_code}")
            geo_data = geo_resp.json()
            if "results" not in geo_data or not geo_data["results"]:
                return f"Город '{city}' не найден."
            lat = geo_data["results"][0]["latitude"]
            lon = geo_data["results"][0]["longitude"]
            city_name = geo_data["results"][0].get("name", city)
        else:
            city_name = city

        weather_hosts = [
            "customer-api-eu03.open-meteo.com",
            "customer-api-eu02.open-meteo.com",
        ]
        weather_data = None
        for host in weather_hosts:
            try:
                url = (
                    f"https://{host}/v1/forecast?"
                    f"latitude={lat}&longitude={lon}"
                    f"&current=temperature_2m,relative_humidity_2m,apparent_temperature,weather_code,wind_speed_10m,pressure_msl"
                    f"&daily=temperature_2m_max,temperature_2m_min,weather_code"
                    f"&timezone=auto&forecast_days={forecast_days}"
                )
                resp = requests.get(url, timeout=10)
                if resp.status_code == 200:
                    weather_data = resp.json()
                    break
            except Exception:
                continue
        if weather_data is None:
            raise RuntimeError("все endpoint'ы open-meteo недоступны")

        current = weather_data["current"]
        daily = weather_data["daily"]

        weather_codes = {
            0: "Ясно ☀️", 1: "Преимущественно ясно 🌤️", 2: "Частично облачно ⛅", 3: "Пасмурно ☁️",
            45: "Туман 🌫️", 48: "Иней/туман 🌫️", 51: "Легкая морось 🌦️", 53: "Морось 🌦️", 55: "Сильная морось 🌧️",
            61: "Легкий дождь 🌧️", 63: "Дождь 🌧️", 65: "Сильный дождь 🌧️",
            71: "Легкий снег 🌨️", 73: "Снег 🌨️", 75: "Сильный снег 🌨️",
            80: "Ливень 🌧️", 81: "Сильный ливень 🌧️", 82: "Экстремальный ливень 🌧️",
            95: "Гроза ⛈️", 96: "Гроза с градом ⛈️", 99: "Сильная гроза с градом ⛈️"
        }

        months_ru = {'january': 'января', 'february': 'февраля', 'march': 'марта', 'april': 'апреля', 'may': 'мая',
                    'june': 'июня', 'july': 'июля', 'august': 'августа', 'september': 'сентября', 'october': 'октября',
                    'november': 'ноября', 'december': 'декабря'}
        days_ru = {'wednesday': 'среда', 'thursday': 'четверг', 'friday': 'пятница', 'saturday': 'суббота',
                  'sunday': 'воскресенье', 'monday': 'понедельник', 'tuesday': 'вторник'}

        weather_code = current['weather_code']
        weather_desc = weather_codes.get(weather_code, f'Код {weather_code}')
        days_label = {3: "3 дня", 7: "7 дней", 10: "10 дней"}.get(forecast_days, f"{forecast_days} дней")
        msg = f"🌤 Погода в {city_name}\n"
        msg += f"Сейчас: {current['temperature_2m']}°C, {weather_desc}\n"
        feels_like = current.get('apparent_temperature')
        if feels_like is not None:
            msg += f"Ощущается: {feels_like}°C\n"
        msg += f"Влажность: {current['relative_humidity_2m']}%, Ветер: {current['wind_speed_10m']} м/с\n"
        pressure = current.get('pressure_msl')
        if pressure is not None:
            msg += f"Давление: {pressure} гПа\n"
        msg += "\n"
        msg += f"📅 Прогноз на {days_label}:\n"

        for i in range(min(forecast_days, len(daily["time"]))):
            date_str = daily["time"][i]
            date = datetime.strptime(date_str, "%Y-%m-%d")
            day_name = date.strftime("%d %B, %A").lower()
            for en, ru in months_ru.items():
                day_name = day_name.replace(en, ru)
            for en, ru in days_ru.items():
                day_name = day_name.replace(en, ru)
            tmax = daily["temperature_2m_max"][i]
            tmin = daily["temperature_2m_min"][i]
            wcode = daily["weather_code"][i]
            msg += f"{day_name}: {tmin}...{tmax}°C, {weather_codes.get(wcode, f'Код {wcode}')}\n"

        return msg
    except Exception as e:
        logger.warning(f"open-meteo failed ({e}), trying wttr.in")
        try:
            return get_weather_wttr(city_name, forecast_days)
        except Exception as e2:
            return f"Ошибка погоды: open-meteo недоступен, wttr.in: {e2}"

def get_system_status():
    try:
        cpu = psutil.cpu_percent(interval=1)
        load = psutil.getloadavg()
        mem = psutil.virtual_memory()
        disk = psutil.disk_usage('/')
        uptime = datetime.fromtimestamp(psutil.boot_time())
        uptime_delta = datetime.now() - uptime
        days = uptime_delta.days
        hours, remainder = divmod(uptime_delta.seconds, 3600)
        minutes = remainder // 60
        return (
            f"🖥 Server Status\n"
            f"Uptime: {days}d {hours}h {minutes}m\n"
            f"Load: {load[0]:.1f}, {load[1]:.1f}, {load[2]:.1f}\n"
            f"CPU: {cpu}%\n"
            f"RAM: {mem.percent}% ({mem.used // 1024 // 1024}MB / {mem.total // 1024 // 1024}MB)\n"
            f"Disk: {disk.percent}% ({disk.used // 1024 // 1024 // 1024}GB / {disk.total // 1024 // 1024 // 1024}GB)"
        )
    except Exception as e:
        return f"Error getting status: {e}"

def _remove_day_keyword(raw):
    for kw in ['на неделю', 'неделя', 'week', 'на 10 дней', 'десять дней']:
        raw = raw.replace(kw, '')
    return raw.strip()

def smtp_send(to, subject, body):
    try:
        context = ssl.create_default_context()
        server = smtplib.SMTP_SSL(GMAIL_SMTP_HOST, GMAIL_SMTP_PORT, context=context, timeout=30)
        server.login(GMAIL_EMAIL, GMAIL_APP_PASSWORD)
        msg = f"From: {GMAIL_EMAIL}\r\nTo: {to}\r\nSubject: {subject}\r\n"
        msg += f"Content-Type: text/plain; charset=UTF-8\r\n"
        msg += f"Chat-Version: 1.0\r\n"
        msg += f"Message-ID: <{int(time.time())}@torbot.deltachat>\r\n\r\n{body}"
        server.sendmail(GMAIL_EMAIL, [to], msg.encode('utf-8'))
        server.quit()
        return True
    except Exception as e:
        logger.error(f"SMTP Error: {e}")
        return False

def tor_request_bridges(bridge_type):
    return smtp_send(TOR_EMAIL, "Get bridges", f"get transport {bridge_type}")

def parse_obfs4_line(line):
    if 'obfs4' not in line.lower() or '(Request' in line:
        return None
    match = re.search(r'obfs4\s+[\[\]:0-9a-f:\s]+\S+(?:\s+\S+)*', line, re.IGNORECASE)
    return match.group(0).strip() if match else None

def parse_vanilla_line(line):
    if 'obfs4' in line.lower() or '(Request' in line:
        return None
    match = re.search(r'(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}:\d+)\s+([A-Fa-f0-9]{20,})', line)
    return f"{match.group(1)} {match.group(2)}" if match else None

def parse_ipv6_line(line):
    if 'obfs4' not in line.lower() or '(Request' in line:
        return None
    match = re.search(r'obfs4\s+\[[0-9a-f:]+\]:\d+\s+\S+(?:\s+\S+)*', line, re.IGNORECASE)
    return match.group(0).strip() if match else None

def parse_tor_bridges(response, bridge_type):
    bridges = []
    for line in re.split(r'\r\n|\n', response):
        line = line.strip()
        if not line or 'Here is your bridge' in line or 'This is an automated' in line or '[This is an email' in line or '(Request' in line:
            continue
        parsed = None
        if bridge_type == 'obfs4':
            parsed = parse_obfs4_line(line)
        elif bridge_type == 'vanilla':
            parsed = parse_vanilla_line(line)
        elif bridge_type == 'ipv6':
            parsed = parse_ipv6_line(line)
        if parsed:
            bridges.append(parsed)
    return bridges[:5]

def extract_plain_text_from_email(mail, msg_id):
    import email as email_module
    try:
        status, raw_data = mail.fetch(msg_id, '(BODY[])')
        if status != 'OK':
            return None
        raw_msg = raw_data[0][1] if isinstance(raw_data[0], tuple) else raw_data[0]
        msg = email_module.message_from_bytes(raw_msg)
        if msg.is_multipart():
            for part in msg.walk():
                if part.get_content_type() == 'text/plain':
                    payload = part.get_payload(decode=True)
                    charset = part.get_content_charset() or 'utf-8'
                    return payload.decode(charset, errors='replace')
        else:
            payload = msg.get_payload(decode=True)
            charset = msg.get_content_charset() or 'utf-8'
            return payload.decode(charset, errors='replace')
        return None
    except Exception as e:
        logger.error(f"Error extracting text: {e}")
        return None

def send_bridges_to_user(account, chat_id, bridges, bridge_type, from_cache=False):
    type_name = {'obfs4': 'obfs4', 'vanilla': 'vanilla', 'ipv6': 'IPv6'}.get(bridge_type, bridge_type)
    cache_label = ' (кэш)' if from_cache else ''
    chat = account.get_chat_by_id(chat_id)
    chat.send_text(f"🌉 Ваши {type_name} мосты{cache_label}:")
    for bridge in bridges:
        chat.send_text(bridge)
    chat.send_text("Скопируйте мост в настройки Tor Browser.\nМосты ограничены по времени, обновляйте при необходимости.")

_tor_lock = threading.Lock()

def tor_check_and_deliver(account, max_attempts=10, check_interval=30):
    if not _tor_lock.acquire(blocking=False):
        logger.info("Tor checker: already running, skipping")
        return
    try:
        pending = load_pending_tor()
        if not pending:
            logger.info("Tor checker: No pending requests")
            return
        
        logger.info(f"Tor checker: Starting with {len(pending)} pending requests")
        current_pending = [p for p in pending if not p.get('delivered')]
        if not current_pending:
            return
        
        for attempt in range(max_attempts):
            try:
                mail = imaplib.IMAP4_SSL(GMAIL_IMAP_HOST, GMAIL_IMAP_PORT)
                mail.login(GMAIL_EMAIL, GMAIL_APP_PASSWORD)
                mail.select('INBOX')
                
                msg_ids = []
                status, unseen = mail.search(None, b'FROM bridges@torproject.org UNSEEN')
                if status == 'OK' and unseen[0]:
                    msg_ids = [mid.decode('utf-8') if isinstance(mid, bytes) else str(mid) for mid in unseen[0].split()]
                
                if not msg_ids:
                    from_date = (datetime.now() - timedelta(minutes=10)).strftime('%d-%b-%Y')
                    search_cmd = f'FROM bridges@torproject.org SINCE {from_date}'.encode('utf-7')
                    status, recent = mail.search(None, search_cmd)
                    if status == 'OK' and recent[0]:
                        msg_ids = [mid.decode('utf-8') if isinstance(mid, bytes) else str(mid) for mid in recent[0].split()]
                
                if not msg_ids:
                    mail.logout()
                    time.sleep(check_interval)
                    continue
                
                msg_ids = sorted(msg_ids, key=lambda x: int(x), reverse=True)
                
                for msg_id in msg_ids:
                    plain_body = extract_plain_text_from_email(mail, msg_id)
                    if not plain_body:
                        continue
                    
                    for pending_req in list(current_pending):
                        if pending_req.get('delivered'):
                            continue
                        bridges = parse_tor_bridges(plain_body, pending_req.get('type', 'obfs4'))
                        if bridges:
                            try:
                                chat = account.get_chat_by_id(pending_req['chat_id'])
                                chat.send_text(f"🌉 Ваши {pending_req.get('type', 'obfs4')} мосты:")
                                for bridge in bridges:
                                    chat.send_text(bridge)
                                chat.send_text("Скопируйте мост в настройки Tor Browser.")
                                cache = load_bridges_cache()
                                cache[pending_req.get('type', 'obfs4')] = {'bridges': bridges, 'timestamp': int(time.time())}
                                save_bridges_cache(cache)
                            except Exception as e:
                                logger.error(f"Tor: Error: {e}")
                            pending_req['delivered'] = True
                            remaining = [p for p in current_pending if not p.get('delivered')]
                            save_pending_tor(remaining)
                            logger.info(f"Tor: delivered to chat {pending_req['chat_id']}, {len(remaining)} remaining")
                        else:
                            logger.info(f"Tor: No {pending_req.get('type')} bridges found in email {msg_id}")
                    
                    mail.store(msg_id, '+FLAGS', '\\SEEN')
                
                mail.logout()
                
                if not any(not p.get('delivered') for p in current_pending):
                    save_pending_tor([])
                    return
                
            except Exception as e:
                logger.error(f"Tor checker: IMAP error: {e}")
                try:
                    mail.logout()
                except:
                    pass
            
            if attempt < max_attempts - 1:
                time.sleep(check_interval)
        
        for pending_req in current_pending:
            if not pending_req.get('delivered'):
                cached = load_bridges_cache().get(pending_req.get('type', 'obfs4'), {}).get('bridges')
                if cached:
                    send_bridges_to_user(account, pending_req['chat_id'], cached, pending_req.get('type', 'obfs4'), from_cache=True)
                    pending_req['delivered'] = True
                else:
                    chat = account.get_chat_by_id(pending_req['chat_id'])
                    chat.send_text("К сожалению, не удалось получить мосты. Попробуйте позже.")
        save_pending_tor([])
    finally:
        _tor_lock.release()

def get_cached_bridges(bridge_type):
    cached = load_bridges_cache().get(bridge_type)
    if cached and time.time() - cached.get('timestamp', 0) < BRIDGES_CACHE_TTL:
        return cached.get('bridges')
    return None

# --- Notes ---

def load_allowed_contacts():
    return set(load_json(ALLOWED_CONTACTS_FILE, []))

def save_allowed_contacts(contacts):
    save_json(ALLOWED_CONTACTS_FILE, list(contacts))

TRUSTED_DOMAINS = {"budaev.org", "dc.budaev.org"}

def _matches_allowlist(addr, allowed):
    """Return True if addr matches any entry (exact email or *@domain wildcard)."""
    if addr in allowed:
        return True
    domain = addr.split("@")[-1] if "@" in addr else ""
    return domain in TRUSTED_DOMAINS or f"*@{domain}" in allowed

def is_contact_allowed(account, from_id):
    """Return True if the sender is verified via SecureJoin or in the explicit allowlist."""
    if from_id <= 0:
        return False
    try:
        contact_data = account._rpc.get_contact(account.id, from_id)
        if contact_data.get('isVerified', False):
            return True
        addr = contact_data.get('address', '').lower()
        return _matches_allowlist(addr, load_allowed_contacts())
    except Exception as e:
        logger.warning(f"is_contact_allowed error for contact {from_id}: {e}")
        return False


def load_notes():
    return load_json(NOTES_FILE, {})

def save_notes(data):
    save_json(NOTES_FILE, data)

def get_notes(chat_id):
    return load_notes().get(str(chat_id), [])

def add_note(chat_id, text):
    data = load_notes()
    key = str(chat_id)
    notes = data.get(key, [])
    next_id = max((n["id"] for n in notes), default=0) + 1
    notes.append({"id": next_id, "text": text, "created": datetime.now(IRKUTSK_TZ).isoformat()})
    data[key] = notes
    save_notes(data)
    return next_id

def delete_note(chat_id, note_id):
    data = load_notes()
    key = str(chat_id)
    notes = data.get(key, [])
    new_notes = [n for n in notes if n["id"] != note_id]
    if len(new_notes) == len(notes):
        return False
    data[key] = new_notes
    save_notes(data)
    return True


# --- Exchange rates ---

def get_exchange_rates():
    now = time.time()
    if now - _rates_cache["ts"] < 3600 and _rates_cache["data"]:
        return _rates_cache["data"]
    try:
        r = requests.get(CBR_RATES_URL, timeout=10)
        r.raise_for_status()
        root = ET.fromstring(r.content)
        rates = {}
        for valute in root.findall("Valute"):
            code = valute.findtext("CharCode", "")
            name = valute.findtext("Name", "")
            nominal_str = valute.findtext("Nominal", "1").replace(",", ".")
            value_str = valute.findtext("Value", "0").replace(",", ".")
            try:
                rates[code] = (int(nominal_str), float(value_str), name)
            except ValueError:
                pass
        _rates_cache["ts"] = now
        _rates_cache["data"] = rates
        return rates
    except Exception as e:
        logger.error(f"CBR rates error: {e}")
        raise


# --- Network utilities ---

def lookup_ip_info(ip_or_host):
    try:
        logger.info(f"=== lookup_ip_info: {ip_or_host}")
        r = requests.get(f"https://ipinfo.io/{ip_or_host}/json", timeout=10)
        r.raise_for_status()
        data = r.json()
        logger.info(f"=== lookup_ip_info result: {data.get('ip', '?')}")
        return data
    except Exception as e:
        logger.warning(f"=== lookup_ip_info failed: {e}")
        raise RuntimeError(f"ipinfo.io: {e}")

def dns_lookup(domain):
    try:
        infos = socket.getaddrinfo(domain, None)
        addrs = list(dict.fromkeys(info[4][0] for info in infos))
        return addrs
    except socket.gaierror as e:
        raise RuntimeError(f"DNS: {e}")


# --- Site monitors ---

def load_monitors():
    return load_json(MONITORS_FILE, [])

def save_monitors(data):
    save_json(MONITORS_FILE, data)

def check_url(url):
    try:
        r = requests.get(url, timeout=MONITOR_TIMEOUT, allow_redirects=True)
        return True, str(r.status_code)
    except requests.Timeout:
        return False, "Timeout"
    except requests.ConnectionError as e:
        return False, str(e)[:80]
    except Exception as e:
        return False, str(e)[:80]

def monitor_worker(account):
    while True:
        time.sleep(MONITOR_INTERVAL)
        monitors = load_monitors()
        changed = False
        for m in monitors:
            ok, detail = check_url(m["url"])
            was_ok = m.get("last_ok")
            m["last_check"] = time.time()
            if was_ok is not None and ok != was_ok:
                if ok:
                    alert = f"Сайт восстановлен\n{m['url']}"
                else:
                    alert = f"САЙТ НЕДОСТУПЕН\n{m['url']}\nСтатус: {detail}"
                chat_id = m.get("added_chat")
                if chat_id:
                    try:
                        account._rpc.send_msg(account.id, chat_id, {"text": alert})
                    except Exception as e:
                        logger.error(f"Monitor alert error: {e}")
                logger.info(f"Monitor: {m['url']} {'UP' if ok else 'DOWN'} ({detail})")
            m["last_ok"] = ok
            m["last_detail"] = detail
            changed = True
        if changed:
            save_monitors(monitors)


# --- CalDAV reminders ---

def load_cal_reminders_sent():
    return load_json(CAL_REMINDERS_FILE, {})

def save_cal_reminders_sent(data):
    save_json(CAL_REMINDERS_FILE, data)

def cal_reminder_worker(account):
    while True:
        time.sleep(CAL_REMINDER_INTERVAL)
        try:
            now = datetime.now(timezone.utc)
            window_end = now + timedelta(seconds=CAL_REMINDER_AHEAD)
            evs = cal_list_events(days_ahead=1)
            sent = load_cal_reminders_sent()
            # Чистим старые записи (старше 25 часов)
            cutoff = now.timestamp() - 25 * 3600
            sent = {uid: ts for uid, ts in sent.items() if ts > cutoff}
            subscribers = load_subscribers()
            for ev in evs:
                uid = ev.get("uid")
                dtstart = ev.get("dtstart_dt")
                if not uid or not dtstart or uid in sent:
                    continue
                if now <= dtstart <= window_end:
                    local_dt = dtstart.astimezone(timezone(IRKUTSK_OFFSET))
                    title = ev.get("summary", "(без названия)")
                    dtend = ev.get("dtend_dt")
                    if dtend:
                        local_end = dtend.astimezone(timezone(IRKUTSK_OFFSET))
                        time_range = f"{local_dt.strftime('%H:%M')}–{local_end.strftime('%H:%M')}"
                    else:
                        time_range = local_dt.strftime("%H:%M")
                    text = f"Напоминание: через ~15 мин\n{time_range} — {title}"
                    for accid, chat_id in list(subscribers):
                        try:
                            account._rpc.send_msg(account.id, chat_id, {"text": text})
                        except Exception as e:
                            logger.error(f"CalDAV reminder send error: {e}")
                    sent[uid] = now.timestamp()
                    logger.info(f"CalDAV reminder sent: {title}")
            save_cal_reminders_sent(sent)
        except Exception as e:
            logger.warning(f"cal_reminder_worker error: {e}")


# --- Whisper transcription ---

def transcribe_audio(file_path):
    account_id = os.environ.get("CLOUDFLARE_ACCOUNT_ID")
    api_token = os.environ.get("CLOUDFLARE_API_TOKEN")
    if not account_id or not api_token:
        return None
    url = f"https://api.cloudflare.com/client/v4/accounts/{account_id}/ai/run/@cf/openai/whisper"
    try:
        with open(file_path, "rb") as f:
            audio_data = f.read()
        r = requests.post(
            url,
            headers={"Authorization": f"Bearer {api_token}"},
            data=audio_data,
            timeout=60,
        )
        if r.status_code != 200:
            logger.warning(f"Whisper API error: {r.status_code} {r.text[:200]}")
            return None
        data = r.json()
        if not data.get("success"):
            return None
        return data.get("result", {}).get("text") or data.get("result", {}).get("transcription")
    except Exception as e:
        logger.warning(f"transcribe_audio error: {e}")
        return None


IRKUTSK_OFFSET = timedelta(hours=8)

def _caldav_auth():
    return (CALDAV_USER, CALDAV_PASSWORD)

def _caldav_headers(extra=None):
    h = {"Content-Type": "application/xml; charset=utf-8"}
    if extra:
        h.update(extra)
    return h

def cal_list_events(days_ahead=1, max_events=20):
    """Запрашивает события из CalDAV за указанный диапазон дней."""
    now = datetime.now(timezone.utc)
    end = now + timedelta(days=days_ahead)
    dtstart = now.strftime("%Y%m%dT%H%M%SZ")
    dtend = end.strftime("%Y%m%dT%H%M%SZ")
    body = f"""<?xml version="1.0" encoding="utf-8"?>
<C:calendar-query xmlns:D="DAV:" xmlns:C="urn:ietf:params:xml:ns:caldav">
  <D:prop>
    <D:getetag/>
    <C:calendar-data/>
  </D:prop>
  <C:filter>
    <C:comp-filter name="VCALENDAR">
      <C:comp-filter name="VEVENT">
        <C:time-range start="{dtstart}" end="{dtend}"/>
      </C:comp-filter>
    </C:comp-filter>
  </C:filter>
</C:calendar-query>"""
    try:
        r = requests.request(
            "REPORT", CALDAV_URL,
            auth=_caldav_auth(),
            headers={"Content-Type": "application/xml; charset=utf-8", "Depth": "1"},
            data=body.encode("utf-8"),
            timeout=10,
        )
        r.raise_for_status()
        return _parse_caldav_response(r.text)
    except Exception as e:
        logger.error(f"CalDAV list error: {e}")
        raise

def cal_add_event(title, dt_start, dt_end=None, description=""):
    """Создаёт событие через CalDAV PUT."""
    if dt_end is None:
        dt_end = dt_start + timedelta(hours=1)
    uid = str(uuid.uuid4())
    fmt = "%Y%m%dT%H%M%S"
    # Используем локальное время Иркутска с явным смещением
    tz_suffix = "+0800"
    ical = (
        "BEGIN:VCALENDAR\r\n"
        "VERSION:2.0\r\n"
        "PRODID:-//DeltaBot//CalDAV//EN\r\n"
        "BEGIN:VEVENT\r\n"
        f"UID:{uid}\r\n"
        f"DTSTART;TZID=Asia/Irkutsk:{dt_start.strftime(fmt)}\r\n"
        f"DTEND;TZID=Asia/Irkutsk:{dt_end.strftime(fmt)}\r\n"
        f"SUMMARY:{title}\r\n"
    )
    if description:
        ical += f"DESCRIPTION:{description}\r\n"
    ical += (
        "BEGIN:VALARM\r\n"
        "ACTION:DISPLAY\r\n"
        "DESCRIPTION:Напоминание\r\n"
        "TRIGGER:-PT15M\r\n"
        "END:VALARM\r\n"
        "END:VEVENT\r\nEND:VCALENDAR\r\n"
    )
    url = CALDAV_URL.rstrip("/") + f"/{uid}.ics"
    try:
        r = requests.put(
            url,
            auth=_caldav_auth(),
            headers={"Content-Type": "text/calendar; charset=utf-8"},
            data=ical.encode("utf-8"),
            timeout=10,
        )
        r.raise_for_status()
        return uid
    except Exception as e:
        logger.error(f"CalDAV add error: {e}")
        raise

def cal_delete_event(uid):
    """Удаляет событие по UID."""
    url = CALDAV_URL.rstrip("/") + f"/{uid}.ics"
    try:
        r = requests.delete(url, auth=_caldav_auth(), timeout=10)
        if r.status_code == 404:
            raise ValueError("Событие не найдено")
        r.raise_for_status()
    except ValueError:
        raise
    except Exception as e:
        logger.error(f"CalDAV delete error: {e}")
        raise

def _parse_caldav_response(xml_text):
    """Парсит multistatus XML и извлекает список событий."""
    events_list = []
    try:
        root = ET.fromstring(xml_text)
        ns = {
            "D": "DAV:",
            "C": "urn:ietf:params:xml:ns:caldav",
        }
        for resp in root.findall(".//D:response", ns):
            cal_data_el = resp.find(".//C:calendar-data", ns)
            if cal_data_el is None or not cal_data_el.text:
                continue
            ev = _parse_ical(cal_data_el.text)
            if ev:
                events_list.append(ev)
    except ET.ParseError as e:
        logger.error(f"CalDAV XML parse error: {e}")
    events_list.sort(key=lambda x: x.get("dtstart_dt") or datetime.min.replace(tzinfo=timezone.utc))
    return events_list

def _parse_ical(ical_text):
    """Извлекает поля VEVENT из iCalendar-текста."""
    ev = {}
    in_vevent = False
    for raw_line in ical_text.splitlines():
        line = raw_line.strip()
        if line == "BEGIN:VEVENT":
            in_vevent = True
            ev = {}
            continue
        if line == "END:VEVENT":
            in_vevent = False
            continue
        if not in_vevent:
            continue
        if ":" not in line:
            continue
        key_part, _, value = line.partition(":")
        key = key_part.split(";")[0].upper()
        if key == "UID":
            ev["uid"] = value
        elif key == "SUMMARY":
            ev["summary"] = value
        elif key == "DESCRIPTION":
            ev["description"] = value
        elif key in ("DTSTART", "DTEND"):
            dt = _parse_ical_dt(value)
            field = "dtstart_dt" if key == "DTSTART" else "dtend_dt"
            if dt:
                ev[field] = dt
    return ev if ev.get("uid") else None

def _parse_ical_dt(value):
    """Разбирает дату/время из iCalendar."""
    value = value.strip()
    try:
        if value.endswith("Z"):
            dt = datetime.strptime(value, "%Y%m%dT%H%M%SZ").replace(tzinfo=timezone.utc)
        elif "T" in value:
            dt = datetime.strptime(value, "%Y%m%dT%H%M%S").replace(tzinfo=timezone(IRKUTSK_OFFSET))
        else:
            dt = datetime.strptime(value, "%Y%m%d").replace(tzinfo=timezone(IRKUTSK_OFFSET))
        return dt
    except ValueError:
        return None

def _format_event(ev, show_uid=False):
    """Форматирует событие для отображения."""
    dt = ev.get("dtstart_dt")
    dt_end = ev.get("dtend_dt")
    if dt:
        local_dt = dt.astimezone(timezone(IRKUTSK_OFFSET))
        date_str = local_dt.strftime("%d.%m %H:%M")
        if dt_end:
            local_end = dt_end.astimezone(timezone(IRKUTSK_OFFSET))
            if local_dt.date() == local_end.date():
                date_str += f"–{local_end.strftime('%H:%M')}"
    else:
        date_str = "?"
    title = ev.get("summary", "(без названия)")
    desc = ev.get("description", "")
    line = f"{date_str} — {title}"
    if desc:
        line += f"\n  {desc}"
    if show_uid:
        uid = ev.get("uid", "")
        line += f"\n  ID: {uid[:8]}"
    return line

RU_MONTHS = {
    "января": 1, "февраля": 2, "марта": 3, "апреля": 4,
    "мая": 5, "июня": 6, "июля": 7, "августа": 8,
    "сентября": 9, "октября": 10, "ноября": 11, "декабря": 12,
    "january": 1, "february": 2, "march": 3, "april": 4,
    "may": 5, "june": 6, "july": 7, "august": 8,
    "september": 9, "october": 10, "november": 11, "december": 12,
}

def _parse_cal_datetime(date_str, time_str):
    """Парсит дату/время для команды /cal add в часовом поясе Иркутска."""
    now_irkutsk = datetime.now(timezone(IRKUTSK_OFFSET))
    date_str = date_str.strip()
    time_str = time_str.strip()

    if date_str.lower() in ("сегодня", "today"):
        d = now_irkutsk.date()
    elif date_str.lower() in ("завтра", "tomorrow"):
        d = (now_irkutsk + timedelta(days=1)).date()
    else:
        # "22 июня" / "22 июня 2026"
        words = date_str.split()
        if len(words) >= 2 and words[1].lower() in RU_MONTHS:
            try:
                month = RU_MONTHS[words[1].lower()]
                day = int(words[0])
                year = int(words[2]) if len(words) >= 3 else now_irkutsk.year
                from datetime import date as _date
                d = _date(year, month, day)
            except (ValueError, IndexError):
                raise ValueError(f"Неверная дата: {date_str}")
        else:
            for fmt in ("%d.%m.%Y", "%d.%m"):
                try:
                    parsed = datetime.strptime(date_str, fmt)
                    d = parsed.replace(year=now_irkutsk.year).date() if fmt == "%d.%m" else parsed.date()
                    break
                except ValueError:
                    continue
            else:
                raise ValueError(f"Неверный формат даты: {date_str}")

    try:
        t = datetime.strptime(time_str, "%H:%M").time()
    except ValueError:
        raise ValueError(f"Неверный формат времени: {time_str}")
    return datetime.combine(d, t)


hooks = events.HookCollection()

@hooks.on(events.RawEvent)
def log_event(event):
    if event.kind == EventType.INFO:
        logger.info(event.msg)
    elif event.kind == EventType.WARNING:
        logger.warning(event.msg)
    elif event.kind == EventType.ERROR:
        logger.error(event.msg)

@hooks.on(events.NewMessage(is_info=False))
def handle_message(event):
    message = event.message_snapshot
    text = message.text.strip() if message.text else ""
    chat_id = message.chat_id
    from_id = getattr(message, 'from_id', 0)

    account = message.chat.account
    if not is_contact_allowed(account, from_id):
        logger.info(f"Ignoring message from unverified contact id={from_id} in chat {chat_id}")
        return

    # Транскрипция голосовых/аудио сообщений через Cloudflare Whisper
    file_path = getattr(message, 'file', None)
    file_mime = getattr(message, 'file_mime_type', None) or ""
    if file_path and file_mime.startswith("audio/") and not text:
        transcript = transcribe_audio(file_path)
        if transcript:
            message.chat.send_text(f"Транскрипция:\n{transcript}")
            return
        else:
            message.chat.send_text("Не удалось транскрибировать аудио.")
            return

    if text and not text.startswith("/"):
        cmd = parse_natural_language(text)
        if cmd:
            text = cmd

    if text.startswith("/weather"):
        raw = text[8:].strip()
        city = DEFAULT_CITY
        days = 3
        raw_lower = raw.lower()
        
        if 'на неделю' in raw_lower or ' неделя' in raw_lower or raw_lower.strip() == 'week':
            days = 7
            raw = _remove_day_keyword(raw)
        elif 'на 10 дней' in raw_lower or 'десять дней' in raw_lower:
            days = 10
            raw = _remove_day_keyword(raw)
        
        days_map = {'7': 7, '10': 10}
        for word in raw.split():
            if word in days_map:
                days = days_map[word]
                raw = raw.replace(word, '').strip()
        
        city = raw.strip() if raw.strip() else DEFAULT_CITY
        message.chat.send_text(get_weather(city, forecast_days=days))
    
    elif text == "/status":
        message.chat.send_text(get_system_status())
    
    elif text.startswith("/bridges"):
        parts = text.split(maxsplit=1)
        bridge_type = parts[1].strip().lower() if len(parts) > 1 else 'obfs4'
        valid_types = ['obfs4', 'vanilla', 'ipv6']
        if bridge_type not in valid_types:
            message.chat.send_text(f"Неизвестный тип моста. Доступны: {', '.join(valid_types)}\nПример: /bridges obfs4")
            return
        
        cached = get_cached_bridges(bridge_type)
        if cached:
            send_bridges_to_user(message.chat.account, chat_id, cached, bridge_type, from_cache=True)
            return
        
        if tor_request_bridges(bridge_type):
            pending = load_pending_tor()
            pending.append({"chat_id": chat_id, "type": bridge_type, "timestamp": int(time.time())})
            save_pending_tor(pending)
            account = message.chat.account
            threading.Thread(target=tor_check_and_deliver, args=(account,), daemon=True).start()
            message.chat.send_text("Запрос отправлен. Ожидайте ответ в течение нескольких минут...")
        else:
            message.chat.send_text("Ошибка отправки запроса. Попробуйте позже.")
    
    elif text == "/subscribe":
        account = message.chat.account
        subscribers = load_subscribers()
        subscribers.add((account.id, chat_id))
        save_subscribers(subscribers)
        message.chat.send_text("Вы подписаны на ежедневный отчет (09:00 по Иркутску, сервер + погода).")
    
    elif text == "/unsubscribe":
        account = message.chat.account
        subscribers = load_subscribers()
        subscribers.discard((account.id, chat_id))
        save_subscribers(subscribers)
        message.chat.send_text("Вы отписаны от ежедневного статуса.")
    
    elif text.startswith("/channels"):
        parts = text.split(maxsplit=1)
        subcmd = parts[1].strip().lower() if len(parts) > 1 else ""
        channels = load_telegram_channels()
        account = message.chat.account
        
        if subcmd == "list" or subcmd == "":
            if not channels:
                message.chat.send_text("📺 Список каналов пуст.\n\n/channels add username — добавить канал")
            else:
                msg_text = "📺 Каналы Telegram:\n\n"
                for ch in channels:
                    title = ch.get('title', ch['username'])
                    invite_link = ch.get('invite_link', '')
                    if invite_link:
                        msg_text += f"📡 {title}\n🔗 {invite_link}\n📝 Ретрансляция @{ch['username']}\n"
                    else:
                        msg_text += f"📡 {title} (@{ch['username']})\n"
                    msg_text += "───────────────────────\n\n"
                msg_text += "/channels add username — добавить канал"
                message.chat.send_text(msg_text)
    
        
        elif subcmd.startswith("add "):
            username = subcmd[4:].strip().lstrip('@')
            if not username:
                message.chat.send_text("Укажите username: /channels add username")
        
                return
            
            if any(ch['username'] == username for ch in channels):
                message.chat.send_text(f"@{username} уже есть в списке.\n/channels invite {username} — отправить QR повторно")
        
                return
            
            message.chat.send_text(f"⏳ Создаю канал @{username}...")
            
            logger.info(f"Creating channel: {username}")
            posts, channel_title, channel_desc, channel_img, error = get_telegram_feed(username, 1)
            
            if isinstance(channel_title, dict):
                channel_title = channel_title.get('#text', '') or str(channel_title)
            if isinstance(channel_desc, dict):
                channel_desc = channel_desc.get('#text', '') or str(channel_desc)
            if isinstance(channel_img, dict):
                channel_img = channel_img.get('url', '') or str(channel_img)
            
            channel_title = str(channel_title) if channel_title else username
            channel_desc = str(channel_desc) if channel_desc else ''
            channel_img = str(channel_img) if channel_img else ''
            
            debug_info = f"RSS: title='{channel_title}', desc='{channel_desc[:50] if channel_desc else 'empty'}', img='{str(channel_img)[:100]}', error='{error}'"
            logger.info(debug_info)
            message.chat.send_text(f"📋 {debug_info}")
            
            if error:
                message.chat.send_text(f"❌ Канал @{username} недоступен. Проверьте имя канала.")
                return
            
            if not posts and not channel_title:
                message.chat.send_text(f"❌ Канал @{username} не найден или недоступен.")
                return
            
            title = channel_title if channel_title else username
            description = channel_desc if channel_desc else f"Ретрансляция канала @{username}"
            
            try:
                logger.info(f"Creating broadcast: {title}")
                chat = account.create_broadcast(title)
                chat.set_name(title)
                
                logger.info(f"Channel {username}: title={title}, description={channel_desc[:50] if channel_desc else 'empty'}, image={channel_img[:50] if channel_img else 'empty'}")
                
                if not channel_img:
                    logger.warning(f"No image URL in RSS for {username}")
                
                try:
                    chat._rpc.set_chat_description(account.id, chat.id, description)
                    logger.info(f"Description set: {description[:100]}")
                except Exception as desc_e:
                    logger.error(f"Failed to set description: {desc_e}")
                
                if channel_img:
                    try:
                        logger.info(f"Downloading channel image: {channel_img}")
                        img_resp = requests.get(channel_img, timeout=15, headers={'User-Agent': 'Mozilla/5.0'})
                        if img_resp.status_code == 200:
                            img_path = os.path.join(CONFIG_DIR, f"channel_img_{chat.id}.jpg")
                            with open(img_path, 'wb') as f:
                                f.write(img_resp.content)
                            logger.info(f"Image saved to {img_path}, size={len(img_resp.content)}")
                            chat.set_image(img_path)
                            logger.info(f"Set channel image from {channel_img}")
                        else:
                            logger.warning(f"Image download failed: {img_resp.status_code}")
                    except Exception as img_e:
                        logger.error(f"Could not set channel image: {img_e}")
                
                broadcast_chat_id = chat.id
                logger.info(f"Broadcast channel created: {title} with chat_id={broadcast_chat_id}")
                
                invite_link = None
                try:
                    qr = chat.get_qr_code()
                    if isinstance(qr, str):
                        invite_link = qr
                    elif isinstance(qr, dict):
                        invite_link = qr.get('qr') or qr.get('url') or qr.get('link')
                    logger.info(f"QR code obtained: {invite_link}")
                except Exception as qr_e:
                    logger.warning(f"Could not get QR code: {qr_e}")
                
                new_channel = {
                    'username': username,
                    'title': title,
                    'description': description,
                    'image_url': channel_img or '',
                    'broadcast_chat_id': broadcast_chat_id,
                    'invite_link': invite_link or '',
                    'last_post_id': ''
                }
                channels.append(new_channel)
                save_telegram_channels(channels)
                
                if invite_link:
                    message.chat.send_text(f"✅ Канал '{title}' создан!\n\n🔗 Подписка: {invite_link}")
                else:
                    message.chat.send_text(f"✅ Канал '{title}' создан!\n⚠️ QR код недоступен, используйте /channels invite позже")
                
                chat.send_text(f"📺 Тест канала '{title}'\n\nЭто тестовое сообщение. Подпишитесь на канал через ссылку выше.")
                
            except Exception as e:
                logger.error(f"Error creating channel: {e}")
                message.chat.send_text(f"❌ Ошибка создания канала: {e}")
            
    
        
        elif subcmd.startswith("invite "):
            identifier = subcmd[7:].strip().lstrip('@')
            ch = next((c for c in channels if c['username'] == identifier), None)
            if not ch:
                message.chat.send_text(f"Канал @{identifier} не найден.")
        
                return
            
            message.chat.send_text(f"⏳ Получаю QR для {ch['title']}...")
            
            try:
                chat = account.get_chat_by_id(ch['broadcast_chat_id'])
                qr = chat.get_qr_code()
                if isinstance(qr, str):
                    invite_link = qr
                elif isinstance(qr, dict):
                    invite_link = qr.get('qr') or qr.get('url') or qr.get('link')
                
                if invite_link:
                    ch['invite_link'] = invite_link
                    save_telegram_channels(channels)
                    message.chat.send_text(f"✅ QR для '{ch['title']}':\n\n🔗 {invite_link}")
                else:
                    message.chat.send_text(f"⚠️ Не удалось получить QR код")
            except Exception as e:
                logger.error(f"Error getting invite: {e}")
                message.chat.send_text(f"❌ Ошибка: {e}")
            
    
        
        elif subcmd.startswith("remove "):
            username = subcmd[7:].strip().lstrip('@')
            ch = next((c for c in channels if c['username'] == username), None)
            if not ch:
                message.chat.send_text(f"@{username} не найден в списке.")
        
                return
            channels = [c for c in channels if c['username'] != username]
            save_telegram_channels(channels)
            message.chat.send_text(f"✅ @{username} удалён из списка.\n(пушить перестаём, канал Delta Chat остаётся)")
    
        
        elif subcmd.startswith("description "):
            identifier = subcmd[12:].strip().lstrip('@')
            ch = next((c for c in channels if c['username'] == identifier), None)
            if not ch:
                message.chat.send_text(f"Канал @{identifier} не найден.")
                return
            set_pending_channel(chat_id, identifier, ch['broadcast_chat_id'], "description")
            message.chat.send_text(f"✏️ Введите описание для канала @{identifier}:")

        elif subcmd.startswith("image "):
            identifier = subcmd[6:].strip().lstrip('@')
            ch = next((c for c in channels if c['username'] == identifier), None)
            if not ch:
                message.chat.send_text(f"Канал @{identifier} не найден.")
                return
            set_pending_channel(chat_id, identifier, ch['broadcast_chat_id'], "image")
            message.chat.send_text(f"🖼 Отправьте изображение для канала @{identifier}:")

        else:
            message.chat.send_text("Команды /channels:\n/list — список каналов\n/add username — создать broadcast канал\n/invite username — QR для подписки\n/description username — изменить описание\n/image username — изменить изображение\n/remove username — удалить из списка")
    
    
    elif text.startswith("/telegram"):
        parts = text.split(maxsplit=2)
        if len(parts) < 2:
            message.chat.send_text("Использование: /telegram username [N]\n/telegram markettwits 10\nМаксимум: 100")
    
            return
        
        username = parts[1].strip().lstrip('@')
        limit = 10
        if len(parts) > 2:
            try:
                limit = min(int(parts[2]), 100)
            except:
                pass
        
        posts, channel_title, _, _, error = get_telegram_feed(username, limit)
        if error:
            message.chat.send_text(f"❌ {error}")
    
            return
        
        if not posts:
            message.chat.send_text("Посты не найдены.")
    
            return
        
        display_name = channel_title or username
        msg_text = f"📺 {display_name}\nПоследние {len(posts)} постов:\n\n"
        for i, post in enumerate(posts, 1):
            text = re.sub(r'<[^>]+>', '', (post.get('description') or post.get('title', '')))[:200]
            link = post.get('link', '')
            msg_text += f"{i}. {text}\n{link}\n\n"
        
        message.chat.send_text(msg_text)

    
    elif text.startswith("/save") or text.startswith("/s "):
        logger.info(f"/save command received, text='{text}', file={message.file}")
        if get_pending_save(chat_id):
            message.chat.send_text("Дождитесь ответа на предыдущий запрос.")
    
            return
        
        parts = text.split(maxsplit=1)
        save_path = parts[1].strip() if len(parts) > 1 else ""
        
        file_blob = message.file
        logger.info(f"file_blob: {file_blob}")
        
        if not file_blob:
            message.chat.send_text("Прикрепите файл и укажите путь: /save /путь/к/файлу")
            return
        
        if not save_path:
            message.chat.send_text("Укажите путь для сохранения: /save /путь/к/файлу")
            return
        
        if ".." in save_path:
            message.chat.send_text("Путь не должен содержать ..")
            return
        
        abs_path = os.path.abspath(os.path.expanduser(save_path))
        
        if save_path.endswith('/'):
            message.chat.send_text("Укажите имя файла: /save /путь/к/файлу")
            return
        
        if os.path.isdir(abs_path):
            file_name = getattr(message, 'filename', None) or 'file'
            abs_path = os.path.join(abs_path, file_name)
        
        allowed = False
        for prefix in DEFAULT_SAVE_DIRS + [BOT_DIR, SAVE_DIR]:
            if abs_path.startswith(os.path.abspath(prefix)):
                allowed = True
                break
        
        if not allowed:
            message.chat.send_text(f"Недопустимый путь. Разрешены: /tmp/, ~/")
            return
        
        file_blob_clean = file_blob.replace("accounts/", "", 1) if file_blob.startswith("accounts/") else file_blob
        file_path = os.path.realpath(os.path.join(ACCOUNTS_DIR, file_blob_clean))
        logger.info(f"file_path: {file_path}")

        if not file_path.startswith(os.path.realpath(ACCOUNTS_DIR) + os.sep):
            message.chat.send_text("Недопустимый путь файла.")
            return

        if not os.path.exists(file_path):
            message.chat.send_text("Не удалось найти файл.")
            return

        MAX_SAVE_SIZE = 50 * 1024 * 1024  # 50 MB
        if os.path.getsize(file_path) > MAX_SAVE_SIZE:
            message.chat.send_text("Файл слишком большой (макс. 50 МБ).")
            return

        with open(file_path, 'rb') as f:
            file_bytes = f.read()
        
        logger.info(f"Read {len(file_bytes)} bytes from file")
        
        file_name = os.path.basename(abs_path)
        exists = os.path.exists(abs_path)
        
        if exists:
            msg_text = f"⚠️ Файл {file_name} уже существует.\nЗаменить? [Да / Нет]"
        else:
            msg_text = f"📄 Сохранить файл {file_name}?\nПуть: {abs_path}\n[Да / Нет]"
        
        message.chat.send_text(msg_text)
        set_pending_save(chat_id, file_name, abs_path, base64.b64encode(file_bytes).decode())

    
    elif get_pending_channel(chat_id):
        pc = get_pending_channel(chat_id)
        account = message.chat.account
        cancel_words = ['отмена', 'cancel', 'нет', 'no', 'n']
        try:
            chat = account.get_chat_by_id(pc['broadcast_chat_id'])
        except:
            message.chat.send_text("Ошибка: канал не найден.")
            clear_pending_channel(chat_id)
            return

        if text.lower() in cancel_words:
            clear_pending_channel(chat_id)
            message.chat.send_text("Операция отменена.")
            return

        if pc['action'] == "description":
            if not text:
                message.chat.send_text("Введите текст описания.")
                return
            try:
                chat._rpc.set_chat_description(account.id, chat.id, text)
                channels = load_telegram_channels()
                for ch in channels:
                    if ch['username'] == pc['username']:
                        ch['description'] = text
                        break
                save_telegram_channels(channels)
                message.chat.send_text(f"✅ Описание канала @{pc['username']} обновлено.")
            except Exception as e:
                message.chat.send_text(f"❌ Ошибка: {e}")
            clear_pending_channel(chat_id)
            return

        elif pc['action'] == "image":
            file_path = message.file
            if not file_path:
                message.chat.send_text("Прикрепите изображение к сообщению.")
                return
            try:
                clean = file_path.replace("accounts/", "", 1) if file_path.startswith("accounts/") else file_path
                abs_path = os.path.realpath(os.path.join(ACCOUNTS_DIR, clean))
                if not abs_path.startswith(os.path.realpath(ACCOUNTS_DIR) + os.sep):
                    message.chat.send_text("Недопустимый путь файла.")
                    clear_pending_channel(chat_id)
                    return
                if not os.path.exists(abs_path):
                    message.chat.send_text("Не удалось найти файл изображения.")
                    clear_pending_channel(chat_id)
                    return
                chat.set_image(abs_path)
                message.chat.send_text(f"✅ Изображение канала @{pc['username']} обновлено.")
            except Exception as e:
                message.chat.send_text(f"❌ Ошибка: {e}")
            clear_pending_channel(chat_id)
            return

    elif get_pending_save(chat_id):
        pending = get_pending_save(chat_id)
        logger.info(f"Pending save for chat_id={chat_id}: {pending is not None}")
        if not pending:
            message.chat.send_text("Нет ожидающего сохранения.")
            return
        path = pending['path']
        base64_data = pending.get('base64', '')
        
        if text.lower() in ['да', 'yes', 'y', 'а', 'lf']:
            try:
                file_bytes = base64.b64decode(base64_data)
                os.makedirs(os.path.dirname(path), exist_ok=True)
                if os.path.exists(path):
                    os.rename(path, path + ".backup")
                with open(path, 'wb') as f:
                    f.write(file_bytes)
                message.chat.send_text(f"✅ Файл сохранён: {path}")
                if path.endswith('.py'):
                    message.chat.send_text("⚠️ Для активации: systemctl restart deltabot")
                clear_pending_save(chat_id)
            except Exception as e:
                message.chat.send_text(f"Ошибка сохранения: {e}")
                clear_pending_save(chat_id)
        elif text.lower() in ['нет', 'no', 'n', 'ytn']:
            message.chat.send_text("Сохранение отменено.")
            clear_pending_save(chat_id)
        else:
            message.chat.send_text("Ответьте [Да] или [Нет]")

    
    elif text.startswith("/join"):
        sub = text.split(maxsplit=1)
        if len(sub) < 2:
            message.chat.send_text("Использование: /join https://i.delta.chat/#...")
            return
        value = sub[1].strip()
        account = message.chat.account

        if re.match(r'https://i\.delta\.chat/#', value):
            message.chat.send_text("⏳ Запускаю secure join...")
            threading.Thread(target=_process_secure_join, args=(account, message.chat, value), daemon=True).start()
            return

        message.chat.send_text("Некорректная ссылка. Используй /join https://i.delta.chat/#...")

    elif text == "/qr":
        try:
            account = message.chat.account
            qr = account.get_qr_code()
            logger.info(f"Account QR code: {qr}")
            message.chat.send_text(f"🔗 QR код для добавления бота:\n\n{qr}")
        except Exception as e:
            logger.error(f"Error getting QR: {e}")
            message.chat.send_text(f"❌ Ошибка: {e}")

    elif text == "/help":
        message.chat.send_text(HELP_TEXT)

    elif text.startswith("/addcontact"):
        parts = text.split(maxsplit=1)
        email = parts[1].strip().lower() if len(parts) > 1 else ""
        if not email:
            message.chat.send_text("Использование: /addcontact email@example.com или *@domain.org")
        elif "@" not in email or "." not in email.split("@")[-1]:
            message.chat.send_text("Неверный формат. Примеры: user@example.com или *@example.com")
        else:
            try:
                sender_data = account._rpc.get_contact(account.id, from_id)
                if not sender_data.get('isVerified', False):
                    message.chat.send_text("Только верифицированные контакты (SecureJoin) могут добавлять новых.")
                else:
                    allowed = load_allowed_contacts()
                    allowed.add(email)
                    save_allowed_contacts(allowed)
                    message.chat.send_text(f"Контакт {email} добавлен в белый список.")
            except Exception as e:
                message.chat.send_text(f"Ошибка: {e}")

    elif text.startswith("/contacts"):
        parts = text.split(maxsplit=1)
        subcmd = parts[1].strip().lower() if len(parts) > 1 else "list"
        if subcmd == "list":
            allowed = load_allowed_contacts()
            if not allowed:
                message.chat.send_text("Белый список пуст. Доступ только через SecureJoin/QR.")
            else:
                message.chat.send_text("Разрешённые контакты:\n" + "\n".join(sorted(allowed)))
        elif subcmd.startswith("remove "):
            email = subcmd[7:].strip().lower()
            try:
                sender_data = account._rpc.get_contact(account.id, from_id)
                if not sender_data.get('isVerified', False):
                    message.chat.send_text("Только верифицированные контакты могут удалять из списка.")
                else:
                    allowed = load_allowed_contacts()
                    if email in allowed:
                        allowed.discard(email)
                        save_allowed_contacts(allowed)
                        message.chat.send_text(f"Контакт {email} удалён из белого списка.")
                    else:
                        message.chat.send_text(f"{email} не найден в белом списке.")
            except Exception as e:
                message.chat.send_text(f"Ошибка: {e}")
        else:
            message.chat.send_text("/contacts list — список\n/contacts remove <email> — удалить")

    elif text.startswith("/ai"):
        parts = text.split(maxsplit=1)
        subcmd = parts[1].strip().lower() if len(parts) > 1 else ""

        if subcmd == "on":
            session = ai_agent.load_session(str(chat_id))
            session["enabled"] = True
            ai_agent.save_session(str(chat_id), session)
            message.chat.send_text(f"🤖 AI включён. Модель: {session.get('model', ai_agent.DEFAULT_MODEL)}\n\n"
                "Любое сообщение → AI ответ.\n"
                "/ai off — выключить | /model — сменить модель")

        elif subcmd == "off":
            session = ai_agent.load_session(str(chat_id))
            session["enabled"] = False
            ai_agent.save_session(str(chat_id), session)
            message.chat.send_text("🤖 AI выключен.")

        elif subcmd == "reset":
            session = ai_agent.load_session(str(chat_id))
            session["messages"] = []
            ai_agent.save_session(str(chat_id), session)
            message.chat.send_text("🤖 История очищена.")

        elif subcmd == "status":
            session = ai_agent.load_session(str(chat_id))
            enabled = "✅" if session.get("enabled") else "❌"
            model = session.get("model", ai_agent.DEFAULT_MODEL)
            msgs = len(session.get("messages", []))
            has_key = "✅" if ai_agent.get_api_key(str(chat_id)) else "❌"
            message.chat.send_text(f"🤖 {enabled} Модель: {model}\nСообщений: {msgs} | Ключ: {has_key}")

        elif subcmd == "summary":
            try:
                result = ai_agent.summarize_session(str(chat_id))
                message.chat.send_text(strip_markdown(result))
            except Exception as e:
                message.chat.send_text(f"Ошибка: {e}")

        else:
            session = ai_agent.load_session(str(chat_id))
            enabled = "✅" if session.get("enabled") else "❌"
            model = session.get("model", ai_agent.DEFAULT_MODEL)
            message.chat.send_text(f"🤖 /ai on — включить ({enabled})\n"
                f"/ai off — выключить\n/model — сменить модель ({model})\n/apikey — ключ")

    elif text.startswith("/model"):
        parts = text.split(maxsplit=1)
        model_arg = parts[1].strip().lower() if len(parts) > 1 else ""

        if not model_arg:
            models_list = "\n".join([f"• `{k}` — {v}" for k, v in ai_agent.MODELS.items()])
            session = ai_agent.load_session(str(chat_id))
            current = session.get("model", ai_agent.DEFAULT_MODEL)
            message.chat.send_text(f"🤖 Текущая: {current}\n\n{models_list}\n\n/model deepseek — выбрать")

        else:
            matched = None
            for model_name in ai_agent.MODELS:
                if model_arg in model_name.lower():
                    matched = model_name
                    break

            if matched:
                session = ai_agent.load_session(str(chat_id))
                session["model"] = matched
                ai_agent.save_session(str(chat_id), session)
                message.chat.send_text(f"🤖 → {matched}")
            else:
                message.chat.send_text(f"❌ Не найдена '{model_arg}'. /model — список")

    elif text.startswith("/apikey"):
        parts = text.split(maxsplit=1)
        key = parts[1].strip() if len(parts) > 1 else ""

        if not key:
            has_key = "✅" if ai_agent.get_api_key(str(chat_id)) else "❌"
            message.chat.send_text(f"🔑 Ключ: {has_key}\n/apikey [ключ] — установить (sk-or-...)")
        else:
            session = ai_agent.load_session(str(chat_id))
            session["api_key"] = key
            ai_agent.save_session(str(chat_id), session)
            message.chat.send_text(f"🔑 Установлен ({key[:8]}...{key[-4:]})")

    elif text.startswith("/note"):
        parts = text.split(maxsplit=1)
        subcmd = parts[1].strip() if len(parts) > 1 else ""

        if subcmd.lower().startswith("add "):
            note_text = subcmd[4:].strip()
            if note_text:
                nid = add_note(chat_id, note_text)
                message.chat.send_text(f"Заметка #{nid} сохранена.")
            else:
                message.chat.send_text("Использование: /note add <текст>")

        elif subcmd.lower() in ("list", "список", ""):
            notes = get_notes(chat_id)
            if not notes:
                message.chat.send_text("Заметок нет. /note add <текст> — добавить.")
            else:
                lines = [f"Заметки ({len(notes)}):"]
                for n in notes:
                    lines.append(f"{n['id']}. {n['text']}")
                message.chat.send_text("\n".join(lines))

        elif subcmd.lower().startswith("delete ") or subcmd.lower().startswith("удалить "):
            id_part = subcmd.split(maxsplit=1)[1].strip()
            if id_part.isdigit():
                if delete_note(chat_id, int(id_part)):
                    message.chat.send_text(f"Заметка #{id_part} удалена.")
                else:
                    message.chat.send_text(f"Заметка #{id_part} не найдена.")
            else:
                message.chat.send_text("Использование: /note delete <номер>")

        else:
            message.chat.send_text(
                "/note add <текст> — добавить\n"
                "/note list — список\n"
                "/note delete <N> — удалить"
            )

    elif text.startswith("/rate"):
        parts = text.split()
        currencies = parts[1:] if len(parts) > 1 else ["USD", "EUR", "CNY", "GBP"]
        currencies = [c.upper() for c in currencies]
        try:
            rates = get_exchange_rates()
            date_str = datetime.now(IRKUTSK_TZ).strftime("%d.%m.%Y")
            lines = [f"Курс ЦБ РФ на {date_str}:"]
            for code in currencies:
                if code in rates:
                    nominal, value, name = rates[code]
                    if nominal == 1:
                        lines.append(f"{code} — {value:,.2f} ₽  ({name})")
                    else:
                        lines.append(f"{nominal} {code} — {value:,.2f} ₽  ({name})")
                else:
                    lines.append(f"{code} — не найдено")
            message.chat.send_text("\n".join(lines))
        except Exception as e:
            message.chat.send_text(f"Ошибка получения курса: {e}")

    elif text.startswith("/ip"):
        parts = text.split(maxsplit=1)
        target = parts[1].strip() if len(parts) > 1 else ""
        logger.info(f"=== /ip called: chat_id={chat_id}, target='{target}'")
        try:
            if not target:
                r = requests.get("https://api.ipify.org?format=json", timeout=10)
                r.raise_for_status()
                ip = r.json()["ip"]
                logger.info(f"=== /ip result: ip={ip}")
                message.chat.send_text(f"Внешний IP сервера: {ip}")
            else:
                info = lookup_ip_info(target)
                lines = [f"IP: {info.get('ip', target)}"]
                if info.get("country"):
                    lines.append(f"Страна: {info['country']}")
                if info.get("city"):
                    lines.append(f"Город: {info['city']}")
                if info.get("org"):
                    lines.append(f"Org: {info['org']}")
                if info.get("hostname"):
                    lines.append(f"Hostname: {info['hostname']}")
                message.chat.send_text("\n".join(lines))
        except Exception as e:
            message.chat.send_text(f"Ошибка: {e}")

    elif text.startswith("/dns"):
        parts = text.split(maxsplit=1)
        domain = parts[1].strip() if len(parts) > 1 else ""
        if not domain:
            message.chat.send_text("Использование: /dns <домен>")
        else:
            try:
                addrs = dns_lookup(domain)
                lines = [f"DNS: {domain}"]
                for addr in addrs[:10]:
                    lines.append(f"  {addr}")
                message.chat.send_text("\n".join(lines))
            except Exception as e:
                message.chat.send_text(f"Ошибка DNS: {e}")

    elif text.startswith("/monitor"):
        parts = text.split(maxsplit=1)
        subcmd = parts[1].strip().lower() if len(parts) > 1 else ""
        monitors = load_monitors()

        if subcmd.startswith("add "):
            url = subcmd[4:].strip()
            if not url.startswith("http"):
                url = "https://" + url
            if any(m["url"] == url for m in monitors):
                message.chat.send_text(f"Уже в мониторинге: {url}")
            else:
                ok, detail = check_url(url)
                monitors.append({
                    "url": url,
                    "added_chat": chat_id,
                    "last_ok": ok,
                    "last_check": time.time(),
                    "last_detail": detail,
                })
                save_monitors(monitors)
                status = "доступен" if ok else f"НЕДОСТУПЕН ({detail})"
                message.chat.send_text(f"Добавлен: {url}\nСтатус: {status}")

        elif subcmd in ("list", "список", ""):
            if not monitors:
                message.chat.send_text("Список пуст. /monitor add <url>")
            else:
                lines = [f"Мониторинг ({len(monitors)}):"]
                for i, m in enumerate(monitors, 1):
                    icon = "OK" if m.get("last_ok") else "DOWN"
                    checked = datetime.fromtimestamp(m["last_check"], tz=IRKUTSK_TZ).strftime("%H:%M") if m.get("last_check") else "—"
                    lines.append(f"{i}. [{icon}] {m['url']} (проверен {checked})")
                message.chat.send_text("\n".join(lines))

        elif subcmd.startswith("remove "):
            arg = subcmd[7:].strip()
            if arg.isdigit():
                idx = int(arg) - 1
                if 0 <= idx < len(monitors):
                    removed = monitors.pop(idx)
                    save_monitors(monitors)
                    message.chat.send_text(f"Удалён: {removed['url']}")
                else:
                    message.chat.send_text("Неверный номер. /monitor list — список.")
            else:
                url = arg if arg.startswith("http") else "https://" + arg
                before = len(monitors)
                monitors = [m for m in monitors if m["url"] != url]
                if len(monitors) < before:
                    save_monitors(monitors)
                    message.chat.send_text(f"Удалён: {url}")
                else:
                    message.chat.send_text(f"Не найден: {url}")

        elif subcmd == "check":
            if not monitors:
                message.chat.send_text("Список пуст.")
            else:
                lines = ["Проверка:"]
                for m in monitors:
                    ok, detail = check_url(m["url"])
                    m["last_ok"] = ok
                    m["last_check"] = time.time()
                    m["last_detail"] = detail
                    icon = "OK" if ok else f"DOWN: {detail}"
                    lines.append(f"[{icon}] {m['url']}")
                save_monitors(monitors)
                message.chat.send_text("\n".join(lines))
        else:
            message.chat.send_text(
                "Мониторинг сайтов:\n"
                "/monitor add <url> — добавить\n"
                "/monitor list — список\n"
                "/monitor remove <N|url> — удалить\n"
                "/monitor check — проверить сейчас"
            )

    elif text.startswith("/cal"):
        parts = text.split(maxsplit=1)
        subcmd = parts[1].strip().lower() if len(parts) > 1 else ""

        if subcmd in ("today", "сегодня"):
            try:
                evs = cal_list_events(days_ahead=1)
                if not evs:
                    message.chat.send_text("Сегодня событий нет.")
                else:
                    lines = [f"Сегодня ({len(evs)}):"]
                    for ev in evs:
                        lines.append(_format_event(ev))
                    message.chat.send_text("\n".join(lines))
            except Exception as e:
                message.chat.send_text(f"Ошибка CalDAV: {e}")

        elif subcmd in ("week", "неделя"):
            try:
                evs = cal_list_events(days_ahead=7)
                if not evs:
                    message.chat.send_text("На неделю событий нет.")
                else:
                    lines = [f"Ближайшие 7 дней ({len(evs)}):"]
                    for ev in evs:
                        lines.append(_format_event(ev))
                    message.chat.send_text("\n".join(lines))
            except Exception as e:
                message.chat.send_text(f"Ошибка CalDAV: {e}")

        elif subcmd.startswith("list"):
            try:
                list_parts = subcmd.split()
                days = int(list_parts[1]) if len(list_parts) > 1 and list_parts[1].isdigit() else 30
                evs = cal_list_events(days_ahead=days)
                if not evs:
                    message.chat.send_text(f"Нет событий на {days} дней.")
                else:
                    lines = [f"События на {days} дней ({len(evs)}):"]
                    for ev in evs:
                        lines.append(_format_event(ev, show_uid=True))
                    message.chat.send_text("\n".join(lines))
            except Exception as e:
                message.chat.send_text(f"Ошибка CalDAV: {e}")

        elif subcmd.startswith("add") or subcmd.startswith("добавить"):
            # Форматы:
            # /cal add сегодня 15:00 Весь текст как название
            # /cal add 22 июня 12:00 Весь текст как название
            # /cal add 12.06 14:30 Весь текст как название
            # /cal add 15.06.2026 09:00 Весь текст как название
            rest = subcmd.split(maxsplit=1)[1].strip() if " " in subcmd else ""
            words = rest.split()
            # Определяем, занимает ли дата 1 или 2 слова
            if len(words) >= 4 and words[1].lower() in RU_MONTHS:
                # "22 июня 12:00 текст..."
                date_s = f"{words[0]} {words[1]}"
                time_s = words[2]
                title = " ".join(words[3:])
            else:
                # "сегодня 12:00 текст..." или "22.06 12:00 текст..."
                parts = rest.split(maxsplit=2)
                date_s = parts[0] if len(parts) > 0 else ""
                time_s = parts[1] if len(parts) > 1 else ""
                title = parts[2] if len(parts) > 2 else ""

            if not title:
                message.chat.send_text(
                    "Использование: /cal add <дата> <время> <название>\n"
                    "Дата: сегодня, завтра, ДД.ММ, ДД.ММ.ГГГГ, 22 июня\n"
                    "Пример: /cal add сегодня 15:00 Встреча с командой"
                )
            else:
                try:
                    dt_start = _parse_cal_datetime(date_s, time_s)
                    uid = cal_add_event(title, dt_start)
                    local_dt = dt_start.replace(tzinfo=timezone(IRKUTSK_OFFSET)) if dt_start.tzinfo is None else dt_start
                    date_fmt = local_dt.strftime("%d.%m.%Y %H:%M")
                    message.chat.send_text(
                        f"Добавлено: {title}\n{date_fmt}\nID: {uid[:8]}"
                    )
                except ValueError as e:
                    message.chat.send_text(f"Ошибка: {e}")
                except Exception as e:
                    message.chat.send_text(f"Ошибка CalDAV: {e}")

        elif subcmd.startswith("delete") or subcmd.startswith("удалить"):
            uid_prefix = subcmd.split(maxsplit=1)[1].strip() if " " in subcmd else ""
            if not uid_prefix:
                message.chat.send_text(
                    "Использование: /cal delete <ID>\n"
                    "ID можно узнать через /cal list"
                )
            else:
                try:
                    # Поиск полного UID по префиксу (8 символов)
                    evs = cal_list_events(days_ahead=365)
                    matched = [e for e in evs if e.get("uid", "").startswith(uid_prefix)]
                    if not matched:
                        message.chat.send_text(f"Событие с ID {uid_prefix}... не найдено.")
                    elif len(matched) > 1:
                        lines = ["Несколько совпадений, уточните ID:"]
                        for ev in matched:
                            lines.append(_format_event(ev, show_uid=True))
                        message.chat.send_text("\n".join(lines))
                    else:
                        full_uid = matched[0]["uid"]
                        title = matched[0].get("summary", "?")
                        cal_delete_event(full_uid)
                        message.chat.send_text(f"Удалено: {title}")
                except Exception as e:
                    message.chat.send_text(f"Ошибка CalDAV: {e}")

        else:
            message.chat.send_text(
                "Управление календарём:\n"
                "/cal today — события на сегодня\n"
                "/cal week — события на неделю\n"
                "/cal list [дней] — список событий (до. /cal list 14)\n"
                "/cal add <дата> <время> <название> [описание]\n"
                "  Дата: сегодня, завтра, ДД.ММ, ДД.ММ.ГГГГ\n"
                "  Пример: /cal add завтра 10:00 Встреча\n"
                "/cal delete <ID> — удалить событие по ID"
            )

    elif text and not text.startswith("/"):
        if ai_agent.is_ai_enabled(str(chat_id)):
            try:
                response = ai_agent.process_message(str(chat_id), text)
                message.chat.send_text(strip_markdown(response))
            except Exception as e:
                message.chat.send_text(f"❌ Ошибка: {e}")
        else:
            message.chat.send_text(HELP_TEXT)


def strip_markdown(text):
    text = re.sub(r'\\([\\`*_{}[\]()#+.!-])', r'\1', text)
    text = re.sub(r'```[\s\S]*?```', '', text)
    text = re.sub(r'`([^`]+)`', r'\1', text)
    text = re.sub(r'\*\*([^*]+?)\*\*', r'\1', text)
    text = re.sub(r'(?<!\*)\*([^*]+?)\*(?!\*)', r'\1', text)
    text = re.sub(r'__([^_]+?)__', r'\1', text)
    text = re.sub(r'(?<!\S)_(\S[\s\S]*?\S)_(?!\S)', r'\1', text)
    urls = []
    def _link_repl(m):
        t = m.group(1).strip()
        u = m.group(2).strip()
        if t:
            urls.append(u)
            return t
        return u
    text = re.sub(r'(?<!!)\[([^\]]*)\]\(([^)]*)\)', _link_repl, text)
    text = re.sub(r'!\[([^\]]*)\]\(([^)]*)\)', r'\1', text)
    text = re.sub(r'^#{1,6}\s+', '', text, flags=re.MULTILINE)
    text = re.sub(r'^([-*_]\s?){3,}$', '', text, flags=re.MULTILINE)
    text = re.sub(r'^>\s?', '', text, flags=re.MULTILINE)
    text = re.sub(r'^[\s]*[-*+]\s+', '', text, flags=re.MULTILINE)
    text = re.sub(r'^[\s]*\d+\.\s+', '', text, flags=re.MULTILINE)
    if urls:
        text += '\n\n---\n' + '\n'.join(urls)
    text = re.sub(r'\n{3,}', '\n\n', text)
    return text.strip()

def extract_post_id(link):
    match = re.search(r'/(\d+)$', link)
    return match.group(1) if match else ""


def telegram_poll_worker(account):
    while True:
        try:
            channels = load_telegram_channels()
            for ch in channels:
                if not ch.get('broadcast_chat_id'):
                    continue

                username = ch['username']
                last_id_str = ch.get('last_post_id', '')
                last_id = int(last_id_str) if last_id_str and last_id_str.isdigit() else 0

                t0 = time.time()
                posts, channel_title, _, _, error = get_telegram_feed(username, 10)
                elapsed = time.time() - t0
                if error or not posts:
                    logger.warning(f"TG Broadcast: Skipping {username} ({elapsed:.1f}s): {error or 'no posts'}")
                    continue
                logger.info(f"TG Broadcast: Fetched {username} ({elapsed:.1f}s, {len(posts)} posts)")

                new_posts = []
                for post in reversed(posts):
                    pid_str = extract_post_id(post.get('link', ''))
                    if pid_str and pid_str.isdigit():
                        pid = int(pid_str)
                        if pid > last_id:
                            new_posts.append(post)
                            last_id = pid

                if not new_posts:
                    continue

                for post in new_posts:
                    pid_str = extract_post_id(post.get('link', ''))
                    pid = int(pid_str) if pid_str and pid_str.isdigit() else 0
                    logger.info(f"TG Broadcast: New post in {username}: {pid}")

                    broadcast_id = ch['broadcast_chat_id']
                    desc_html = post.get('description') or ''
                    enc_url = post.get('enclosure_url', '') or ''
                    title = ch.get('title', username)

                    text = re.sub(r'<a\s+[^>]*><img\s+[^>]*></a>\s*', '', desc_html)
                    text = re.sub(r'</?tg-emoji[^>]*>', '', text)

                    # Extract URLs from <a> tags, keep only link text. Skip max.ru
                    link_urls = []
                    def collect_url(m):
                        url = m.group(1)
                        linktext = m.group(2).strip()
                        if 'max.ru' not in url.lower():
                            link_urls.append(url)
                        return linktext if linktext else url
                    text = re.sub(r'<a\s+[^>]*?href="([^"]*)"[^>]*>\s*(.*?)\s*</a>', collect_url, text, flags=re.DOTALL)
                    text = re.sub(r'<br\s*/?>', '\n', text, flags=re.IGNORECASE)
                    text = re.sub(r'<[^>]+>', '', text)
                    text = html.unescape(text).strip()
                    text = re.sub(r'\n{3,}', '\n\n', text)
                    text = re.sub(r' {2,}', ' ', text)

                    # Append extracted URLs as footnotes (skip duplicates and URLs already in text)
                    seen = set()
                    footer_links = []
                    for u in link_urls:
                        if u not in seen and u not in text:
                            seen.add(u)
                            footer_links.append(u)
                    if footer_links:
                        text += '\n\n---\n' + '\n'.join(footer_links)

                    logger.info(f"TG Broadcast: Post {pid} enc_url={'yes' if enc_url else 'no'}, text_len={len(text)}")
                    try:
                        msg_data = {"text": text}
                        tmp_path = None
                        enc_type = post.get('enclosure_type', '')
                        if enc_url and enc_type.startswith('image/'):
                            try:
                                logger.info(f"TG Broadcast: Downloading {enc_url}")
                                img_resp = requests.get(enc_url, timeout=60, headers={'User-Agent': 'Mozilla/5.0'})
                                if img_resp.status_code == 200:
                                    ext = enc_type.split('/')[-1] if '/' in enc_type else 'jpg'
                                    with tempfile.NamedTemporaryFile(suffix=f'.{ext}', delete=False) as f:
                                        f.write(img_resp.content)
                                        tmp_path = f.name
                                    logger.info(f"TG Broadcast: Downloaded {len(img_resp.content)} bytes -> {tmp_path}")
                                    msg_data["file"] = tmp_path
                                else:
                                    logger.debug(f"TG Broadcast: Download returned {img_resp.status_code}")
                            except Exception as e:
                                logger.debug(f"TG Broadcast: Download failed: {e}")
                        account._rpc.send_msg(account.id, broadcast_id, msg_data)
                        if tmp_path:
                            os.unlink(tmp_path)
                        ch['last_post_id'] = pid_str
                        ch['title'] = channel_title if channel_title else ch.get('title', username)
                        save_telegram_channels(channels)
                        logger.info(f"TG Broadcast: Sent to {username}, pid={pid}")
                    except Exception as e:
                        logger.error(f"TG Broadcast: Error sending {pid}: {e}")

        except Exception as e:
            logger.error(f"TG Broadcast: Poll error: {e}")

        time.sleep(TG_POLL_INTERVAL)

def send_daily_status_worker(account):
    while True:
        now_irkutsk = datetime.now(IRKUTSK_TZ)
        target_time = now_irkutsk.replace(hour=9, minute=0, second=0, microsecond=0)
        if now_irkutsk >= target_time:
            target_time += timedelta(days=1)
        
        wait_seconds = (target_time - now_irkutsk).total_seconds()
        logger.info(f"Next status report at {target_time.strftime('%Y-%m-%d %H:%M:%S')} (Irkutsk time). Waiting {wait_seconds/3600:.1f} hours.")
        time.sleep(wait_seconds)
        
        server_status = get_system_status()
        weather = get_weather(DEFAULT_CITY)
        report = f"{server_status}\n\n{weather}"

        try:
            evs = cal_list_events(days_ahead=1)
            if evs:
                cal_lines = [f"\nСобытия на сегодня ({len(evs)}):"]
                for ev in evs:
                    cal_lines.append(_format_event(ev))
                report += "\n" + "\n".join(cal_lines)
            else:
                report += "\n\nСобытий на сегодня нет."
        except Exception as e:
            logger.warning(f"CalDAV daily report error: {e}")

        subscribers = load_subscribers()
        for accid, chat_id in list(subscribers):
            try:
                account._rpc.send_msg(account.id, chat_id, {"text": report})
            except Exception as e:
                logger.error(f"Error sending daily status: {e}")

def _process_secure_join(account, reply_chat, qr_code):
    try:
        info = account._rpc.check_qr(account.id, qr_code)
        logger.info(f"check_qr result: {info}")
    except Exception as e:
        logger.warning(f"check_qr failed: {e}")
        info = None
    try:
        result = account._rpc.secure_join(account.id, qr_code)
        logger.info(f"secure_join result: {result}")
        reply_chat.send_text(f"✅ Secure join завершён: {result}")
    except Exception as e:
        logger.error(f"secure_join error: {e}")
        reply_chat.send_text(f"❌ Secure join не удался: {e}\ninfo={info}")

def main():
    rpc_server_path = "/home/alexabudaev/delta-bot/.venv/bin/deltachat-rpc-server"
    
    with Rpc(rpc_server_path=rpc_server_path) as rpc:
        deltachat = DeltaChat(rpc)
        system_info = deltachat.get_system_info()
        logger.info(f"Running deltachat core {system_info.deltachat_core_version}")
        
        accounts = deltachat.get_all_accounts()
        if not accounts:
            logger.error("No accounts found. Please configure an account first.")
            sys.exit(1)
        
        account = accounts[0]
        
        if not account.is_configured():
            logger.error("Account is not configured.")
            sys.exit(1)
        
        account.set_config("bot", "1")
        if not account.get_config("displayname"):
            account.set_config("displayname", "DeltaBot")
        account.set_config("selfstatus", "Delta Chat Bot - /help")
        account.set_config("imap_certificate_checks", "2")
        
        logger.info("Account configured, starting IO...")
        deltachat.start_io()
        
        bot = Bot(account, hooks)
        
        threading.Thread(target=telegram_poll_worker, args=(account,), daemon=True).start()
        threading.Thread(target=send_daily_status_worker, args=(account,), daemon=True).start()
        threading.Thread(target=cal_reminder_worker, args=(account,), daemon=True).start()
        threading.Thread(target=monitor_worker, args=(account,), daemon=True).start()
        
        logger.info("Bot started, running forever...")
        bot.run_forever()

if __name__ == "__main__":
    main()