from __future__ import annotations
import shlex
import logging
from datetime import datetime
from typing import Optional, Dict, List, Any
import time
from urllib.parse import urlparse

from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
from telegram.ext import (
    Application, CommandHandler, MessageHandler, ConversationHandler,
    CallbackQueryHandler, CallbackContext, filters,
)
from telegram.error import TelegramError
from apscheduler.schedulers.asyncio import AsyncIOScheduler

from sqlalchemy import select

from app.core.config import settings
from app.tasks.senders import send_post_task
from app.db.session import async_session_maker
from app.models.channel import Channel
from app.models.post import PostType
from app.services.templates import (
    render_template_by_name, list_templates, count_templates,
    create_template, delete_template, required_variables_of_template,
)
from jinja2 import TemplateError

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

# Константы
MAX_MESSAGE_LENGTH = 4096
PAGE_SIZE = 8
SESSION_TIMEOUT = 3600  # 1 час
ALLOWED_URL_SCHEMES = ('http', 'https', 't.me')

# Состояния диалога
(
    CHOOSE_CHANNEL, CHOOSE_TYPE, CHOOSE_FORMAT, ENTER_TEXT, ENTER_MEDIA, EDIT_KEYBOARD,
    CONFIRM_SEND, ENTER_SCHEDULE, SELECT_TEMPLATE,
    PREVIEW_VARS, PREVIEW_CONFIRM,
    TPL_NEW_NAME, TPL_NEW_TYPE, TPL_NEW_FORMAT, TPL_NEW_CONTENT, TPL_NEW_KB, TPL_CONFIRM_DELETE,
) = range(16)

# In-memory сессии с метаданными
session: Dict[int, Dict[str, Any]] = {}

def validate_url(url: str) -> bool:
    """Проверка безопасности URL.
    
    Args:
        url: Строка URL для проверки
        
    Returns:
        bool: True если URL безопасен, False в противном случае
    """
    try:
        result = urlparse(url)
        return all([
            result.scheme in ALLOWED_URL_SCHEMES,
            result.netloc,
            len(url) < 2048  # Максимальная длина URL
        ])
    except Exception as e:
        logger.warning(f"URL validation failed: {e}")
        return False

def validate_message_length(text: str) -> bool:
    """Проверка длины сообщения согласно лимитам Telegram.
    
    Args:
        text: Текст для проверки
        
    Returns:
        bool: True если длина в пределах лимита
    """
    return len(text) <= MAX_MESSAGE_LENGTH

def update_session_activity(uid: int) -> None:
    """Обновление времени последней активности в сессии."""
    if uid in session:
        session[uid]['last_activity'] = time.time()

def cleanup_old_sessions() -> None:
    """Периодическая очистка старых сессий."""
    current_time = time.time()
    for uid in list(session.keys()):
        if current_time - session[uid].get('last_activity', 0) > SESSION_TIMEOUT:
            logger.info(f"Cleaning up session for user {uid}")
            del session[uid]

def parse_template_invocation(s: str) -> tuple[str, dict]:
    """Разбор строки вызова шаблона.
    
    Args:
        s: Строка в формате #template_name key1=value1 key2=value2
        
    Returns:
        tuple: (имя_шаблона, словарь_параметров)
        
    Raises:
        ValueError: Если неверный формат строки
    """
    s = s.strip()
    if not s.startswith("#"):
        raise ValueError("Имя шаблона должно начинаться с #")
    parts = shlex.split(s)
    if not parts:
        raise ValueError("Пустой шаблон")
    name = parts[0][1:]
    args: dict[str, str] = {}
    for tok in parts[1:]:
        if "=" in tok:
            k, v = tok.split("=", 1)
            args[k.strip()] = v.strip()
    return name, args

def parse_key_value_lines(text: str) -> dict:
    """Парсинг строк формата key=value.
    
    Args:
        text: Строки в формате key=value или key="quoted value"
        
    Returns:
        dict: Словарь параметров
    """
    text = (text or "").strip()
    if not text:
        return {}
        
    out = {}
    if "\n" in text:
        for line in text.splitlines():
            if "=" in line:
                k, v = line.split("=", 1)
                v = v.strip().strip('"')
                if k.strip():  # Проверка на пустой ключ
                    out[k.strip()] = v
    else:
        try:
            for tok in shlex.split(text):
                if "=" in tok:
                    k, v = tok.split("=", 1)
                    if k.strip():  # Проверка на пустой ключ
                        out[k.strip()] = v
        except ValueError as e:
            logger.warning(f"Error parsing key-value line: {e}")
            
    return out

