from telethon import TelegramClient, events
import asyncio
import logging
import os
from pathlib import Path

# Intentar cargar variables de entorno desde .env
try:
    from dotenv import load_dotenv
    load_dotenv()
    logger_init = logging.getLogger(__name__)
    logger_init.info("✅ Variables de entorno cargadas desde .env")
except ImportError:
    pass  # python-dotenv no está instalado, usar valores directos

# Configuración de logging
logging.basicConfig(
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    level=logging.INFO
)
logger = logging.getLogger(__name__)

# ===================== CONFIGURACIÓN =====================
# Opción 1: Usar variables de entorno (recomendado para seguridad)
API_ID = os.getenv('API_ID') or 'TU_API_ID'
API_HASH = os.getenv('API_HASH') or 'TU_API_HASH'
BOT_TOKEN = os.getenv('BOT_TOKEN') or 'TU_BOT_TOKEN'

SOURCE_CHANNEL = os.getenv('SOURCE_CHANNEL') or '@canal_origen'
TARGET_CHANNEL = os.getenv('TARGET_CHANNEL') or '@canal_destino'

# Extensiones de archivo a repostear (puedes agregar más)
ALLOWED_EXTENSIONS = ('.zip', '.rar', '.7z', '.tar', '.gz', '.3mf', '.stl', '.gcode')

# Opciones adicionales
FORWARD_AS_COPY = False  # Si True, copia el mensaje sin mostrar "Forwarded from"
ADD_WATERMARK = False    # Si True, agrega un texto al repostear
WATERMARK_TEXT = "\n\n📦 Reposteado automáticamente"
# =========================================================


# Crear el cliente del bot
bot = TelegramClient('bot_session', API_ID, API_HASH)


def is_allowed_file(file_name):
    """
    Verifica si el archivo tiene una extensión permitida
    """
    if not file_name:
        return False
    return any(file_name.lower().endswith(ext) for ext in ALLOWED_EXTENSIONS)


async def get_file_info(message):
    """
    Extrae información del archivo del mensaje
    """
    if not message.document:
        return None
    
    file_name = None
    file_size = message.document.size
    mime_type = message.document.mime_type
    
    for attribute in message.document.attributes:
        if hasattr(attribute, 'file_name'):
            file_name = attribute.file_name
            break
    
    return {
        'name': file_name,
        'size': file_size,
        'mime_type': mime_type
    }


def format_file_size(size_bytes):
    """
    Convierte bytes a formato legible (KB, MB, GB)
    """
    for unit in ['B', 'KB', 'MB', 'GB']:
        if size_bytes < 1024.0:
            return f"{size_bytes:.2f} {unit}"
        size_bytes /= 1024.0
    return f"{size_bytes:.2f} TB"


@bot.on(events.NewMessage(chats=SOURCE_CHANNEL))
async def repost_handler(event):
    """
    Maneja los nuevos mensajes del canal origen y los repostea al destino
    """
    try:
        message = event.message
        
        # Verificar si el mensaje tiene un archivo
        if message.media and message.document:
            file_info = await get_file_info(message)
            
            if not file_info or not file_info['name']:
                logger.debug("⏭️ Mensaje sin nombre de archivo, ignorado")
                return
            
            file_name = file_info['name']
            
            # Verificar si es una extensión permitida
            if is_allowed_file(file_name):
                file_size = format_file_size(file_info['size'])
                logger.info(f"📥 Reposteando archivo: {file_name} ({file_size})")
                
                if FORWARD_AS_COPY:
                    # Opción: Enviar como copia (sin "Forwarded from")
                    caption = message.message or ""
                    if ADD_WATERMARK:
                        caption += WATERMARK_TEXT
                    
                    await bot.send_file(
                        TARGET_CHANNEL,
                        file=message.media,
                        caption=caption
                    )
                else:
                    # Opción: Forward directo (muestra "Forwarded from")
                    await bot.forward_messages(
                        entity=TARGET_CHANNEL,
                        messages=message.id,
                        from_peer=SOURCE_CHANNEL
                    )
                
                logger.info(f"✅ Archivo reposteado exitosamente: {file_name}")
            else:
                logger.debug(f"⏭️ Archivo ignorado (extensión no permitida): {file_name}")
        else:
            logger.debug("⏭️ Mensaje sin archivo, ignorado")
            
    except Exception as e:
        logger.error(f"❌ Error al repostear mensaje: {e}", exc_info=True)


@bot.on(events.NewMessage(pattern='/start'))
async def start_handler(event):
    """
    Comando /start para verificar que el bot funciona
    """
    await event.respond(
        "🤖 **Bot de Reposteo Activo**\n\n"
        f"📡 Canal origen: `{SOURCE_CHANNEL}`\n"
        f"📤 Canal destino: `{TARGET_CHANNEL}`\n"
        f"📁 Extensiones: {', '.join(ALLOWED_EXTENSIONS)}\n\n"
        "✅ El bot está funcionando correctamente."
    )


@bot.on(events.NewMessage(pattern='/status'))
async def status_handler(event):
    """
    Comando /status para verificar el estado del bot
    """
    try:
        # Verificar acceso a los canales
        source_entity = await bot.get_entity(SOURCE_CHANNEL)
        target_entity = await bot.get_entity(TARGET_CHANNEL)
        
        await event.respond(
            "📊 **Estado del Bot**\n\n"
            f"✅ Canal origen: {source_entity.title}\n"
            f"✅ Canal destino: {target_entity.title}\n"
            f"✅ Extensiones activas: {len(ALLOWED_EXTENSIONS)}\n"
            f"✅ Bot funcionando correctamente"
        )
    except Exception as e:
        await event.respond(f"❌ Error: {e}")


async def main():
    """
    Función principal para iniciar el bot
    """
    logger.info("🤖 Iniciando bot...")
    
    # Validar configuración
    if API_ID == 'TU_API_ID' or API_HASH == 'TU_API_HASH':
        logger.error("❌ ERROR: Debes configurar API_ID y API_HASH")
        return
    
    if BOT_TOKEN == 'TU_BOT_TOKEN':
        logger.error("❌ ERROR: Debes configurar BOT_TOKEN")
        return
    
    # Conectar con el token del bot
    await bot.start(bot_token=BOT_TOKEN)
    
    # Obtener información del bot
    me = await bot.get_me()
    logger.info(f"✅ Bot conectado: @{me.username}")
    logger.info(f"📡 Escuchando mensajes en: {SOURCE_CHANNEL}")
    logger.info(f"📤 Reposteando a: {TARGET_CHANNEL}")
    logger.info(f"📁 Extensiones permitidas: {', '.join(ALLOWED_EXTENSIONS)}")
    logger.info(f"🔄 Modo: {'Copia' if FORWARD_AS_COPY else 'Forward'}")
    logger.info("🟢 Bot funcionando. Presiona Ctrl+C para detener.")
    logger.info("💡 Tip: Envía /start o /status al bot para verificar su estado")
    
    # Mantener el bot corriendo
    await bot.run_until_disconnected()


if __name__ == '__main__':
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        logger.info("\n🛑 Bot detenido por el usuario")
    except Exception as e:
        logger.error(f"❌ Error fatal: {e}", exc_info=True)