import os
import logging
import asyncio
import pymysql
import time
import html
import httpx
from datetime import datetime, timezone, timedelta
from dotenv import load_dotenv
from formatter import get_event_text

# Загрузка переменных окружения
load_dotenv()

# Настройки из переменных окружения
BOT_TOKEN = os.getenv('POSTER_BOT_TOKEN')
RESPONDER_BOT_NAME = os.getenv('RESPONDER_BOT_NAME')
CHANNEL_ID = os.getenv('CHANNEL_ID')
MDB_HOST = os.getenv('MDB_HOST')
MDB_USER = os.getenv('MDB_USER')
MDB_PW = os.getenv('MDB_PW')
MDBASE = os.getenv('MDBASE')
DESC_PREFIX = os.getenv('DESC_PREFIX')
PZK_PREFIX = os.getenv('PZK_PREFIX')
LOG_FILE = os.getenv('LOG_FILE', 'evtg_publisher.log')
EVENT_POST_DELAY = int(os.getenv('EVENT_POST_DELAY', 0))  # Задержка в минутах
WORKMODE = os.getenv('WORKMODE', 'ZILANT')  # Режим работы: ZILANT или VOLK

# Параметры длины сообщений
MAX_CAPTION_LENGTH = int(os.getenv('MAX_CAPTION_LENGTH', 1000))
MAX_TEXT_LENGTH = int(os.getenv('MAX_TEXT_LENGTH', 4000))

# Режим публикации без звука
PUBLISH_SILENTLY = os.getenv('PUBLISH_SILENTLY', 'false').lower() in ('true', '1', 'yes', 'on')

# Использование бота подписки
USE_SUBSCRIPTION_BOT = os.getenv('USE_SUBSCRIPTION_BOT', 'true').lower() in ('true', '1', 'yes', 'on')

# Настройка логирования
logger = logging.getLogger('TG_EV_post')
logger.setLevel(logging.INFO)

formatter = logging.Formatter('[%(asctime)s] [%(name)s] %(message)s', datefmt='%Y-%m-%d %H:%M:%S')

console_handler = logging.StreamHandler()
console_handler.setFormatter(formatter)
logger.addHandler(console_handler)

class RetryFileHandler(logging.FileHandler):
    def emit(self, record):
        for _ in range(5):
            try:
                super().emit(record)
                return
            except (IOError, PermissionError):
                time.sleep(0.5)
        print(f"Failed to write to log file after 5 attempts: {record.msg}")

file_handler = RetryFileHandler(LOG_FILE, encoding='utf-8')
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)

# Класс для обработки RetryAfter (FloodWait 429)
class RetryAfterException(Exception):
    """Исключение для обработки FloodWait (429) от Telegram API"""
    def __init__(self, retry_after):
        self.retry_after = retry_after
        super().__init__(f"RetryAfter: {retry_after}")

def format_tags(tags_str):
    """Форматирование тегов с добавлением #"""
    if not tags_str:
        return ""
    tags = tags_str.split()
    formatted_tags = []
    for tag in tags:
        if len(tag) > 1 and not tag.startswith('#'):
            formatted_tags.append(f"#{tag}")
        else:
            formatted_tags.append(tag)
    return " ".join(formatted_tags)

def prepare_text(text):
    """Подготовка текстовых полей с экранированием HTML-сущностей"""
    if not text:
        return ""

    # Экранируем специальные символы HTML
    text = html.escape(str(text))

    return text