# -------- Команды верхнего уровня ---------

async def start(update: Update, context: CallbackContext) -> None:
    """Обработчик команды /start."""
    update_session_activity(update.effective_user.id)
    await update.message.reply_text(
        "Привет! Я редактор. Команды:\n"
        "/newpost — мастер поста\n"
        "/tpl_new — создать шаблон\n"
        "/tpl_list — список шаблонов"
    )

async def newpost(update: Update, context: CallbackContext) -> int:
    """Начало создания нового поста."""
    uid = update.effective_user.id
    update_session_activity(uid)
    
    session[uid] = {'last_activity': time.time()}
    
    try:
        async with async_session_maker() as s:
            res = await s.execute(select(Channel).where(Channel.owner_id == uid).limit(50))
            channels = list(res.scalars())
            
        if not channels:
            await update.message.reply_text(
                "Пока нет каналов. Добавь через админку или команду /add_channel (в разработке)."
            )
            return ConversationHandler.END

        kb = [
            [InlineKeyboardButton(ch.title or str(ch.chat_id), callback_data=f"channel:{ch.id}")]
            for ch in channels
        ]
        await update.message.reply_text(
            "Выбери канал для публикации:",
            reply_markup=InlineKeyboardMarkup(kb)
        )
        return CHOOSE_CHANNEL
        
    except Exception as e:
        logger.error(f"Error in newpost: {e}")
        await update.message.reply_text("Произошла ошибка. Попробуйте позже.")
        return ConversationHandler.END

async def choose_channel(update: Update, context: CallbackContext) -> int:
    """Обработка выбора канала."""
    q = update.callback_query
    await q.answer()
    
    uid = update.effective_user.id
    update_session_activity(uid)
    
    try:
        ch_id = int(q.data.split(":")[1])
        session[uid]["channel_id"] = ch_id

        kb = [
            [
                InlineKeyboardButton("Текст", callback_data="type:text"),
                InlineKeyboardButton("Фото", callback_data="type:photo")
            ],
            [
                InlineKeyboardButton("Видео", callback_data="type:video"),
                InlineKeyboardButton("GIF", callback_data="type:animation")
            ],
        ]
        await q.edit_message_text(
            "Тип поста:",
            reply_markup=InlineKeyboardMarkup(kb)
        )
        return CHOOSE_TYPE
        
    except ValueError:
        await q.edit_message_text("Ошибка: неверный формат ID канала")
        return ConversationHandler.END
    except Exception as e:
        logger.error(f"Error in choose_channel: {e}")
        await q.edit_message_text("Произошла ошибка. Попробуйте заново.")
        return ConversationHandler.END

# ... [Остальные функции обновляются аналогично] ...

async def enter_schedule(update: Update, context: CallbackContext) -> int:
    """Обработка ввода времени для отложенной публикации."""
    uid = update.effective_user.id
    update_session_activity(uid)
    
    try:
        when = datetime.strptime(update.message.text.strip(), "%Y-%m-%d %H:%M")
        
        if when < datetime.now():
            await update.message.reply_text(
                "Дата должна быть в будущем. Укажите корректное время в формате YYYY-MM-DD HH:MM"
            )
            return ENTER_SCHEDULE
            
        await _dispatch_with_eta(uid, when)
        await update.message.reply_text("Задача запланирована.")
        return ConversationHandler.END
        
    except ValueError:
        await update.message.reply_text(
            "Неверный формат даты. Используйте формат YYYY-MM-DD HH:MM"
        )
        return ENTER_SCHEDULE
    except Exception as e:
        logger.error(f"Error scheduling post: {e}")
        await update.message.reply_text("Ошибка планирования. Попробуйте позже.")
        return ConversationHandler.END

async def _dispatch_with_eta(uid: int, when: datetime) -> None:
    """Отправка отложенного поста."""
    data = session.get(uid)
    if not data:
        raise ValueError("Сессия потеряна")
        
    token = settings.editor_bot_token
    try:
        payload = build_payload(
            ptype=data.get("type"),
            text=data.get("text"),
            media_file_id=data.get("media_file_id"),
            parse_mode=data.get("parse_mode") or "HTML",
            keyboard=data.get("keyboard"),
        )
        
        # Проверка длины сообщения
        if not validate_message_length(payload.get("text", "")):
            raise ValueError("Превышен максимальный размер сообщения")
            
        # Проверка URL в клавиатуре
        if keyboard := payload.get("keyboard"):
            for row in keyboard.get("rows", []):
                for btn in row:
                    if "url" in btn and not validate_url(btn["url"]):
                        raise ValueError(f"Небезопасный URL: {btn['url']}")
                        
        send_post_task.apply_async(
            args=[token, data["channel_id"], payload],
            eta=when
        )
        
    except Exception as e:
        logger.error(f"Error in _dispatch_with_eta: {e}")
        raise

