"""
Скрипт для парсинга постов из разных источников и сохранения в файл
Собирает посты из X.com, Instagram, Telegram с метриками и ссылками
Отправляет посты в Telegram бота с переводами и картинками
"""

import asyncio
import sys
import os
from datetime import datetime
from dotenv import load_dotenv

# Fix encoding for Windows
if sys.platform == 'win32':
    os.environ['PYTHONIOENCODING'] = 'utf-8'
    if hasattr(sys.stdout, 'reconfigure'):
        sys.stdout.reconfigure(encoding='utf-8')
        sys.stderr.reconfigure(encoding='utf-8')

load_dotenv()

from src.parsers.x_parser import XParser
from src.parsers.instagram_parser import InstagramParser
from src.parsers.telegram_parser import TelegramParser
from src.config_loader import ConfigLoader
from src.constants import DEFAULT_PARSE_DAYS
from src.utils.translator import translate_to_russian, detect_language

# Try to import Telegram bot
try:
    from telegram import Bot
    from telegram.error import TelegramError
    TELEGRAM_BOT_AVAILABLE = True
except ImportError:
    Bot = None
    TelegramError = None
    TELEGRAM_BOT_AVAILABLE = False
    print("[WARNING] Telegram bot library not available (will skip sending to bot)")

# Output file path
OUTPUT_FILE = r'C:\Projects\seaBot\parsed_posts.txt'

# Telegram bot configuration
TELEGRAM_BOT_TOKEN = os.getenv('TELEGRAM_BOT_TOKEN')
TELEGRAM_CHAT_ID = os.getenv('TELEGRAM_CHAT_ID')


async def parse_source(platform: str, username: str, subscribers: int, days: int = 7):
    """
    Парсит посты из источника
    
    Args:
        platform: Платформа (x, instagram, telegram)
        username: Имя пользователя
        subscribers: Количество подписчиков
        days: Количество дней для парсинга (увеличено до 7 для получения большего количества постов)
        
    Returns:
        Список ParsedPost объектов
    """
    print(f"\n{'='*60}")
    print(f"Парсинг {platform.upper()}: @{username}")
    print(f"{'='*60}")
    
    try:
        # Создаем парсер
        parser = None
        if platform == 'x':
            parser = XParser(username, subscribers)
        elif platform == 'instagram':
            parser = InstagramParser(username, subscribers)
        elif platform == 'telegram':
            parser = TelegramParser(username, subscribers)
        else:
            print(f"❌ Неизвестная платформа: {platform}")
            return []
        
        # Парсим посты (увеличиваем период для получения большего количества постов)
        print(f"🔍 Запускаю парсинг (последние {days} дней)...")
        posts = await parser.parse_posts(days=days)
        
        print(f"✓ Получено постов: {len(posts)}")
        
        # Добавляем информацию о платформе и источнике к каждому посту
        for post in posts:
            post.platform = platform
            post.source_username = username
            post.subscriber_count = subscribers
        
        return posts
        
    except Exception as e:
        print(f"❌ Ошибка парсинга {platform}/@{username}: {e}")
        import traceback
        traceback.print_exc()
        return []