async def tg_post_event(httpx_client, event_data):
    """Публикация одного события"""
    try:
        # Форматирование текста
        tags = format_tags(event_data['tags'])
        unit_name = prepare_text(event_data['unit_name'] or "")
        name = prepare_text(event_data['name'] or "")

        # Получаем и подготавливаем описание события
        about_raw = event_data['about']

        # Формируем базовый текст (теги + название площадки + название события)
        caption_parts = []
        if tags:
            caption_parts.append(tags)
        if unit_name:
            caption_parts.append(unit_name)
        if name:
            caption_parts.append(f"<b>{name}</b>")
        base_text = "\n".join(caption_parts)
        base_text_length = len(base_text)

        # Предварительный расчет строки ссылок (с запасом 20 символов для message_id)
        number = event_data['number']
        placeholder_message_id = '0' * 20  # Заполнитель для message_id
        
        # Формируем ссылки в зависимости от USE_SUBSCRIPTION_BOT
        if USE_SUBSCRIPTION_BOT:
            links_line_placeholder = f'🔎 <a href="{DESC_PREFIX}{number}/">Инфо</a> | 📌 <a href="{PZK_PREFIX}{number}/">Иду</a> | 🔜 <a href="https://t.me/{RESPONDER_BOT_NAME}?start=event_{placeholder_message_id}">Подписка</a>'
        else:
            links_line_placeholder = f'🔎 <a href="{DESC_PREFIX}{number}/">Инфо</a>'
        links_line_length = len(links_line_placeholder)

        # Определяем максимальную длину в зависимости от типа сообщения
        image_url = event_data['about_social_picture']
        has_image = image_url and image_url.strip()
        max_length = MAX_CAPTION_LENGTH if has_image else MAX_TEXT_LENGTH

        # Вычисляем доступную длину для текста события
        available_length = max_length - base_text_length - links_line_length - 3  # -3 для символов переноса строки
        if available_length < 0:
            available_length = 0

        # Получаем обработанный текст с учетом доступной длины
        about = get_event_text(about_raw, available_length) if about_raw else ""

        # Формируем первоначальный текст
        initial_text = f"{base_text}\n\n{about}" if about else base_text

        # Логируем детальную информацию о данных для публикации
        logger.info(f"=== Детали публикации события номер {event_data['number']} ===")
        logger.info(f"Длина initial_text: {len(initial_text)} символов")
        logger.info(f"Длина base_text: {base_text_length} символов")
        logger.info(f"Длина about: {len(about)} символов")
        logger.info(f"Длина links_line_placeholder: {links_line_length} символов")
        logger.info(f"Максимальная длина (max_length): {max_length} символов")
        logger.info(f"Доступная длина для about: {available_length} символов")
        logger.info(f"Есть изображение: {has_image}")
        if has_image:
            logger.info(f"URL изображения: {image_url}")
            logger.info(f"Длина URL изображения: {len(image_url)} символов")
        logger.info(f"Текст для публикации: {initial_text[:200]}..." if len(initial_text) > 200 else f"Текст для публикации: {initial_text}")

        # Публикация первоначального сообщения без ссылок
        send_photo_url = f"https://api.telegram.org/bot{BOT_TOKEN}/sendPhoto"
        send_message_url = f"https://api.telegram.org/bot{BOT_TOKEN}/sendMessage"
        
        if has_image:
            try:
                logger.info(f"Попытка отправки фото для события {event_data['number']}: chat_id={CHANNEL_ID}, caption_length={len(initial_text)}, image_url_length={len(image_url)}")
                photo_payload = {
                    'chat_id': CHANNEL_ID,
                    'photo': image_url,
                    'caption': initial_text,
                    'parse_mode': 'HTML',
                    'disable_notification': PUBLISH_SILENTLY
                }
                photo_response = await httpx_client.post(send_photo_url, json=photo_payload)
                
                if photo_response.status_code == 200:
                    photo_result = photo_response.json()
                    if photo_result.get('ok'):
                        message_data = photo_result.get('result', {})
                        message_id = message_data.get('message_id')
                        logger.info(f"Фото успешно отправлено для события {event_data['number']}, message_id={message_id}")
                    else:
                        # Ошибка в ответе API - пробуем отправить текстовое сообщение
                        error_code = photo_result.get('error_code')
                        if error_code == 429:
                            # FloodWait - пробрасываем как RetryAfter
                            retry_after = photo_result.get('parameters', {}).get('retry_after', 60)
                            raise Exception(f"RetryAfter:{retry_after}")
                        raise Exception(f"API error: {photo_result.get('description', 'Unknown error')}")
                else:
                    if photo_response.status_code == 429:
                        # FloodWait
                        retry_after = 60
                        try:
                            error_data = photo_response.json()
                            retry_after = error_data.get('parameters', {}).get('retry_after', 60)
                        except:
                            pass
                        raise Exception(f"RetryAfter:{retry_after}")
                    raise Exception(f"HTTP {photo_response.status_code}: {photo_response.text}")
                    
            except httpx.TimeoutException as e:
                logger.error(f"ТАЙМАУТ при отправке изображения для события номер {event_data['number']}")
                logger.error(f"Полная диагностическая информация об ошибке TimedOut:")
                logger.error(f"  Тип ошибки: {type(e).__name__}")
                logger.error(f"  Сообщение: {str(e)}")
                logger.error(f"  Все атрибуты ошибки: {vars(e)}")
                logger.error(f"  Полное представление: {repr(e)}")
                logger.error(f"  Параметры запроса:")
                logger.error(f"    chat_id: {CHANNEL_ID}")
                logger.error(f"    image_url: {image_url}")
                logger.error(f"    caption_length: {len(initial_text)}")
                logger.error(f"    parse_mode: HTML")
                raise
            except Exception as e:
                error_msg = str(e)
                if error_msg.startswith("RetryAfter:"):
                    retry_after = int(error_msg.split(":")[1])
                    raise Exception(f"RetryAfter:{retry_after}")
                logger.warning(f"Не удалось отправить изображение для события номер {event_data['number']}: {e}. Отправляем текстовое сообщение.")
                logger.error(f"Полная информация об ошибке Telegram при отправке изображения для события {event_data['number']}:")
                logger.error(f"  Тип ошибки: {type(e).__name__}")
                logger.error(f"  Сообщение: {str(e)}")
                logger.error(f"  Все атрибуты ошибки: {vars(e) if hasattr(e, '__dict__') else 'N/A'}")
                logger.error(f"  Полное представление: {repr(e)}")
                logger.info(f"Попытка отправки текстового сообщения вместо фото для события {event_data['number']}")
                try:
                    text_payload = {
                        'chat_id': CHANNEL_ID,
                        'text': initial_text,
                        'parse_mode': 'HTML',
                        'disable_notification': PUBLISH_SILENTLY,
                        'disable_web_page_preview': True
                    }
                    text_response = await httpx_client.post(send_message_url, json=text_payload)
                    
                    if text_response.status_code == 200:
                        text_result = text_response.json()
                        if text_result.get('ok'):
                            message_data = text_result.get('result', {})
                            message_id = message_data.get('message_id')
                            logger.info(f"Текстовое сообщение успешно отправлено для события {event_data['number']}, message_id={message_id}")
                        else:
                            error_code = text_result.get('error_code')
                            if error_code == 429:
                                retry_after = text_result.get('parameters', {}).get('retry_after', 60)
                                raise Exception(f"RetryAfter:{retry_after}")
                            raise Exception(f"API error: {text_result.get('description', 'Unknown error')}")
                    else:
                        if text_response.status_code == 429:
                            retry_after = 60
                            try:
                                error_data = text_response.json()
                                retry_after = error_data.get('parameters', {}).get('retry_after', 60)
                            except:
                                pass
                            raise Exception(f"RetryAfter:{retry_after}")
                        raise Exception(f"HTTP {text_response.status_code}: {text_response.text}")
                except httpx.TimeoutException as e:
                    logger.error(f"ТАЙМАУТ при отправке текстового сообщения для события номер {event_data['number']}")
                    logger.error(f"Полная диагностическая информация об ошибке TimedOut:")
                    logger.error(f"  Тип ошибки: {type(e).__name__}")
                    logger.error(f"  Сообщение: {str(e)}")
                    logger.error(f"  Все атрибуты ошибки: {vars(e)}")
                    logger.error(f"  Полное представление: {repr(e)}")
                    logger.error(f"  Параметры запроса:")
                    logger.error(f"    chat_id: {CHANNEL_ID}")
                    logger.error(f"    text_length: {len(initial_text)}")
                    logger.error(f"    parse_mode: HTML")
                    raise
                except Exception as e:
                    error_msg = str(e)
                    if error_msg.startswith("RetryAfter:"):
                        raise
                    raise
        else:
            logger.info(f"Попытка отправки текстового сообщения для события {event_data['number']}: chat_id={CHANNEL_ID}, text_length={len(initial_text)}")
            try:
                text_payload = {
                    'chat_id': CHANNEL_ID,
                    'text': initial_text,
                    'parse_mode': 'HTML',
                    'disable_notification': PUBLISH_SILENTLY,
                    'disable_web_page_preview': True
                }
                text_response = await httpx_client.post(send_message_url, json=text_payload)
                
                if text_response.status_code == 200:
                    text_result = text_response.json()
                    if text_result.get('ok'):
                        message_data = text_result.get('result', {})
                        message_id = message_data.get('message_id')
                        logger.info(f"Текстовое сообщение успешно отправлено для события {event_data['number']}, message_id={message_id}")
                    else:
                        error_code = text_result.get('error_code')
                        if error_code == 429:
                            retry_after = text_result.get('parameters', {}).get('retry_after', 60)
                            raise Exception(f"RetryAfter:{retry_after}")
                        raise Exception(f"API error: {text_result.get('description', 'Unknown error')}")
                else:
                    if text_response.status_code == 429:
                        retry_after = 60
                        try:
                            error_data = text_response.json()
                            retry_after = error_data.get('parameters', {}).get('retry_after', 60)
                        except:
                            pass
                        raise Exception(f"RetryAfter:{retry_after}")
                    raise Exception(f"HTTP {text_response.status_code}: {text_response.text}")
            except httpx.TimeoutException as e:
                logger.error(f"ТАЙМАУТ при отправке текстового сообщения для события номер {event_data['number']}")
                logger.error(f"Полная диагностическая информация об ошибке TimedOut:")
                logger.error(f"  Тип ошибки: {type(e).__name__}")
                logger.error(f"  Сообщение: {str(e)}")
                logger.error(f"  Все атрибуты ошибки: {vars(e)}")
                logger.error(f"  Полное представление: {repr(e)}")
                logger.error(f"  Параметры запроса:")
                logger.error(f"    chat_id: {CHANNEL_ID}")
                logger.error(f"    text_length: {len(initial_text)}")
                logger.error(f"    parse_mode: HTML")
                raise

        # Формируем финальный текст с ссылками
        if USE_SUBSCRIPTION_BOT:
            links_line = f'🔎 <a href="{DESC_PREFIX}{number}/">Инфо</a> | 📌 <a href="{PZK_PREFIX}{number}/">Иду</a> | 🔜 <a href="https://t.me/{RESPONDER_BOT_NAME}?start=event_{message_id}">Подписка</a>'
        else:
            links_line = f'🔎 <a href="{DESC_PREFIX}{number}/">Инфо</a>'
        final_text = f"{initial_text}\n\n{links_line}"

        await asyncio.sleep(2)

        # Редактируем сообщение, добавляя ссылки
        logger.info(f"Попытка редактирования сообщения для события {event_data['number']}: message_id={message_id}, final_text_length={len(final_text)}")
        edit_caption_url = f"https://api.telegram.org/bot{BOT_TOKEN}/editMessageCaption"
        edit_text_url = f"https://api.telegram.org/bot{BOT_TOKEN}/editMessageText"
        
        if has_image:
            try:
                edit_caption_payload = {
                    'chat_id': CHANNEL_ID,
                    'message_id': message_id,
                    'caption': final_text,
                    'parse_mode': 'HTML'
                }
                edit_caption_response = await httpx_client.post(edit_caption_url, json=edit_caption_payload)
                
                if edit_caption_response.status_code == 200:
                    edit_result = edit_caption_response.json()
                    if edit_result.get('ok'):
                        logger.info(f"Подпись успешно отредактирована для события {event_data['number']}")
                    else:
                        # Ошибка при редактировании подписи - пробуем редактировать текст
                        error_code = edit_result.get('error_code')
                        if error_code == 429:
                            retry_after = edit_result.get('parameters', {}).get('retry_after', 60)
                            raise Exception(f"RetryAfter:{retry_after}")
                        raise Exception(f"API error: {edit_result.get('description', 'Unknown error')}")
                else:
                    if edit_caption_response.status_code == 429:
                        retry_after = 60
                        try:
                            error_data = edit_caption_response.json()
                            retry_after = error_data.get('parameters', {}).get('retry_after', 60)
                        except:
                            pass
                        raise Exception(f"RetryAfter:{retry_after}")
                    raise Exception(f"HTTP {edit_caption_response.status_code}: {edit_caption_response.text}")
                    
            except httpx.TimeoutException as e:
                logger.error(f"ТАЙМАУТ при редактировании подписи для события номер {event_data['number']}")
                logger.error(f"Полная диагностическая информация об ошибке TimedOut:")
                logger.error(f"  Тип ошибки: {type(e).__name__}")
                logger.error(f"  Сообщение: {str(e)}")
                logger.error(f"  Все атрибуты ошибки: {vars(e)}")
                logger.error(f"  Полное представление: {repr(e)}")
                logger.error(f"  Параметры запроса:")
                logger.error(f"    chat_id: {CHANNEL_ID}")
                logger.error(f"    message_id: {message_id}")
                logger.error(f"    caption_length: {len(final_text)}")
                logger.error(f"    parse_mode: HTML")
                raise
            except Exception as e:
                error_msg = str(e)
                if error_msg.startswith("RetryAfter:"):
                    raise
                logger.warning(f"Не удалось отредактировать подпись для события номер {event_data['number']}: {e}. Пробуем отредактировать текстовое сообщение.")
                logger.error(f"Полная информация об ошибке Telegram при редактировании подписи для события {event_data['number']}:")
                logger.error(f"  Тип ошибки: {type(e).__name__}")
                logger.error(f"  Сообщение: {str(e)}")
                logger.error(f"  Все атрибуты ошибки: {vars(e) if hasattr(e, '__dict__') else 'N/A'}")
                logger.error(f"  Полное представление: {repr(e)}")
                logger.info(f"Попытка редактирования текста вместо подписи для события {event_data['number']}")
                try:
                    edit_text_payload = {
                        'chat_id': CHANNEL_ID,
                        'message_id': message_id,
                        'text': final_text,
                        'parse_mode': 'HTML',
                        'disable_web_page_preview': True
                    }
                    edit_text_response = await httpx_client.post(edit_text_url, json=edit_text_payload)
                    
                    if edit_text_response.status_code == 200:
                        edit_result = edit_text_response.json()
                        if edit_result.get('ok'):
                            logger.info(f"Текст успешно отредактирован для события {event_data['number']}")
                        else:
                            error_code = edit_result.get('error_code')
                            if error_code == 429:
                                retry_after = edit_result.get('parameters', {}).get('retry_after', 60)
                                raise Exception(f"RetryAfter:{retry_after}")
                            raise Exception(f"API error: {edit_result.get('description', 'Unknown error')}")
                    else:
                        if edit_text_response.status_code == 429:
                            retry_after = 60
                            try:
                                error_data = edit_text_response.json()
                                retry_after = error_data.get('parameters', {}).get('retry_after', 60)
                            except:
                                pass
                            raise Exception(f"RetryAfter:{retry_after}")
                        raise Exception(f"HTTP {edit_text_response.status_code}: {edit_text_response.text}")
                except httpx.TimeoutException as e:
                    logger.error(f"ТАЙМАУТ при редактировании текста для события номер {event_data['number']}")
                    logger.error(f"Полная диагностическая информация об ошибке TimedOut:")
                    logger.error(f"  Тип ошибки: {type(e).__name__}")
                    logger.error(f"  Сообщение: {str(e)}")
                    logger.error(f"  Все атрибуты ошибки: {vars(e)}")
                    logger.error(f"  Полное представление: {repr(e)}")
                    logger.error(f"  Параметры запроса:")
                    logger.error(f"    chat_id: {CHANNEL_ID}")
                    logger.error(f"    message_id: {message_id}")
                    logger.error(f"    text_length: {len(final_text)}")
                    logger.error(f"    parse_mode: HTML")
                    raise
                except Exception as e:
                    error_msg = str(e)
                    if error_msg.startswith("RetryAfter:"):
                        raise
                    raise
        else:
            try:
                edit_text_payload = {
                    'chat_id': CHANNEL_ID,
                    'message_id': message_id,
                    'text': final_text,
                    'parse_mode': 'HTML',
                    'disable_web_page_preview': True
                }
                edit_text_response = await httpx_client.post(edit_text_url, json=edit_text_payload)
                
                if edit_text_response.status_code == 200:
                    edit_result = edit_text_response.json()
                    if edit_result.get('ok'):
                        logger.info(f"Текст успешно отредактирован для события {event_data['number']}")
                    else:
                        error_code = edit_result.get('error_code')
                        if error_code == 429:
                            retry_after = edit_result.get('parameters', {}).get('retry_after', 60)
                            raise Exception(f"RetryAfter:{retry_after}")
                        raise Exception(f"API error: {edit_result.get('description', 'Unknown error')}")
                else:
                    if edit_text_response.status_code == 429:
                        retry_after = 60
                        try:
                            error_data = edit_text_response.json()
                            retry_after = error_data.get('parameters', {}).get('retry_after', 60)
                        except:
                            pass
                        raise Exception(f"RetryAfter:{retry_after}")
                    raise Exception(f"HTTP {edit_text_response.status_code}: {edit_text_response.text}")
            except httpx.TimeoutException as e:
                logger.error(f"ТАЙМАУТ при редактировании текста для события номер {event_data['number']}")
                logger.error(f"Полная диагностическая информация об ошибке TimedOut:")
                logger.error(f"  Тип ошибки: {type(e).__name__}")
                logger.error(f"  Сообщение: {str(e)}")
                logger.error(f"  Все атрибуты ошибки: {vars(e)}")
                logger.error(f"  Полное представление: {repr(e)}")
                logger.error(f"  Параметры запроса:")
                logger.error(f"    chat_id: {CHANNEL_ID}")
                logger.error(f"    message_id: {message_id}")
                logger.error(f"    text_length: {len(final_text)}")
                logger.error(f"    parse_mode: HTML")
                raise

        return message_id  # Возвращаем только message_id

    except httpx.TimeoutException as e:
        logger.error(f"ТАЙМАУТ при публикации события номер {event_data['number']}")
        logger.error(f"Полная диагностическая информация об ошибке TimedOut:")
        logger.error(f"  Тип ошибки: {type(e).__name__}")
        logger.error(f"  Сообщение: {str(e)}")
        logger.error(f"  Все атрибуты ошибки: {vars(e)}")
        logger.error(f"  Полное представление: {repr(e)}")
        logger.error(f"  Контекст события:")
        logger.error(f"    number: {event_data.get('number')}")
        logger.error(f"    has_image: {bool(event_data.get('about_social_picture'))}")
        logger.error(f"    image_url_length: {len(event_data.get('about_social_picture', '') or '')}")
        logger.error(f"    initial_text_length: {len(initial_text) if 'initial_text' in locals() else 'N/A'}")
        logger.error(f"    final_text_length: {len(final_text) if 'final_text' in locals() else 'N/A'}")
        return None
    except Exception as e:
        error_msg = str(e)
        if error_msg.startswith("RetryAfter:"):
            # Обработка ошибки FloodWait (429)
            retry_after = int(error_msg.split(":")[1])
            logger.error(f"Получена ошибка FloodWait (429) при публикации события номер {event_data['number']}")
            logger.error(f"Необходимо подождать {retry_after} секунд перед следующей попыткой")
            logger.error(f"Полная информация об ошибке RetryAfter для события {event_data['number']}:")
            logger.error(f"  Тип ошибки: RetryAfter")
            logger.error(f"  Сообщение: {error_msg}")
            logger.error(f"  retry_after: {retry_after}")
            raise RetryAfterException(retry_after)
        logger.error(f"Ошибка Telegram при публикации события номер {event_data['number']}: {e}")
        logger.error(f"Полная информация об ошибке Telegram для события {event_data['number']}:")
        logger.error(f"  Тип ошибки: {type(e).__name__}")
        logger.error(f"  Сообщение: {str(e)}")
        logger.error(f"  Все атрибуты ошибки: {vars(e) if hasattr(e, '__dict__') else 'N/A'}")
        logger.error(f"  Полное представление: {repr(e)}")
        return None
    except Exception as e:
        logger.error(f"Неожиданная ошибка при публикации события номер {event_data['number']}: {e}")
        return None

