app.py

import json
import asyncio
import aiohttp
import discord
import logging
import os
import time
from dotenv import load_dotenv

# -------------------------------
# Environment
# -------------------------------
load_dotenv()

BOT_TOKEN = os.getenv("BOT_TOKEN")

if not BOT_TOKEN:
    raise RuntimeError("BOT_TOKEN missing (.env not loaded)")


# -------------------------------
# Logging
# -------------------------------
os.makedirs("logs", exist_ok=True)

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s | %(levelname)s | %(message)s",
    handlers=[
        logging.FileHandler("logs/bot.log", encoding="utf-8"),
        logging.StreamHandler()
    ]
)


# -------------------------------
# Load configuration
# -------------------------------
with open("config.json", "r", encoding="utf-8") as f:
    config = json.load(f)


WEBHOOKS = config.get("webhooks", [])
ALERT_CHANNEL_ID = config.get("alert_channel_id")
CHECK_INTERVAL = config.get("check_interval_seconds", 60)

if not WEBHOOKS:
    raise RuntimeError("No webhooks defined in config.json")

if not ALERT_CHANNEL_ID:
    raise RuntimeError("alert_channel_id missing in config.json")


# -------------------------------
# Discord Client
# -------------------------------
intents = discord.Intents.default()

client = discord.Client(intents=intents)


# -------------------------------
# State / Cache
# -------------------------------
webhook_cache = {}

alerted = {}

CACHE_DURATION = 300  # seconds

monitor_task = None


# -------------------------------
# Pastebin Resolver
# -------------------------------
async def resolve_webhook_url(session: aiohttp.ClientSession, entry: dict) -> str:

    name = entry["name"]
    paste_url = entry["url"]

    current_time = time.time()

    # Use cached webhook if still valid
    if name in webhook_cache:

        cached = webhook_cache[name]

        if current_time - cached["time"] < CACHE_DURATION:
            return cached["url"]


    async with session.get(paste_url) as resp:

        if resp.status != 200:
            raise RuntimeError(
                f"Pastebin request failed ({name}): HTTP {resp.status}"
            )


        text = (await resp.text()).strip()


        if not text.startswith("https://discord.com/api/webhooks/"):
            raise RuntimeError(
                f"Invalid webhook URL in Pastebin ({name})"
            )


        webhook_cache[name] = {
            "url": text,
            "time": current_time
        }


        return text



# -------------------------------
# Webhook Checker
# -------------------------------
async def check_single_webhook(
        session: aiohttp.ClientSession,
        entry: dict,
        channel
):

    name = entry["name"]


    if name not in alerted:
        alerted[name] = False


    try:

        webhook_url = await resolve_webhook_url(
            session,
            entry
        )


        async with session.get(webhook_url) as resp:

            logging.info(
                f"[{name}] HTTP status: {resp.status}"
            )


            # Webhook deleted or invalid
            if resp.status in [401, 403, 404]:

                if not alerted[name]:

                    await channel.send(
                        f"⚠️ @everyone **Webhook unavailable: `{name}`**"
                    )

                    alerted[name] = True


                logging.warning(
                    f"[{name}] webhook unavailable ({resp.status})"
                )


            # Webhook is working
            elif resp.status == 200:


                if alerted[name]:

                    await channel.send(
                        f"✅ **Webhook restored: `{name}`**"
                    )

                    alerted[name] = False


                logging.info(
                    f"[{name}] webhook active"
                )


    except Exception as e:

        logging.error(
            f"[{name}] error: {e}"
        )



# -------------------------------
# Main Monitoring Loop
# -------------------------------
async def check_all_webhooks():

    await client.wait_until_ready()


    try:

        channel = await client.fetch_channel(
            ALERT_CHANNEL_ID
        )


    except Exception as e:

        logging.error(
            f"Failed to fetch alert channel: {e}"
        )

        return



    logging.info(
        f"Monitoring started for {len(WEBHOOKS)} webhooks"
    )


    timeout = aiohttp.ClientTimeout(
        total=10
    )


    async with aiohttp.ClientSession(
        timeout=timeout
    ) as session:


        while True:


            tasks = [
                check_single_webhook(
                    session,
                    entry,
                    channel
                )

                for entry in WEBHOOKS
            ]


            await asyncio.gather(
                *tasks
            )


            await asyncio.sleep(
                CHECK_INTERVAL
            )



# -------------------------------
# Discord Events
# -------------------------------
@client.event
async def on_ready():

    global monitor_task


    logging.info(
        f"Bot online as {client.user}"
    )


    # Prevent multiple monitoring tasks
    if monitor_task is None:

        monitor_task = asyncio.create_task(
            check_all_webhooks()
        )



# -------------------------------
# Start Bot
# -------------------------------
client.run(BOT_TOKEN)