def format_post_for_file(post, index: int):
    """
    Форматирует пост для записи в файл с переводом
    
    Args:
        post: ParsedPost объект
        index: Номер поста
        
    Returns:
        Отформатированная строка
    """
    lines = []
    
    lines.append(f"\n{'='*60}")
    lines.append(f"ПОСТ #{index}")
    lines.append(f"{'='*60}")
    
    # Платформа и источник
    platform_emoji = {
        'telegram': '📱',
        'instagram': '📷',
        'x': '🐦'
    }.get(post.platform, '📄')
    
    lines.append(f"Платформа: {platform_emoji} {post.platform.upper()}")
    lines.append(f"Источник: @{getattr(post, 'source_username', 'unknown')}")
    lines.append(f"Подписчиков: {getattr(post, 'subscriber_count', 0):,}")
    lines.append(f"ID поста: {post.external_id}")
    
    # URL
    if post.url:
        lines.append(f"🔗 Ссылка: {post.url}")
    else:
        lines.append(f"🔗 Ссылка: N/A")
    
    lines.append("")
    
    # Содержимое поста (оригинал)
    content = post.content or "Нет текста"
    lines.append(f"ТЕКСТ ПОСТА (ОРИГИНАЛ):")
    lines.append(f"{content}")
    lines.append("")
    
    # Перевод на русский
    if content and content != "Нет текста":
        original_lang = detect_language(content)
        if original_lang and original_lang != 'ru':
            translated = translate_to_russian(content, original_lang)
            lang_names = {
                'en': 'английский',
                'es': 'испанский',
                'fr': 'французский',
                'de': 'немецкий',
                'it': 'итальянский',
                'pt': 'португальский',
                'ja': 'японский',
                'ko': 'корейский',
                'zh': 'китайский',
                'ar': 'арабский'
            }
            lang_name = lang_names.get(original_lang, original_lang)
            lines.append(f"ЯЗЫК ОРИГИНАЛА: {lang_name} ({original_lang})")
            lines.append(f"ПЕРЕВОД НА РУССКИЙ:")
            lines.append(f"{translated}")
            lines.append("")
        elif original_lang == 'ru':
            lines.append(f"ЯЗЫК: русский (уже на русском)")
            lines.append("")
        else:
            lines.append(f"ЯЗЫК: не определен")
            lines.append("")
    
    # Метрики
    lines.append(f"МЕТРИКИ ПОПУЛЯРНОСТИ:")
    
    if post.views > 0:
        lines.append(f"  👁 Просмотры: {post.views:,}")
    else:
        lines.append(f"  👁 Просмотры: 0")
    
    if post.likes > 0:
        lines.append(f"  ❤️ Лайки: {post.likes:,}")
    else:
        lines.append(f"  ❤️ Лайки: 0")
    
    if post.comments > 0:
        lines.append(f"  💬 Комментарии: {post.comments:,}")
    else:
        lines.append(f"  💬 Комментарии: 0")
    
    shares_count = post.shares if post.shares > 0 else 0
    if shares_count > 0:
        lines.append(f"  🔄 Репосты/Retweets: {shares_count:,}")
    else:
        lines.append(f"  🔄 Репосты/Retweets: 0")
    
    reactions_count = getattr(post, 'reactions', 0) if hasattr(post, 'reactions') else 0
    if reactions_count > 0:
        lines.append(f"  ⭐ Реакции: {reactions_count:,}")
    else:
        lines.append(f"  ⭐ Реакции: 0")
    
    # Общая вовлеченность
    total_engagement = post.likes + post.comments + shares_count + reactions_count
    lines.append(f"")
    lines.append(f"  📊 Общая вовлеченность: {total_engagement:,}")
    
    # Engagement rate (если есть подписчики)
    subscriber_count = getattr(post, 'subscriber_count', 0)
    if subscriber_count > 0:
        engagement_rate = (total_engagement / subscriber_count) * 100
        lines.append(f"  📈 Engagement Rate: {engagement_rate:.2f}%")
    
    # Дата
    if post.created_at:
        date_str = post.created_at.strftime("%d.%m.%Y %H:%M")
        lines.append(f"")
        lines.append(f"📅 Дата публикации: {date_str}")
    else:
        lines.append(f"")
        lines.append(f"📅 Дата публикации: N/A")
    
    return "\n".join(lines)