async def tg_post_event_by_id(id_event):
    """Публикация события по ID"""
    logger.info(f"Запуск публикации для события ID {id_event}")
    conn = None
    try:
        conn = pymysql.connect(
            host=MDB_HOST,
            user=MDB_USER,
            password=MDB_PW,
            database=MDBASE,
            charset='utf8mb4',
            cursorclass=pymysql.cursors.DictCursor
        )

        # Проверка времени изменения только в режиме ZILANT
        with conn.cursor() as cursor:
            if WORKMODE == "ZILANT":
                # Вычисляем время, до которого должно быть изменено событие для публикации
                modified_before = datetime.now(timezone.utc) - timedelta(minutes=EVENT_POST_DELAY)
                
                cursor.execute("""
                    SELECT id_event, number, tags, unit_name, name, about, about_social_picture, tg_message_id
                    FROM events
                    WHERE id_event = %s
                        AND marked_to_publication = True
                        AND is_posted_tg = False
                        AND modified <= %s
                """, (id_event, modified_before))
                event = cursor.fetchone()

                if not event:
                    logger.info(f"Событие ID {id_event} не найдено, уже опубликовано или изменено менее чем {EVENT_POST_DELAY} минут назад")
                    return
            else:
                # В режиме VOLK проверка времени не выполняется
                cursor.execute("""
                    SELECT id_event, number, tags, unit_name, name, about, about_social_picture, tg_message_id
                    FROM events
                    WHERE id_event = %s
                        AND marked_to_publication = True
                        AND is_posted_tg = False
                """, (id_event,))
                event = cursor.fetchone()

                if not event:
                    logger.info(f"Событие ID {id_event} не найдено или уже опубликовано")
                    return

            old_message_id = event.get('tg_message_id')  # Сохраняем старый ID сообщения
            # Создаем httpx клиент с отключенным HTTP/2
            httpx_client = httpx.AsyncClient(
                http2=False,
                timeout=20.0,
                follow_redirects=True
            )
            try:
                tg_message_id = await tg_post_event(httpx_client, event)  # Получаем новый message_id
            finally:
                await httpx_client.aclose()

            if tg_message_id:
                # Используем UTC время для записи в базу данных
                current_time_utc = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
                
                # Обновляем подписки если был предыдущий message_id
                if old_message_id:
                    cursor.execute("""
                        UPDATE marks_evt 
                        SET tg_event_id = %s 
                        WHERE tg_event_id = %s
                    """, (tg_message_id, old_message_id))
                    logger.info(f"Обновлены подписки для события {id_event}: {cursor.rowcount} записей")

                cursor.execute("""
                    UPDATE events
                    SET is_posted_tg = True,
                        tg_message_id = %s,
                        tg_posted_date = %s
                    WHERE id_event = %s
                """, (tg_message_id, current_time_utc, id_event))
                conn.commit()
                logger.info(f"Событие номер {event['number']} успешно опубликовано")
            else:
                logger.error(f"Не удалось опубликовать событие ID {id_event}")

    except Exception as e:
        # Проверяем, не RetryAfter ли это
        error_msg = str(e)
        if error_msg.startswith("RetryAfter:") or (hasattr(e, 'retry_after')):
            retry_after = getattr(e, 'retry_after', int(error_msg.split(":")[1]) if ":" in error_msg else 60)
            logger.error(f"Полная информация об ошибке RetryAfter в tg_post_event_by_id для события ID {id_event}:")
            logger.error(f"  Тип ошибки: RetryAfter")
            logger.error(f"  Сообщение: {error_msg}")
            logger.error(f"  retry_after: {retry_after}")
            logger.error(f"  Полное представление: {repr(e)}")
            raise RetryAfterException(retry_after)
        # Если это не RetryAfter, обрабатываем как обычную ошибку
        if "RetryAfter" not in error_msg:
            logger.error(f"Ошибка при публикации: {e}")
            logger.error(f"Полная информация об ошибке в tg_post_event_by_id для события ID {id_event}:")
            logger.error(f"  Тип ошибки: {type(e).__name__}")
            logger.error(f"  Сообщение: {str(e)}")
            logger.error(f"  Все атрибуты ошибки: {vars(e) if hasattr(e, '__dict__') else 'N/A'}")
            logger.error(f"  Полное представление: {repr(e)}")
    except Exception as e:
        logger.error(f"Ошибка при публикации: {e}")
        logger.error(f"Полная информация об ошибке в tg_post_event_by_id для события ID {id_event}:")
        logger.error(f"  Тип ошибки: {type(e).__name__}")
        logger.error(f"  Сообщение: {str(e)}")
        logger.error(f"  Все атрибуты ошибки: {vars(e)}")
        logger.error(f"  Полное представление: {repr(e)}")
    finally:
        if conn:
            conn.close()