def main():
    """Инициализация и запуск бота."""
    try:
        # Настройка логирования
        logging.basicConfig(
            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
            level=logging.INFO
        )
        
        # Инициализация планировщика
        scheduler = AsyncIOScheduler()
        scheduler.add_job(cleanup_old_sessions, 'interval', minutes=30)
        scheduler.start()
        
        app = Application.builder().token(settings.editor_bot_token).build()
        
        # Регистрация обработчиков
        post_conv = ConversationHandler(
            entry_points=[CommandHandler("newpost", newpost)],
            states={
                CHOOSE_CHANNEL: [CallbackQueryHandler(choose_channel, pattern=r"^channel:")],
                CHOOSE_TYPE: [CallbackQueryHandler(choose_type, pattern=r"^type:")],
                CHOOSE_FORMAT: [CallbackQueryHandler(choose_format, pattern=r"^fmt:")],
                ENTER_TEXT: [
                    MessageHandler(filters.TEXT & ~filters.COMMAND, enter_text),
                    CallbackQueryHandler(choose_template_open, pattern=r"^tpl:choose$"),
                ],
                SELECT_TEMPLATE: [
                    CallbackQueryHandler(choose_template_apply, pattern=r"^tpluse:"),
                    CallbackQueryHandler(choose_template_preview, pattern=r"^tplprev:"),
                    CallbackQueryHandler(choose_template_navigate, pattern=r"^tplpage:"),
                    CallbackQueryHandler(choose_template_cancel, pattern=r"^tpl:cancel$"),
                ],
                PREVIEW_VARS: [
                    MessageHandler(filters.TEXT & ~filters.COMMAND, preview_collect_vars)
                ],
                PREVIEW_CONFIRM: [
                    CallbackQueryHandler(preview_confirm, pattern=r"^pv:(use|edit)$"),
                    CallbackQueryHandler(choose_template_cancel, pattern=r"^tpl:cancel$"),
                ],
                ENTER_MEDIA: [
                    MessageHandler(filters.TEXT & ~filters.COMMAND, enter_media)
                ],
                EDIT_KEYBOARD: [
                    MessageHandler(filters.TEXT & ~filters.COMMAND, edit_keyboard)
                ],
                CONFIRM_SEND: [
                    CallbackQueryHandler(confirm_send, pattern=r"^send:")
                ],
                ENTER_SCHEDULE: [
                    MessageHandler(filters.TEXT & ~filters.COMMAND, enter_schedule)
                ],
            },
            fallbacks=[CommandHandler("start", start)],
        )

        tpl_conv = ConversationHandler(
            entry_points=[CommandHandler("tpl_new", tpl_new_start)],
            states={
                TPL_NEW_NAME: [
                    MessageHandler(filters.TEXT & ~filters.COMMAND, tpl_new_name)
                ],
                TPL_NEW_TYPE: [
                    CallbackQueryHandler(tpl_new_type, pattern=r"^tpltype:")
                ],
                TPL_NEW_FORMAT: [
                    CallbackQueryHandler(tpl_new_format, pattern=r"^tplfmt:")
                ],
                TPL_NEW_CONTENT: [
                    MessageHandler(filters.TEXT & ~filters.COMMAND, tpl_new_content)
                ],
                TPL_NEW_KB: [
                    MessageHandler(filters.TEXT & ~filters.COMMAND, tpl_new_kb)
                ],
                TPL_CONFIRM_DELETE: [
                    CallbackQueryHandler(tpl_delete_ok, pattern=r"^tpldelok:"),
                    CallbackQueryHandler(choose_template_cancel, pattern=r"^tpl:cancel$"),
                ],
            },
            fallbacks=[CommandHandler("start", start)],
        )

        app.add_handler(CommandHandler("start", start))
        app.add_handler(post_conv)
        app.add_handler(tpl_conv)
        app.add_handler(CommandHandler("tpl_list", tpl_list))

        # Запуск бота
        app.run_polling(allowed_updates=Update.ALL_TYPES)
        
    except Exception as e:
        logger.critical(f"Critical error in main: {e}")
        raise

if __name__ == "__main__":
    main()