async def main():
    """Главная функция"""
    print("="*60)
    print("ПАРСИНГ ПОСТОВ ИЗ РАЗНЫХ ИСТОЧНИКОВ")
    print("="*60)
    print(f"Время запуска: {datetime.now().strftime('%d.%m.%Y %H:%M:%S')}")
    print(f"Файл вывода: {OUTPUT_FILE}")
    print()
    
    # Загружаем конфигурацию источников
    try:
        config_loader = ConfigLoader('config/sources.yaml')
        sources = config_loader.load()
        stats = config_loader.get_stats()
        
        print(f"📋 Загружено источников:")
        print(f"   - Telegram: {stats['telegram']}")
        print(f"   - X.com: {stats['x']}")
        print(f"   - Instagram: {stats['instagram']}")
        print(f"   - Всего: {stats['total']}")
        print()
        
    except Exception as e:
        print(f"❌ Ошибка загрузки конфигурации: {e}")
        return
    
    if not sources:
        print("⚠️ Нет источников для парсинга")
        return
    
    # Парсим посты из всех источников
    all_posts = []
    
    # Парсим по несколько источников из каждой платформы (чтобы не перегружать)
    platforms_parsed = {'x': 0, 'instagram': 0, 'telegram': 0}
    max_per_platform = 5  # Максимум источников на платформу для теста
    
    for source in sources:
        platform = source.platform
        username = source.username
        subscribers = source.subscriber_count
        
        # Пропускаем X.com - заблокирован в сети
        if platform == 'x':
            continue
        
        # Ограничиваем количество источников на платформу
        if platforms_parsed[platform] >= max_per_platform:
            print(f"⏭ Пропускаю {platform}/@{username} (уже обработано {platforms_parsed[platform]} источников)")
            continue
        
        posts = await parse_source(platform, username, subscribers, days=7)  # Увеличиваем до 7 дней для получения большего количества постов
        all_posts.extend(posts)
        platforms_parsed[platform] += 1
        
        # Задержка между источниками
        await asyncio.sleep(2)
    
    # Сортируем по дате (новые первыми)
    all_posts.sort(key=lambda p: p.created_at if p.created_at else datetime.min, reverse=True)
    
    print(f"\n{'='*60}")
    print(f"ВСЕГО ПОЛУЧЕНО ПОСТОВ: {len(all_posts)}")
    print(f"{'='*60}")
    
    # Проверяем, есть ли посты
    if not all_posts:
        print("\n⚠️ Не удалось получить посты из источников")
        print("💡 Возможные причины:")
        print("   - Instagram блокирует запросы (429)")
        print("   - Аккаунты приватные")
        print("   - Проблемы с сетью")
    
    # Сохраняем в файл
    try:
        with open(OUTPUT_FILE, 'w', encoding='utf-8') as f:
            # Заголовок
            f.write("="*60 + "\n")
            f.write("ПАРСЕННЫЕ ПОСТЫ ИЗ РАЗНЫХ ИСТОЧНИКОВ\n")
            f.write("="*60 + "\n")
            f.write(f"Время парсинга: {datetime.now().strftime('%d.%m.%Y %H:%M:%S')}\n")
            f.write(f"Всего постов: {len(all_posts)}\n")
            f.write(f"Источников обработано:\n")
            f.write(f"  - X.com: {platforms_parsed['x']}\n")
            f.write(f"  - Instagram: {platforms_parsed['instagram']}\n")
            f.write(f"  - Telegram: {platforms_parsed['telegram']}\n")
            f.write("\n")
            
            # Записываем посты
            for i, post in enumerate(all_posts, 1):
                formatted = format_post_for_file(post, i)
                f.write(formatted)
                f.write("\n")
            
            # Футер
            f.write("\n" + "="*60 + "\n")
            f.write("КОНЕЦ ОТЧЕТА\n")
            f.write("="*60 + "\n")
        
        print(f"✓ Результаты сохранены в {OUTPUT_FILE}")
        print(f"✓ Всего постов: {len(all_posts)}")
        
        # Статистика по платформам
        platform_stats = {}
        for post in all_posts:
            platform = post.platform
            platform_stats[platform] = platform_stats.get(platform, 0) + 1
        
        print(f"\n📊 Статистика по платформам:")
        for platform, count in platform_stats.items():
            print(f"   - {platform.upper()}: {count} постов")
        
    except Exception as e:
        print(f"❌ Ошибка сохранения в файл: {e}")
        import traceback
        traceback.print_exc()
    
    # Отправляем посты в Telegram бота
    if TELEGRAM_BOT_AVAILABLE and TELEGRAM_BOT_TOKEN and TELEGRAM_CHAT_ID and all_posts:
        print(f"\n{'='*60}")
        print("ОТПРАВКА ПОСТОВ В TELEGRAM БОТА")
        print(f"{'='*60}")
        
        try:
            bot = Bot(token=TELEGRAM_BOT_TOKEN)
            print(f"✓ Бот инициализирован, отправка в чат: {TELEGRAM_CHAT_ID}")
            
            sent_count = 0
            for i, post in enumerate(all_posts[:10], 1):  # Отправляем первые 10 постов
                try:
                    success = await send_post_to_telegram(bot, post, i)
                    if success:
                        sent_count += 1
                        print(f"✓ Отправлен пост {i}/{min(10, len(all_posts))}: {post.platform}/@{getattr(post, 'source_username', 'unknown')}")
                    else:
                        print(f"⚠ Не удалось отправить пост {i}")
                    
                    # Задержка между отправками
                    await asyncio.sleep(2)
                    
                except Exception as e:
                    print(f"❌ Ошибка при отправке поста {i}: {e}")
            
            print(f"\n✓ Отправлено постов: {sent_count}/{min(10, len(all_posts))}")
            
        except Exception as e:
            print(f"❌ Ошибка инициализации бота: {e}")
    elif not TELEGRAM_BOT_AVAILABLE:
        print("\n⚠ Telegram bot библиотека недоступна, посты не отправлены")
    elif not TELEGRAM_BOT_TOKEN:
        print("\n⚠ TELEGRAM_BOT_TOKEN не установлен, посты не отправлены")
    elif not TELEGRAM_CHAT_ID:
        print("\n⚠ TELEGRAM_CHAT_ID не установлен, посты не отправлены")