async def tg_post_all_events():
    """Публикация всех неопубликованных событий (максимум 10 за один вызов)"""
    logger.info("Запуск скрипта публикации всех событий")
    conn = None
    try:
        conn = pymysql.connect(
            host=MDB_HOST,
            user=MDB_USER,
            password=MDB_PW,
            database=MDBASE,
            charset='utf8mb4',
            cursorclass=pymysql.cursors.DictCursor
        )

        with conn.cursor() as cursor:
            # Проверка времени изменения только в режиме ZILANT
            if WORKMODE == "ZILANT":
                # Вычисляем время, до которого должно быть изменено событие для публикации
                modified_before = datetime.now(timezone.utc) - timedelta(minutes=EVENT_POST_DELAY)
                
                cursor.execute("""
                    SELECT id_event
                    FROM events
                    WHERE marked_to_publication = True
                        AND is_posted_tg = False
                        AND modified <= %s
                    LIMIT 5
                """, (modified_before,))
            else:
                # В режиме VOLK проверка времени не выполняется
                cursor.execute("""
                    SELECT id_event
                    FROM events
                    WHERE marked_to_publication = True
                        AND is_posted_tg = False
                    LIMIT 5
                """)
            events = cursor.fetchall()

            event_count = 0
            for event in events:
                try:
                    await tg_post_event_by_id(event['id_event'])
                    event_count += 1

                    # Задержка между публикациями разных событий
                    if event_count < len(events):
                        await asyncio.sleep(2)

                except RetryAfterException as e:
                    logger.error(f"Прерываем публикацию из-за ошибки FloodWait. Ожидание: {e.retry_after} секунд")
                    logger.error(f"Полная информация об ошибке RetryAfter в tg_post_all_events для события ID {event['id_event']}:")
                    logger.error(f"  Тип ошибки: RetryAfter")
                    logger.error(f"  Сообщение: {str(e)}")
                    logger.error(f"  retry_after: {e.retry_after}")
                    logger.error(f"  Полное представление: {repr(e)}")
                    break
                except Exception as e:
                    logger.error(f"Ошибка при публикации события ID {event['id_event']}: {e}")
                    logger.error(f"Полная информация об ошибке в tg_post_all_events для события ID {event['id_event']}:")
                    logger.error(f"  Тип ошибки: {type(e).__name__}")
                    logger.error(f"  Сообщение: {str(e)}")
                    logger.error(f"  Все атрибуты ошибки: {vars(e) if hasattr(e, '__dict__') else 'N/A'}")
                    logger.error(f"  Полное представление: {repr(e)}")
                    # Продолжаем публикацию следующих событий, несмотря на ошибку
                except Exception as e:
                    logger.error(f"Ошибка при публикации события ID {event['id_event']}: {e}")
                    logger.error(f"Полная информация об ошибке в tg_post_all_events для события ID {event['id_event']}:")
                    logger.error(f"  Тип ошибки: {type(e).__name__}")
                    logger.error(f"  Сообщение: {str(e)}")
                    logger.error(f"  Все атрибуты ошибки: {vars(e)}")
                    logger.error(f"  Полное представление: {repr(e)}")
                    # Продолжаем публикацию следующих событий, несмотря на ошибку

            logger.info(f"Опубликовано событий в этом запуске: {event_count}")

    except Exception as e:
        logger.error(f"Ошибка при публикации: {e}")
    finally:
        if conn:
            conn.close()
        logger.info("Завершение работы скрипта")

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