#!/usr/bin/env python3
"""Утилиты для форматирования и отправки сообщений."""

import asyncio
import logging
import re
from typing import List, Tuple
from telegram import Update

logger = logging.getLogger(__name__)

# Лимиты Telegram
MAX_MESSAGE_LENGTH = 4096  # Максимальная длина сообщения
RESERVED_FOR_HEADER = 20  # Резервируем место для "(N/N) "


def escape_markdown(text: str) -> str:
    """
    Экранирование специальных символов Markdown для Telegram API.
    
    Telegram Markdown v1 использует: * _ ` [ ] ( )
    Эти символы нужно экранировать обратным слэшем.
    """
    if not text:
        return text
    
    # Экранируем специальные символы Markdown
    # Порядок важен: сначала экранируем обратные слэши
    text = text.replace('\\', '\\\\')
    text = text.replace('`', '\\`')
    text = text.replace('*', '\\*')
    text = text.replace('_', '\\_')
    text = text.replace('[', '\\[')
    text = text.replace(']', '\\]')
    text = text.replace('(', '\\(')
    text = text.replace(')', '\\)')
    
    return text


def find_code_blocks(text: str) -> List[Tuple[int, int]]:
    """
    Найти все блоки кода (```) в тексте.
    Возвращает список кортежей (start, end) для каждого блока.
    """
    blocks = []
    pattern = re.compile(r'```')
    matches = list(pattern.finditer(text))
    
    # Пары start-end для каждого блока
    i = 0
    while i < len(matches) - 1:
        start = matches[i].start()
        end = matches[i + 1].end()
        blocks.append((start, end))
        i += 2
    
    return blocks


def split_message(text: str, max_length: int = MAX_MESSAGE_LENGTH) -> List[Tuple[str, bool, bool, bool]]:
    """
    Умно разбить длинный текст на сообщения <= max_length символов.

    Возвращает список кортежей (text, has_code, code_opened, code_closed):
    - text: текст сообщения
    - has_code: True если сообщение содержит часть блока кода
    - code_opened: True если блок кода ОТКРЫТ в этом сообщении (есть открывающий ```)
    - code_closed: True если блок кода ЗАКРЫТ в этом сообщении (есть закрывающий ```)

    Алгоритм:
    1. Находим все блоки кода
    2. Стараемся не разрывать блоки кода
    3. Если блок кода не влезает — отправляем отдельным сообщением без Markdown
    """
    if len(text) <= max_length:
        has_code = '```' in text
        # Считаем количество ``` для определения открыт/закрыт
        backtick_count = text.count('```')
        # Если 1 или нечётное количество — блок открыт но не закрыт (или наоборот)
        code_opened = backtick_count >= 1 and (backtick_count % 2 == 1)
        code_closed = backtick_count >= 2 and (backtick_count % 2 == 0)
        return [(text, has_code, code_opened, code_closed)]

    parts = []
    code_blocks = find_code_blocks(text)

    # Текущая позиция в тексте
    pos = 0
    current = ""
    current_has_code = False
    current_code_opened = False
    current_code_closed = False

    for block_start, block_end in code_blocks:
        # Текст до блока кода
        before_code = text[pos:block_start]

        # Сам блок кода (включая ```)
        code_block = text[block_start:block_end]

        # Обрабатываем текст до блока
        for line in before_code.split('\n'):
            if len(current) + len(line) + 1 > max_length - RESERVED_FOR_HEADER:
                if current:
                    parts.append((current, current_has_code, current_code_opened, current_code_closed))
                current = line
                current_has_code = False
                current_code_opened = False
                current_code_closed = False
            else:
                current += ('\n' if current else '') + line

        # Проверяем влезет ли блок кода
        if len(current) + len(code_block) + 1 > max_length - RESERVED_FOR_HEADER:
            # Отправляем что накопилось
            if current:
                parts.append((current, current_has_code, current_code_opened, current_code_closed))

            # Если блок кода слишком длинный — режем его на части
            if len(code_block) > max_length - RESERVED_FOR_HEADER:
                # Отправляем блок кода частями без Markdown
                for i in range(0, len(code_block), max_length - RESERVED_FOR_HEADER):
                    chunk = code_block[i:i + max_length - RESERVED_FOR_HEADER]
                    # Первая часть имеет открывающий ```, последняя — закрывающий
                    first_chunk = (i == 0)
                    last_chunk = (i + max_length - RESERVED_FOR_HEADER >= len(code_block))
                    parts.append((chunk, True, first_chunk, last_chunk))
                current = ""
                current_has_code = False
                current_code_opened = False
                current_code_closed = False
            else:
                # Блок влезает в следующее сообщение
                current = code_block
                current_has_code = True
                current_code_opened = True  # Блок начинается с ```
                current_code_closed = True  # Блок заканчивается на ```
        else:
            # Блок кода влезает в текущее сообщение
            current += ('\n' if current else '') + code_block
            current_has_code = True
            current_code_opened = True  # Блок содержит открывающий ```
            current_code_closed = True  # Блок содержит закрывающий ```

        pos = block_end

    # Обрабатываем остаток текста после последнего блока
    if pos < len(text):
        remaining = text[pos:]
        for line in remaining.split('\n'):
            if len(current) + len(line) + 1 > max_length - RESERVED_FOR_HEADER:
                if current:
                    parts.append((current, current_has_code, current_code_opened, current_code_closed))
                current = line
                current_has_code = False
                current_code_opened = False
                current_code_closed = False
            else:
                current += ('\n' if current else '') + line

    if current:
        parts.append((current, current_has_code, current_code_opened, current_code_closed))

    return parts