async def get_image_url_from_post(post):
    """
    Пытается получить URL изображения из поста
    
    Args:
        post: ParsedPost объект
        
    Returns:
        URL изображения или None
    """
    try:
        if post.platform == 'instagram' and post.url:
            # Для Instagram постов можно попробовать получить изображение
            # Формат URL Instagram поста: https://www.instagram.com/p/SHORTCODE/
            # Изображение обычно доступно через API или парсинг страницы
            # Для простоты используем URL поста - Telegram сам покажет превью из Open Graph
            return post.url
        elif post.platform == 'x' and post.url:
            # Для X.com также используем URL - Telegram покажет превью
            return post.url
    except:
        pass
    return None


async def download_image_from_url(image_url: str):
    """
    Скачивает изображение по URL для отправки в Telegram
    
    Args:
        image_url: URL изображения
        
    Returns:
        Bytes изображения или None
    """
    try:
        from curl_cffi import requests as curl_requests
        
        response = curl_requests.get(image_url, timeout=10)
        if response.status_code == 200:
            # Проверяем, что это изображение
            content_type = response.headers.get('content-type', '')
            if 'image' in content_type:
                return response.content
    except Exception as e:
        print(f"  ⚠ Не удалось скачать изображение: {e}")
    return None


async def send_post_to_telegram(bot: Bot, post, index: int):
    """
    Отправляет пост в Telegram бота с переводом и картинкой (если доступна)
    
    Args:
        bot: Telegram Bot объект
        post: ParsedPost объект
        index: Номер поста
        
    Returns:
        True если успешно отправлено
    """
    try:
        # Определяем язык оригинала и переводим
        content = post.content or "Нет текста"
        original_lang = detect_language(content) if content != "Нет текста" else None
        content_ru = content
        
        if original_lang and original_lang != 'ru':
            content_ru = translate_to_russian(content, original_lang)
        
        # Обрезаем длинный текст
        if len(content_ru) > 3000:
            content_ru = content_ru[:3000] + "..."
        
        # Формируем сообщение
        platform_emoji = {
            'telegram': '📱',
            'instagram': '📷',
            'x': '🐦'
        }.get(post.platform, '📄')
        
        message = f"{platform_emoji} <b>{post.platform.upper()}</b>"
        
        # Источник
        source_username = getattr(post, 'source_username', 'unknown')
        if source_username:
            message += f" | <b>@{source_username}</b>"
        message += "\n\n"
        
        # Текст поста (переведенный)
        message += f"{content_ru}\n"
        
        # Указываем, что текст переведен
        if original_lang and original_lang != 'ru' and content_ru != content:
            lang_names = {
                'en': 'английский',
                'es': 'испанский',
                'fr': 'французский',
                'de': 'немецкий',
                'it': 'итальянский',
                'pt': 'португальский',
                'ja': 'японский',
                'ko': 'корейский',
                'zh': 'китайский',
                'ar': 'арабский'
            }
            lang_name = lang_names.get(original_lang, original_lang)
            message += f"\n<i>🌐 Переведено с {lang_name}</i>\n"
        
        message += "\n"
        
        # Метрики популярности
        metrics = []
        if post.views > 0:
            metrics.append(f"👁 {post.views:,}")
        if post.likes > 0:
            metrics.append(f"❤️ {post.likes:,}")
        if post.comments > 0:
            metrics.append(f"💬 {post.comments:,}")
        if post.shares > 0:
            metrics.append(f"🔄 {post.shares:,}")
        if hasattr(post, 'reactions') and post.reactions > 0:
            metrics.append(f"⭐ {post.reactions:,}")
        
        if metrics:
            message += " ".join(metrics) + "\n\n"
        
        # Ссылка
        if post.url:
            message += f"🔗 <a href=\"{post.url}\">Открыть пост</a>\n"
        
        # Дата
        if post.created_at:
            date_str = post.created_at.strftime("%d.%m.%Y %H:%M")
            message += f"\n📅 {date_str}"
        
        # Пытаемся получить изображение из поста
        image_url = await get_image_url_from_post(post)
        
        # Отправляем сообщение с изображением
        try:
            # Для Instagram и X.com Telegram автоматически покажет превью изображения из ссылки
            # Используем send_message с disable_web_page_preview=False для показа превью
            # Это самый простой и надежный способ - Telegram сам извлечет изображение из Open Graph мета-тегов
            
            await bot.send_message(
                chat_id=TELEGRAM_CHAT_ID,
                text=message,
                parse_mode='HTML',
                disable_web_page_preview=False  # Telegram покажет превью изображения из ссылки
            )
            
            # Альтернативный способ: отправка фото напрямую (если нужно)
            # Для этого нужно получить прямой URL изображения через парсинг страницы
            # Пока используем превью из ссылки, которое работает автоматически
            
        except Exception as e:
            # Если не удалось отправить с превью, отправляем без превью
            print(f"  ⚠ Не удалось отправить с превью, отправляю без: {e}")
            try:
                await bot.send_message(
                    chat_id=TELEGRAM_CHAT_ID,
                    text=message,
                    parse_mode='HTML',
                    disable_web_page_preview=True
                )
            except Exception as e2:
                print(f"  ❌ Критическая ошибка отправки: {e2}")
                raise
        
        return True
        
    except TelegramError as e:
        print(f"  ⚠ Ошибка отправки в Telegram: {e}")
        return False
    except Exception as e:
        print(f"  ⚠ Неожиданная ошибка: {e}")
        import traceback
        traceback.print_exc()
        return False


if __name__ == '__main__':
    asyncio.run(main())