import os
import sys
import re
import asyncio
import logging

# Windows terminal UTF-8 encoding fix
if sys.platform == "win32":
    try:
        sys.stdout.reconfigure(encoding="utf-8")
        sys.stderr.reconfigure(encoding="utf-8")
    except Exception:
        pass

# Python 3.12/3.14 asyncio loop compatibility
try:
    loop = asyncio.get_event_loop()
except RuntimeError:
    loop = asyncio.new_event_loop()
    asyncio.set_event_loop(loop)

from dotenv import load_dotenv
import pyrogram.utils

# 64-bit Telegram Channel ID support
pyrogram.utils.MIN_CHANNEL_ID = -1009999999999999

from pyrogram import Client, filters
from pyrogram.errors import FloodWait, RPCError

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - [%(levelname)s] - %(message)s"
)
logger = logging.getLogger("PURE_BOT_SYNC")

load_dotenv()

API_ID = os.getenv("API_ID")
API_HASH = os.getenv("API_HASH")
BOT_TOKEN = os.getenv("BOT_TOKEN")

def parse_chat(chat_val: str):
    if not chat_val:
        return None
    chat_val = chat_val.strip()
    if chat_val.startswith("-100") or chat_val.lstrip("-").isdigit():
        return int(chat_val)
    return chat_val

SOURCE_CHAT = parse_chat(os.getenv("SOURCE_CHAT", ""))
TARGET_CHAT = parse_chat(os.getenv("TARGET_CHAT", ""))

if not API_ID or not API_HASH:
    raise ValueError("Error: .env me API_ID aur API_HASH fill karein!")

if not BOT_TOKEN:
    raise ValueError("Error: .env me BOT_TOKEN fill karein!")

if not SOURCE_CHAT or not TARGET_CHAT:
    raise ValueError("Error: .env me SOURCE_CHAT aur TARGET_CHAT fill karein!")

# Regex for Firebase URLs
FIREBASE_URL_REGEX = re.compile(
    r"(https?://[a-zA-Z0-9_\-\.]+\.(?:firebaseio\.com|firebasedatabase\.app)(?:/[^\s]*)?|[a-zA-Z0-9_\-\.]+\.firebaseio\.com)",
    re.IGNORECASE
)

# In-memory deduplication set
seen_urls = set()

# Pre-load existing unique URLs if available
TXT_FILE = "unique_firebase_urls.txt"
if os.path.exists(TXT_FILE):
    try:
        with open(TXT_FILE, "r", encoding="utf-8") as f:
            for line in f:
                u = line.strip().rstrip("/").lower()
                if u:
                    seen_urls.add(u)
        logger.info(f"Loaded {len(seen_urls)} previous unique URLs into memory.")
    except Exception:
        pass

# 🤖 100% PURE BOT CLIENT (NO USERBOT / NO PHONE NUMBER / NO OTP)
bot = Client(
    name="bot_session",
    api_id=int(API_ID),
    api_hash=API_HASH,
    bot_token=BOT_TOKEN
)

def normalize_url(url: str) -> str:
    url = url.strip()
    if not url.startswith("http://") and not url.startswith("https://"):
        url = "https://" + url
    return url.rstrip("/").lower()

@bot.on_message(filters.chat(SOURCE_CHAT) & ~filters.service)
async def bot_message_handler(client: Client, message):
    """
    Source channel me message aate hi Bot use detect karega:
    - FRESH Firebase: 🟢 [FRESH NEW FIREBASE] banner ke sath.
    - DUPLICATE Firebase: 🔴 [DUPLICATE FIREBASE] banner ke sath.
    - Normal Message/Media: As-is clean deliver karega.
    """
    text = message.text or message.caption or ""
    is_firebase = "new firebase connected" in text.lower()
    highlighted_banner = ""
    is_fresh = False

    if is_firebase:
        url_match = FIREBASE_URL_REGEX.search(text)
        if url_match:
            clean_url = normalize_url(url_match.group(1))

            if clean_url not in seen_urls:
                # 🟢 FRESH NEW FIREBASE
                seen_urls.add(clean_url)
                is_fresh = True
                highlighted_banner = (
                    "🟢 ━━━━━━━━━━━━━━━━━━━\n"
                    "✨  <b>[FRESH NEW FIREBASE]</b>  ✨\n"
                    "━━━━━━━━━━━━━━━━━━━━━\n\n"
                )
                logger.info(f"🔥 [FRESH FIREBASE] {clean_url}")
            else:
                # 🔴 DUPLICATE FIREBASE
                highlighted_banner = (
                    "🔴 ━━━━━━━━━━━━━━━━━━━\n"
                    "⚠️  <b>[DUPLICATE FIREBASE]</b>  ⚠️\n"
                    "━━━━━━━━━━━━━━━━━━━━━\n\n"
                )
                logger.info(f"🔁 [DUPLICATE FIREBASE] {clean_url}")

    # Deliver to Target Chat via Bot
    retries = 3
    while retries > 0:
        try:
            if is_firebase and highlighted_banner:
                final_text = highlighted_banner + text
                if message.text:
                    await bot.send_message(
                        chat_id=TARGET_CHAT,
                        text=final_text,
                        disable_web_page_preview=True
                    )
                else:
                    await bot.copy_message(
                        chat_id=TARGET_CHAT,
                        from_chat_id=SOURCE_CHAT,
                        message_id=message.id,
                        caption=final_text
                    )
            else:
                # Normal message without modification
                await bot.copy_message(
                    chat_id=TARGET_CHAT,
                    from_chat_id=SOURCE_CHAT,
                    message_id=message.id
                )

            status_tag = "🟢 FRESH" if is_fresh else ("🔴 DUPLICATE" if is_firebase else "⚡ NORMAL")
            logger.info(f"[{status_tag}] Msg ID {message.id} delivered to target by Bot!")
            break

        except FloodWait as e:
            logger.warning(f"Telegram FloodWait: Waiting {e.value}s...")
            await asyncio.sleep(e.value + 1)
            retries -= 1
        except RPCError as e:
            logger.error(f"RPC Error delivering msg {message.id}: {e}")
            break
        except Exception as e:
            logger.error(f"Failed to deliver msg {message.id}: {e}")
            break

async def main():
    while True:
        try:
            async with bot:
                me = await bot.get_me()
                print("=" * 60)
                print(f"🤖 PURE TELEGRAM BOT RUNNING: @{me.username}")
                print(f"📡 Source Channel : {SOURCE_CHAT}")
                print(f"🎯 Target Chat/GC : {TARGET_CHAT}")
                print(f"🧠 Known Firebases: {len(seen_urls)}")
                print("🟢 FRESH & 🔴 DUPLICATE Highlights Active!")
                print("⚡ Zero Phone Number / Zero OTP needed!")
                print("=" * 60)

                # 24/7 listen mode
                await asyncio.Event().wait()

        except (KeyboardInterrupt, SystemExit):
            print("\n👋 Bot band kar diya gaya.")
            break
        except Exception as e:
            logger.error(f"Connection error: {e}. Reconnecting in 10s...")
            await asyncio.sleep(10)

if __name__ == "__main__":
    try:
        loop.run_until_complete(main())
    except (KeyboardInterrupt, SystemExit):
        print("\n👋 Process stopped.")