async def send_long_message(update: Update, text: str, parse_mode: str = None, pause_every: int = 3):
    """
    Отправить длинный текст, разбив на несколько сообщений.

    Умная разбивка:
    - Блоки кода не разрываются между сообщениями
    - Если блок кода не влезает — отправляется без Markdown
    - Нумерация (1/N), (2/N) только если сообщений > 1
    - КАЖДЫЕ pause_every сообщений — пауза с кнопками "Продолжить" / "Отменить"

    Args:
        update: Telegram update
        text: Текст для отправки
        parse_mode: Режим парсинга (Markdown)
        pause_every: Каждые сколько сообщений делать паузу (0 = без паузы)
    """
    from telegram import InlineKeyboardButton, InlineKeyboardMarkup
    import asyncio

    parts = split_message(text)
    total = len(parts)
    messages_sent = 0
    wait_msg = None

    for i, (part, has_code, code_opened, code_closed) in enumerate(parts):
        # Определяем parse_mode для этого сообщения
        actual_parse_mode = parse_mode if parse_mode and has_code else None

        # Логика работы с блоками кода между сообщениями:
        # - Если предыдущее сообщение не закрыло блок — открываем в этом
        # - Если текущее не закрывает блок и следующее не имеет кода — закрываем
        if total > 1 and actual_parse_mode and has_code:
            # Проверяем нужно ли открыть блок в начале этого сообщения
            if i > 0 and not parts[i-1][3]:  # предыдущее не закрыло блок (parts[i-1][3] = code_closed)
                part = "```\n" + part
            
            # Проверяем нужно ли закрыть блок в конце этого сообщения
            if i < total - 1 and not code_closed and not parts[i+1][1]:  # следующее не имеет кода
                part = part + "\n```"

        # Добавляем номер части ПОСЛЕ работы с блоками кода
        if total > 1:
            header = f"({i+1}/{total}) "
            if len(header) + len(part) <= MAX_MESSAGE_LENGTH:
                part = header + part

        try:
            await update.message.reply_text(part, parse_mode=actual_parse_mode)
        except Exception as e:
            # Фоллбэк: отправляем без разметки
            logger.debug(f"Ошибка Markdown, отправляем без разметки: {e}")
            await update.message.reply_text(part)

        messages_sent += 1

        # Небольшая пауза между сообщениями
        await asyncio.sleep(0.1)

        # КАЖДЫЕ pause_every сообщений — спрашиваем продолжать ли
        if pause_every > 0 and messages_sent % pause_every == 0 and i < total - 1:
            remaining = total - (i + 1)
            keyboard = InlineKeyboardMarkup([
                [
                    InlineKeyboardButton("▶️ Продолжить", callback_data=f"continue_output_{remaining}"),
                    InlineKeyboardButton("❌ Отменить", callback_data="cancel_output")
                ]
            ])
            
            wait_msg = await update.message.reply_text(
                f"📊 **Отправлено {messages_sent} из {total} сообщений**\n\n"
                f"Осталось ещё {remaining} сообщений.\n\n"
                f"Продолжить вывод?",
                parse_mode="Markdown",
                reply_markup=keyboard
            )
            
            # Ждём ответа пользователя (до 60 секунд)
            from bot.config import state_manager
            
            user_id = update.effective_user.id
            
            # Сохраняем состояние ожидания
            state = state_manager.get(user_id)
            state.waiting_for_output_control = True
            state.output_remaining = remaining
            state.output_wait_message = wait_msg
            
            # Ждём 60 секунд
            for _ in range(60):
                await asyncio.sleep(1)
                state = state_manager.get(user_id)
                if not state.waiting_for_output_control:
                    # Пользователь ответил
                    if state.continue_output:
                        # Продолжаем - удаляем кнопки
                        try:
                            await wait_msg.delete()
                        except:
                            pass
                        break
                    else:
                        # Отменил - редактируем сообщение и убираем кнопки
                        try:
                            await wait_msg.edit_text("❌ **Вывод отменен пользователем**", parse_mode="Markdown")
                        except:
                            pass
                        return
            
            # Таймаут
            if state.waiting_for_output_control:
                state.waiting_for_output_control = False
                try:
                    await wait_msg.edit_text("⏱️ **Время ожидания истекло**. Вывод продолжен.", parse_mode="Markdown")
                except:
                    pass


def format_long_output(text: str, max_lines: int = 100, head_lines: int = 50, tail_lines: int = 50) -> str:
    """
    Форматировать длинный вывод: показать первые и последние строки.
    По умолчанию: первые 50 + последние 50 строк = 100 строк максимум.
    """
    lines = text.split('\n')
    total_lines = len(lines)

    if total_lines <= max_lines:
        return text

    # Показываем первые head_lines и последние tail_lines
    head = lines[:head_lines]
    tail = lines[-tail_lines:]

    skipped = total_lines - head_lines - tail_lines

    result = '\n'.join(head)
    result += f'\n\n... ({skipped} строк пропущено) ...\n'
    result += '\n'.join(tail)

    return result