main.py

import logging
import asyncio
from discord.ext import commands, tasks
from discord import app_commands, ui
from typing import Optional
import discord
import re
import os
from dotenv import load_dotenv
import itertools
import aiosqlite
import sqlite3
import time
import ast
from collections import deque
from dataclasses import dataclass, replace
from translations import get_text, LANGUAGE_NAMES, TRANSLATION_LANGUAGE_NAMES, TRANSLATIONS
from link_utils import build_automatic_url, build_fixembed_url, chunk_lines, extract_supported_links
from instagram_embed import fetch_instagram_delivery
from twitter_embed import build_twitter_layout, fetch_twitter_payload
from reddit_embed import (
    fetch_reddit_layout,
    keeps_native_reddit_og_on_failure,
)
from threads_embed import fetch_threads_layout
from bluesky_embed import fetch_bluesky_layout
from pixiv_embed import fetch_pixiv_layout
from pixiv_relay import start_pixiv_relay
from bilibili_embed import fetch_bilibili_layout
from youtube_embed import fetch_youtube_community_layout
from pinterest_embed import fetch_pinterest_layout
from tiktok_embed import fetch_tiktok_layout
from tumblr_embed import fetch_tumblr_layout
from twitch_embed import fetch_twitch_layout
from deviantart_embed import fetch_deviantart_layout
from embed_footer import FooterBranding, escape_component_text
from card_preferences import preferences_from_settings
from content_visibility import (
    channel_visibility_override,
    init_content_visibility,
    is_nsfw_channel,
    load_channel_visibility_overrides,
    resolve_content_visibility,
    set_channel_visibility_override,
)
from premium_controls import (
    fetch_analytics_summary,
    init_premium_controls,
    load_premium_controls,
    record_processing_outcome,
    resolve_translation_language,
    save_premium_controls,
    should_skip_automatic,
)
from premium_activation import (
    evaluate_activation_checklist,
    checklist_settings_targets,
    format_checklist_row,
)
from message_context import format_tagged_users, no_mentions, sender_allowed_mentions
from command_components import render_command_layout, render_settings_layout
from install_links import build_install_controls
from onboarding import send_onboarding_dm
from settings_migrations import (
    migrate_new_social_services_default,
    migrate_pinterest_service_default,
    migrate_youtube_service_default,
)
from reliability import (
    ReliabilityClient,
    ReliabilityReport,
    format_reliability_status,
    probe_deviantart_bot_health,
)
from conversion_telemetry import (
    ConversionTelemetry,
    format_local_conversion_health,
    new_request_id,
)
from delivery_telemetry import (
    DeliveryTelemetry,
    deliver_with_fallback,
    format_delivery_health,
)
from delivery_policy import (
    apply_source_message_action,
    format_delivery_mode_status,
    resolve_delivery_mode,
    should_apply_source_message_action,
)
from premium_cache import (
    PREMIUM_CHECK_TIMEOUT_SECONDS,
    PremiumStatusCache,
    record_guild_premium,
    resolve_guild_premium_status,
)
from premium_roles import (
    entitlement_is_active,
    reconcile_supporter_roles,
    sync_supporter_role,
    sync_supporter_role_for_member,
)

# Version number
VERSION = "1.6.0"


@dataclass(frozen=True)
class ComponentsV2Delivery:
    view: discord.ui.LayoutView
    fallback_url: str
    files: tuple[discord.File, ...] = ()


# Service configuration for link processing
# All services now use the unified FixEmbed service at fixembed.app
SERVICES = {
    "Twitter": {
        "patterns": [r"twitter\.com/(\w+)/status/(\d+)", r"x\.com/(\w+)/status/(\d+)"],
        "base_url": "fixembed.app",
        "display_format": "Twitter • {0}"
    },
    "Instagram": {
        "patterns": [r"instagram\.com/(?:p|reels?)/([\w-]+)"],
        "base_url": "fixembed.app",
        "display_format": "Instagram • {0}"
    },
    "Reddit": {
        "patterns": [r"(?:old\.)?reddit\.com/r/(\w+)/(?:s|comments)/\w+"],
        "base_url": "fixembed.app",
        "display_format": "Reddit • r/{0}"
    },
    "Threads": {
        "patterns": [r"threads\.net/@([^/]+)/post/([\w-]+)"],
        "base_url": "fixembed.app",
        "display_format": "Threads • @{0}"
    },
    "Pixiv": {
        "patterns": [r"pixiv\.net/(?:en/)?artworks/(\d+)"],
        "base_url": "fixembed.app",
        "display_format": "Pixiv • {0}"
    },
    "Bluesky": {
        "patterns": [r"bskyx?\.app/profile/([^/]+)/post/([\w-]+)"],
        "base_url": "fixembed.app",
        "display_format": "Bluesky • {0}"
    },
    "Bilibili": {
        "patterns": [r"bilibili\.com/video/([\w]+)", r"b23\.tv/([\w]+)"],
        "base_url": "fixembed.app",
        "display_format": "Bilibili • {0}"
    },
    "YouTube": {
        "patterns": [r"youtube\.com/post/([\w-]+)"],
        "base_url": "fixembed.app",
        "display_format": "YouTube • Community Post"
    },
    "Pinterest": {
        "patterns": [r"pinterest\.com/pin/[\w-]+", r"pin\.it/[\w-]+"],
        "base_url": "fixembed.app",
        "display_format": "Pinterest • {0}"
    },
    "TikTok": {
        "patterns": [
            r"tiktok\.com/@[\w.-]+/video/\d+",
            r"(?:vm|vt)\.tiktok\.com/[\w-]+",
        ],
        "base_url": "fixembed.app",
        "display_format": "TikTok • {0}"
    },
    "Tumblr": {
        "patterns": [
            r"[\w-]+\.tumblr\.com/post/\d+",
            r"tumblr\.com/[\w-]+/\d+",
        ],
        "base_url": "fixembed.app",
        "display_format": "Tumblr • {0}"
    },
    "Twitch": {
        "patterns": [
            r"(?:clips\.twitch\.tv/[\w-]+|twitch\.tv/[\w-]+/clip/[\w-]+)",
            r"twitch\.tv/videos/\d+",
            r"twitch\.tv/[\w-]+",
        ],
        "base_url": "fixembed.app",
        "display_format": "Twitch • {0}"
    },
    "DeviantArt": {
        "patterns": [
            r"deviantart\.com/[\w-]+/art/[\w-]+",
            r"sta\.sh/[\w-]+",
        ],
        "base_url": "fixembed.app",
        "display_format": "DeviantArt • {0}",
    },
}

SERVICE_NAMES = list(SERVICES.keys())
DEFAULT_ENABLED_SERVICES = SERVICE_NAMES.copy()
SERVICE_EMOJI_FALLBACKS = {
    "Twitter": "🐦",
    "Instagram": "📷",
    "Reddit": "👽",
    "Threads": "🧵",
    "Pixiv": "🎨",
    "Bluesky": "🦋",
    "Bilibili": "📺",
    "YouTube": "▶️",
    "Pinterest": "📌",
    "TikTok": "🎵",
    "Tumblr": "🅣",
    "Twitch": "🟣",
    "DeviantArt": "🎨",
}
SERVICE_EMOJI_IDS = {
    "YouTube": 1526267390592290926,
    "Pixiv": 1526268469920792577,
    "Threads": 1526267848924725399,
    "Reddit": 1526267589808881684,
    "Instagram": 1526267158793949435,
    "Twitter": 1526268173589155921,
    "Bluesky": 1526269663334502544,
    "Bilibili": 1526271150739423304,
    "Pinterest": 1526398381415731240,
    "TikTok": 1527868616215629954,
    "Tumblr": 1527868615393546400,
    "Twitch": 1527868614269468852,
    "DeviantArt": 1528150711089500180,
}
LANGUAGE_FLAG_EMOJIS = {
    "en": "🇺🇸",
    "es": "🇪🇸",
    "pt": "🇧🇷",
    "fr": "🇫🇷",
    "de": "🇩🇪",
    "ja": "🇯🇵",
    "ko": "🇰🇷",
    "zh": "🇨🇳",
}

def get_custom_service_emoji(guild: Optional[discord.Guild], service: str):
    """Return a custom emoji for a service (guild/client/id lookup), if available."""
    candidates = (service.lower(), service.replace(" ", "").lower())

    if guild is not None:
        for candidate in candidates:
            emoji = discord.utils.get(guild.emojis, name=candidate)
            if emoji:
                return emoji

    # Fallback by hardcoded emoji IDs (supports cases where emojis are not in guild.emojis)
    emoji_id = SERVICE_EMOJI_IDS.get(service)
    if emoji_id:
        if guild is not None:
            emoji = guild.get_emoji(emoji_id)
            if emoji:
                return emoji
        emoji = client.get_emoji(emoji_id)
        if emoji:
            return emoji

        candidate_name = service.lower()
        return discord.PartialEmoji(name=candidate_name, id=emoji_id)

    return None

def get_service_select_emoji(guild: Optional[discord.Guild], service: str):
    """Emoji object/char for select options with fallback when custom emojis are missing."""
    custom = get_custom_service_emoji(guild, service)
    return custom or SERVICE_EMOJI_FALLBACKS.get(service, "🔗")

def get_service_display_icon(guild: Optional[discord.Guild], service: str) -> str:
    """String icon for embeds/text with fallback when custom emojis are missing."""
    custom = get_custom_service_emoji(guild, service)
    return str(custom) if custom else SERVICE_EMOJI_FALLBACKS.get(service, "🔗")

# Initialize logging
logging.basicConfig(level=logging.INFO)

# Bot configuration
intents = discord.Intents.default()
intents.message_content = True
client = commands.AutoShardedBot(
    command_prefix=commands.when_mentioned,
    intents=intents,
    shard_count=10,
    # Cards and link text carry third-party content (comment bodies, titles,
    # captions, author names). Nothing the bot posts may ping by default.
    allowed_mentions=no_mentions(),
)

# In-memory storage for channel states and settings
channel_states = {}
bot_settings = {}
channel_service_rules = {}
channel_visibility_overrides = {}

# Rate-limiting configuration
MESSAGE_LIMIT = 5
TIME_WINDOW = 1  # Time window in seconds

message_timestamps = deque()

SEND_QUEUE = asyncio.Queue()
processed_link_cache = {}
DEDUP_WINDOW_SECONDS = 10
reliability_client = ReliabilityClient(
    local_checks=(probe_deviantart_bot_health,),
)
conversion_telemetry = ConversionTelemetry(supported_services=SERVICE_NAMES)
delivery_telemetry = DeliveryTelemetry()

async def rate_limited_send(
    channel,
    content=None,
    embed=None,
    files=None,
    allowed_mentions=no_mentions(),
    view=None,
    fallback_content=None,
):
    ticket = delivery_telemetry.queued("card" if view is not None else "link")
    completion = asyncio.get_running_loop().create_future()
    await SEND_QUEUE.put(
        (
            ticket,
            completion,
            channel,
            content,
            embed,
            files,
            allowed_mentions,
            view,
            fallback_content,
        )
    )
    return await asyncio.shield(completion)

async def send_worker():
    while True:
        (
            ticket,
            completion,
            channel,
            content,
            embed,
            files,
            allowed_mentions,
            view,
            fallback_content,
        ) = await SEND_QUEUE.get()
        try:
            current_time = time.time()
            while message_timestamps and current_time - message_timestamps[0] >= TIME_WINDOW:
                message_timestamps.popleft()

            while len(message_timestamps) >= MESSAGE_LIMIT:
                await asyncio.sleep(0.1)
                current_time = time.time()
                while message_timestamps and current_time - message_timestamps[0] >= TIME_WINDOW:
                    message_timestamps.popleft()

            message_timestamps.append(time.time())
            async def primary_send():
                send_options = {
                    "content": content,
                    "embed": embed,
                    "allowed_mentions": allowed_mentions,
                    "view": view,
                    "silent": True,
                }
                if files:
                    send_options["files"] = list(files)
                return await channel.send(**send_options)

            async def fallback_send():
                return await channel.send(
                    content=fallback_content,
                    allowed_mentions=allowed_mentions,
                    silent=True,
                )

            outcome = await deliver_with_fallback(
                ticket,
                telemetry=delivery_telemetry,
                primary_send=primary_send,
                fallback_send=fallback_send if fallback_content else None,
            )
            if not completion.done():
                completion.set_result(outcome)
        except asyncio.CancelledError:
            if not completion.done():
                completion.cancel()
            raise
        except Exception as error:
            delivery_telemetry.failed(ticket, error)
            if not completion.done():
                completion.set_result("failed")
        finally:
            SEND_QUEUE.task_done()

# Premium SKU ID (loaded from .env at bottom of file)
PREMIUM_SKU_ID = None
SUPPORT_GUILD_ID = 1195810157112852540
SUPPORTER_ROLE_ID = 1195810157112852547

def get_guild_lang(guild_id):
    """Get the language setting for a guild, defaulting to English."""
    if guild_id is None:
        return "en"
    return bot_settings.get(guild_id, {}).get("language", "en")

# Premium status per guild id, for every guild whether or not it has a
# bot_settings row. Entries use the premium_cache TTL helpers; bounded LRU.
premium_status_cache = PremiumStatusCache()

async def guild_premium_status(guild_id):
    """``active``, ``inactive``, or ``unconfirmed`` when Discord couldn't be
    checked and nothing is cached. Only /premium and the settings screens use
    the third answer (#101); message handling uses ``is_guild_premium``."""
    if not PREMIUM_SKU_ID:
        return "inactive"

    async def fetch_entitlements():
        guild = client.get_guild(guild_id)
        if guild is None:
            return None
        return [e async for e in client.entitlements(guild=guild, skus=[discord.Object(id=int(PREMIUM_SKU_ID))])]

    # Fresh cache hit (premium or not) skips Discord. Otherwise one lookup capped
    # at PREMIUM_CHECK_TIMEOUT_SECONDS, falling back to the last cached value.
    return await resolve_guild_premium_status(
        premium_status_cache,
        guild_id,
        fetch_entitlements,
        timeout=PREMIUM_CHECK_TIMEOUT_SECONDS,
    )


async def is_guild_premium(guild_id):
    """Check if a guild has an active premium subscription."""
    return await guild_premium_status(guild_id) == "active"


def get_footer_branding(guild, settings, premium):
    """Resolve persisted Premium branding against the current guild."""
    if not premium or not settings.get("footer_branding_enabled", False):
        return None
    emoji = ""
    emoji_id = settings.get("footer_emoji_id")
    if emoji_id:
        try:
            guild_emoji = discord.utils.get(guild.emojis, id=int(emoji_id))
        except (TypeError, ValueError):
            guild_emoji = None
        if guild_emoji is not None:
            emoji = str(guild_emoji)
    return FooterBranding(name=guild.name, emoji=emoji)

def get_premium_color(guild_id):
    """Get custom embed color for a premium guild, or None."""
    color_hex = bot_settings.get(guild_id, {}).get("embed_color")
    if color_hex:
        try:
            return discord.Color(int(color_hex.lstrip('#'), 16))
        except (ValueError, AttributeError):
            pass
    return None

def get_guild_color(guild_id, default=None):
    """Get the guild's custom color if premium, otherwise return default."""
    custom = get_premium_color(guild_id)
    return custom if custom else (default or discord.Color.blurple())


def effective_content_visibility(guild_settings, channel):
    """Resolve the visibility policy for one Discord channel."""
    override = channel_visibility_override(
        channel_visibility_overrides,
        channel,
    )
    return resolve_content_visibility(
        guild_settings,
        override,
        channel_is_nsfw=is_nsfw_channel(channel),
    )


class CommandInfoView(ui.LayoutView):
    """Static Components V2 card for public informational commands."""

    def __init__(self, *, title, description, sections, accent_color, footer, controls=()):
        super().__init__(timeout=180)
        render_command_layout(
            self,
            title=title,
            description=description,
            sections=sections,
            controls=controls,
            accent_color=accent_color,
            footer=footer,
        )


async def init_db():
    db = await aiosqlite.connect('fixembed_data.db')
    await db.execute('''CREATE TABLE IF NOT EXISTS channel_states (channel_id INTEGER PRIMARY KEY, state BOOLEAN)''')
    await db.commit()
    await db.execute('''CREATE TABLE IF NOT EXISTS guild_settings (guild_id INTEGER PRIMARY KEY, enabled_services TEXT, mention_users BOOLEAN, delete_original BOOLEAN DEFAULT TRUE, language TEXT DEFAULT 'en', embed_color TEXT DEFAULT NULL, delivery_mode TEXT DEFAULT 'suppress', media_quality TEXT DEFAULT 'balanced', footer_branding_enabled BOOLEAN DEFAULT FALSE, footer_emoji_id INTEGER DEFAULT NULL, show_nsfw BOOLEAN DEFAULT FALSE, show_spoilers BOOLEAN DEFAULT FALSE)''')
    await db.commit()
    await db.execute('''CREATE TABLE IF NOT EXISTS channel_service_rules (guild_id INTEGER, channel_id INTEGER, service TEXT, action TEXT, PRIMARY KEY (guild_id, channel_id, service))''')
    await db.commit()

    try:
        await db.execute('ALTER TABLE guild_settings ADD COLUMN mention_users BOOLEAN DEFAULT TRUE')
        await db.commit()
    except sqlite3.OperationalError as e:
        if 'duplicate column name' in str(e):
            pass
        else:
            raise

    try:
        await db.execute('ALTER TABLE guild_settings ADD COLUMN delete_original BOOLEAN DEFAULT TRUE')
        await db.commit()
    except sqlite3.OperationalError as e:
        if 'duplicate column name' in str(e):
            pass
        else:
            raise

    try:
        await db.execute("ALTER TABLE guild_settings ADD COLUMN language TEXT DEFAULT 'en'")
        await db.commit()
    except sqlite3.OperationalError as e:
        if 'duplicate column name' in str(e):
            pass
        else:
            raise

    try:
        await db.execute('ALTER TABLE guild_settings ADD COLUMN embed_color TEXT DEFAULT NULL')
        await db.commit()
    except sqlite3.OperationalError as e:
        if 'duplicate column name' in str(e):
            pass
        else:
            raise

    try:
        await db.execute("ALTER TABLE guild_settings ADD COLUMN delivery_mode TEXT DEFAULT 'suppress'")
        await db.commit()
    except sqlite3.OperationalError as e:
        if 'duplicate column name' in str(e):
            pass
        else:
            raise

    try:
        await db.execute("ALTER TABLE guild_settings ADD COLUMN media_quality TEXT DEFAULT 'balanced'")
        await db.commit()
    except sqlite3.OperationalError as e:
        if 'duplicate column name' in str(e):
            pass
        else:
            raise

    try:
        await db.execute("ALTER TABLE guild_settings ADD COLUMN footer_branding_enabled BOOLEAN DEFAULT FALSE")
        await db.commit()
    except sqlite3.OperationalError as e:
        if 'duplicate column name' in str(e):
            pass
        else:
            raise

    try:
        await db.execute("ALTER TABLE guild_settings ADD COLUMN footer_emoji_id INTEGER DEFAULT NULL")
        await db.commit()
    except sqlite3.OperationalError as e:
        if 'duplicate column name' in str(e):
            pass
        else:
            raise

    try:
        await db.execute("ALTER TABLE guild_settings ADD COLUMN show_nsfw BOOLEAN DEFAULT FALSE")
        await db.commit()
    except sqlite3.OperationalError as e:
        if 'duplicate column name' in str(e):
            pass
        else:
            raise

    try:
        await db.execute("ALTER TABLE guild_settings ADD COLUMN show_spoilers BOOLEAN DEFAULT FALSE")
        await db.commit()
    except sqlite3.OperationalError as e:
        if 'duplicate column name' in str(e):
            pass
        else:
            raise

    return db

async def load_channel_states(db):
    async with db.execute('SELECT channel_id, state FROM channel_states') as cursor:
        async for row in cursor:
            channel_states[row[0]] = row[1]

    for guild in client.guilds:
        for channel in guild.text_channels:
            if channel.id not in channel_states:
                channel_states[channel.id] = True

async def load_settings(db):
    async with db.execute('SELECT guild_id, enabled_services, mention_users, delete_original, language, embed_color, delivery_mode, media_quality, footer_branding_enabled, footer_emoji_id, show_nsfw, show_spoilers FROM guild_settings') as cursor:
        async for row in cursor:
            guild_id = row[0]
            enabled_services = row[1]
            mention_users = row[2]
            delete_original = row[3]
            language = row[4] if len(row) > 4 else "en"
            embed_color = row[5] if len(row) > 5 else None
            delivery_mode = row[6] if len(row) > 6 else "suppress"
            media_quality = row[7] if len(row) > 7 else "balanced"
            footer_branding_enabled = row[8] if len(row) > 8 else False
            footer_emoji_id = row[9] if len(row) > 9 else None
            show_nsfw = row[10] if len(row) > 10 else False
            show_spoilers = row[11] if len(row) > 11 else False
            enabled_services_list = ast.literal_eval(enabled_services) if enabled_services else DEFAULT_ENABLED_SERVICES          
            bot_settings[guild_id] = {
                "enabled_services": enabled_services_list,
                "mention_users": mention_users if mention_users is not None else True,
                "delete_original": delete_original if delete_original is not None else True,
                "language": language if language else "en",
                "embed_color": embed_color,
                "delivery_mode": delivery_mode if delivery_mode else "suppress",
                "media_quality": media_quality if media_quality else "balanced",
                "footer_branding_enabled": bool(footer_branding_enabled),
                "footer_emoji_id": footer_emoji_id,
                "show_nsfw": bool(show_nsfw),
                "show_spoilers": bool(show_spoilers),
            }

async def update_channel_state(db, channel_id, state):
    retries = 5
    for i in range(retries):
        try:
            await db.execute('INSERT OR REPLACE INTO channel_states (channel_id, state) VALUES (?, ?)', (channel_id, state))
            await db.commit()
            break
        except sqlite3.OperationalError as e:
            if 'locked' in str(e):
                await asyncio.sleep(0.1)
            else:
                raise

async def update_setting(
    db,
    guild_id,
    enabled_services,
    mention_users,
    delete_original,
    language="en",
    embed_color=None,
    delivery_mode="suppress",
    media_quality="balanced",
    footer_branding_enabled=False,
    footer_emoji_id=None,
    show_nsfw=False,
    show_spoilers=False,
):
    retries = 5
    for i in range(retries):
        try:
            await db.execute(
                'INSERT OR REPLACE INTO guild_settings (guild_id, enabled_services, mention_users, delete_original, language, embed_color, delivery_mode, media_quality, footer_branding_enabled, footer_emoji_id, show_nsfw, show_spoilers) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)',
                (
                    guild_id,
                    repr(enabled_services),
                    mention_users,
                    delete_original,
                    language,
                    embed_color,
                    delivery_mode,
                    media_quality,
                    footer_branding_enabled,
                    footer_emoji_id,
                    show_nsfw,
                    show_spoilers,
                ),
            )
            await db.commit()
            break
        except sqlite3.OperationalError as e:
            if 'locked' in str(e):
                await asyncio.sleep(0.1)
            else:
                raise

async def load_channel_service_rules(db):
    async with db.execute('SELECT guild_id, channel_id, service, action FROM channel_service_rules') as cursor:
        async for guild_id, channel_id, service, action in cursor:
            channel_service_rules[(guild_id, channel_id, service)] = action

async def set_channel_service_rule(db, guild_id, channel_id, service, action):
    await db.execute('INSERT OR REPLACE INTO channel_service_rules (guild_id, channel_id, service, action) VALUES (?, ?, ?, ?)', (guild_id, channel_id, service, action))
    await db.commit()
    channel_service_rules[(guild_id, channel_id, service)] = action

def get_service_rule(guild_id, channel_id, service, default_enabled=True):
    rule = channel_service_rules.get((guild_id, channel_id, service))
    if rule == "on":
        return True
    if rule == "off":
        return False
    return default_enabled

@client.event
async def on_ready():
    print(f'We have logged in as {client.user}')
    logging.info(f'Logged in as {client.user}')
    if (
        os.getenv("PIXIV_RELAY_ENABLED") == "1"
        and getattr(client, "pixiv_relay_runner", None) is None
    ):
        try:
            client.pixiv_relay_runner = await start_pixiv_relay()
        except Exception as error:
            logging.exception("Pixiv relay startup failed: %s", error)
    client.db = await init_db()
    await init_content_visibility(client.db)
    await init_premium_controls(client.db)
    await migrate_youtube_service_default(client.db)
    await migrate_pinterest_service_default(client.db)
    await migrate_new_social_services_default(client.db)
    await load_channel_states(client.db)
    await load_settings(client.db)
    for guild_id, controls in (await load_premium_controls(client.db)).items():
        bot_settings.setdefault(
            guild_id,
            {
                "enabled_services": DEFAULT_ENABLED_SERVICES.copy(),
                "mention_users": True,
                "delete_original": True,
                "language": "en",
                "delivery_mode": "suppress",
                "media_quality": "balanced",
            },
        ).update(controls)
    await load_channel_service_rules(client.db)
    channel_visibility_overrides.update(
        await load_channel_visibility_overrides(client.db)
    )
    if PREMIUM_SKU_ID:
        try:
            await reconcile_supporter_roles(
                client,
                int(PREMIUM_SKU_ID),
                SUPPORT_GUILD_ID,
                SUPPORTER_ROLE_ID,
            )
        except Exception as error:
            logging.exception("Premium supporter role reconciliation failed: %s", error)
    change_status.start()
    client.loop.create_task(send_worker())

    try:
        synced = await client.tree.sync()
        print(f'Synced {len(synced)} command(s)')
    except Exception as e:
        print(f'Failed to sync commands: {e}')

    client.launch_time = discord.utils.utcnow()

statuses = itertools.cycle([
    "for Twitter links", "for Reddit links", "for Instagram links", "for Threads links", "for Pixiv links", "for Bluesky links", "for Bilibili links", "for YouTube links", "for Pinterest links", "for TikTok links", "for Tumblr links", "for Twitch links"
])

@tasks.loop(seconds=60)
async def change_status():
    current_status = next(statuses)
    try:
        await client.change_presence(activity=discord.Activity(type=discord.ActivityType.watching, name=current_status))
    except discord.errors.HTTPException as e:
        logging.error(f"Failed to change status: {e}")


async def build_components_v2_link(
    item,
    guild_settings,
    footer_branding,
    card_preferences,
    *,
    premium=False,
):
    """Build the same Components V2 card for automatic and command entry points."""
    media_quality = guild_settings.get("media_quality", "balanced")
    translated_item = with_translation_language(item, guild_settings)
    translation_language = translated_item.language
    automatic_url = build_automatic_url(
        translated_item,
        media_quality,
        os.getenv("AUTO_TWITTER_PROVIDER", "fixembed"),
    )
    request_id = new_request_id()
    files: tuple[discord.File, ...] = ()
    async with conversion_telemetry.observe(item.service, request_id):
        if item.service == "Instagram":
            instagram_delivery = await fetch_instagram_delivery(
                item.canonical_url,
                automatic_url,
                footer_branding,
                card_preferences,
                translation_language=translation_language,
            )
            layout = instagram_delivery.layout
            files = instagram_delivery.files
        elif item.service == "Twitter":
            fixed_url = build_fixembed_url(translated_item, media_quality)
            payload = await fetch_twitter_payload(
                item.canonical_url,
                translation_language,
                item.mode,
            )
            layout = build_twitter_layout(
                payload,
                fixed_url,
                footer_branding,
                card_preferences,
            )
        elif item.service == "Reddit":
            layout = await fetch_reddit_layout(
                item.canonical_url,
                automatic_url,
                footer_branding,
                card_preferences,
                translation_language=translation_language,
            )
        elif item.service == "Threads":
            layout = await fetch_threads_layout(
                item.canonical_url,
                automatic_url,
                footer_branding,
                card_preferences,
                translation_language=translation_language,
            )
        elif item.service == "Pixiv":
            layout = await fetch_pixiv_layout(
                item.canonical_url,
                automatic_url,
                footer_branding,
                card_preferences,
                translation_language=translation_language,
            )
        elif item.service == "Bluesky":
            layout = await fetch_bluesky_layout(
                item.canonical_url,
                automatic_url,
                footer_branding,
                card_preferences,
                translation_language=translation_language,
            )
        elif item.service == "Bilibili":
            layout = await fetch_bilibili_layout(
                item.canonical_url,
                automatic_url,
                footer_branding,
                card_preferences,
                translation_language=translation_language,
            )
        elif item.service == "YouTube":
            layout = await fetch_youtube_community_layout(
                item.canonical_url,
                automatic_url,
                footer_branding,
                card_preferences,
                translation_language=translation_language,
            )
        elif item.service == "Pinterest":
            layout = await fetch_pinterest_layout(
                item.canonical_url,
                automatic_url,
                footer_branding,
                card_preferences,
                translation_language=translation_language,
            )
        elif item.service == "TikTok":
            layout = await fetch_tiktok_layout(
                item.canonical_url,
                automatic_url,
                footer_branding,
                card_preferences,
                translation_language=translation_language,
            )
        elif item.service == "Tumblr":
            layout = await fetch_tumblr_layout(
                item.canonical_url,
                automatic_url,
                footer_branding,
                card_preferences,
                translation_language=translation_language,
            )
        elif item.service == "Twitch":
            layout = await fetch_twitch_layout(
                item.canonical_url,
                automatic_url,
                footer_branding,
                card_preferences,
                translation_language=translation_language,
            )
        elif item.service == "DeviantArt":
            layout = await fetch_deviantart_layout(
                item.canonical_url,
                automatic_url,
                footer_branding,
                card_preferences,
                translation_language=translation_language,
            )
        else:
            raise ValueError("unsupported rich-card service")
    return ComponentsV2Delivery(
        view=layout,
        fallback_url=automatic_url,
        files=files,
    )


def with_translation_language(item, guild_settings):
    """Apply an explicit or guild-default translation to every delivery path."""
    return replace(
        item,
        language=resolve_translation_language(item.language, guild_settings),
    )


async def send_components_v2_links(interaction, links):
    """Respond to a user command with modern cards and safe URL fallbacks."""
    guild_id = interaction.guild.id if interaction.guild else None
    guild_settings = bot_settings.get(
        guild_id,
        {
            "enabled_services": DEFAULT_ENABLED_SERVICES,
            "mention_users": True,
            "delete_original": True,
            "delivery_mode": "suppress",
            "media_quality": "balanced",
        },
    )
    premium = await is_guild_premium(guild_id) if guild_id is not None else False
    footer_branding = get_footer_branding(interaction.guild, guild_settings, premium)
    content_visibility = effective_content_visibility(
        guild_settings,
        interaction.channel,
    )
    card_preferences = preferences_from_settings(
        guild_settings,
        premium=premium,
        content_visibility=content_visibility,
    )

    await interaction.response.defer()
    for item in links:
        translated_item = with_translation_language(item, guild_settings)
        fallback_url = build_automatic_url(
            translated_item,
            guild_settings.get("media_quality", "balanced"),
            os.getenv("AUTO_TWITTER_PROVIDER", "fixembed"),
        )
        try:
            delivery = await build_components_v2_link(
                item,
                guild_settings,
                footer_branding,
                card_preferences,
                premium=premium,
            )
        except Exception as error:
            logging.warning(
                "Components V2 command card failed for %s: %s",
                item.service,
                type(error).__name__,
            )
            # Real Reddit comment deletions arrive as a success:true tombstone
            # payload and render above. An exception here means Reddit was
            # unreachable, so fall back to the plain link like other services.
            if keeps_native_reddit_og_on_failure(item.service, item.canonical_url):
                logging.info(
                    "Reddit comment metadata unavailable; sending plain link (#71)"
                )
            await interaction.followup.send(fallback_url, allowed_mentions=no_mentions())
            continue

        try:
            send_options = {"view": delivery.view, "allowed_mentions": no_mentions()}
            if delivery.files:
                send_options["files"] = list(delivery.files)
            await interaction.followup.send(**send_options)
        except discord.HTTPException as error:
            logging.warning(
                "Components V2 command delivery failed for %s: %s",
                item.service,
                type(error).__name__,
            )
            await interaction.followup.send(
                delivery.fallback_url, allowed_mentions=no_mentions()
            )

@client.tree.command(
    name='activate',
    description="Activate link processing in this channel or another channel")
@app_commands.describe(
    channel="The channel to activate link processing in (leave blank for current channel)"
)
async def activate(interaction: discord.Interaction,
                   channel: Optional[discord.TextChannel] = None):
    if not channel:
        channel = interaction.channel
    lang = get_guild_lang(interaction.guild.id if interaction.guild else None)
    channel_states[channel.id] = True
    await update_channel_state(client.db, channel.id, True)
    view = SettingsNoticeView(
        title=f"{client.user.name} Activated",
        description=get_text(lang, "activated_for", channel=channel.mention),
        accent_color=discord.Color(0x78B159),
        footer="Activation",
    )
    await interaction.response.send_message(view=view, ephemeral=True)

@client.tree.command(
    name='deactivate',
    description="Deactivate link processing in this channel or another channel")
@app_commands.describe(
    channel="The channel to deactivate link processing in (leave blank for current channel)"
)
async def deactivate(interaction: discord.Interaction,
                     channel: Optional[discord.TextChannel] = None):
    if not channel:
        channel = interaction.channel
    lang = get_guild_lang(interaction.guild.id if interaction.guild else None)
    channel_states[channel.id] = False
    await update_channel_state(client.db, channel.id, False)
    view = SettingsNoticeView(
        title=f"{client.user.name} Deactivated",
        description=get_text(lang, "deactivated_for", channel=channel.mention),
        accent_color=discord.Color.red(),
        footer="Activation",
    )
    await interaction.response.send_message(view=view, ephemeral=True)

@client.tree.command(
    name='about',
    description="Show information about the bot")
@app_commands.allowed_installs(guilds=True, users=True)
@app_commands.allowed_contexts(guilds=True, dms=True, private_channels=True)
async def about(interaction: discord.Interaction):
    guild_id = interaction.guild.id if interaction.guild else None
    lang = get_guild_lang(guild_id)
    view = CommandInfoView(
        title=get_text(lang, "about_title"),
        description=get_text(lang, "about_description"),
        sections=(
            (
                get_text(lang, "quick_links"),
                "Choose **Install to My Account** to use `/fix` and the message command anywhere, "
                "or **Add to Server** for automatic link conversion.\n\n"
                "- [Vote for FixEmbed on Top.gg](https://top.gg/bot/1173820242305224764)\n"
                "- [Source Code (AGPL-3.0-or-later)](https://github.com/kenhendricks00/FixEmbed)\n"
                "- [Join the Support Server](https://discord.gg/QFxTAmtZdn)",
            ),
            (
                "Fallback services & acknowledgements",
                "FixEmbed uses first-party platform data whenever available. When a platform blocks or limits access, it may use:\n\n"
                "- [FxTwitter](https://github.com/FxEmbed/FxEmbed) — X metadata fallback\n"
                "- [VxInstagram](https://github.com/Lainmode/InstagramEmbed-vxinstagram) — Instagram fallback\n"
                "- [KKInstagram](https://kkinstagram.com) — Instagram media fallback\n"
                "- [SnapSave](https://snapsave.app) — Instagram media recovery\n"
                "- [Phixiv](https://github.com/thelaao/phixiv) — Pixiv fallback\n"
                "- [VxBilibili](https://github.com/niconi21/vxBilibili) — Bilibili fallback\n\n"
                "These services are not affiliated with or endorsed by FixEmbed.",
            ),
            (
                "License & Attribution",
                "FixEmbed was created by Kenneth Hendricks and is licensed under "
                "[AGPL-3.0-or-later](https://github.com/kenhendricks00/FixEmbed/blob/main/LICENSE).",
            ),
        ),
        accent_color=get_guild_color(guild_id, discord.Color(0x7289DA)),
        footer=f"About  ·  v{VERSION}",
        controls=build_install_controls(),
    )
    await interaction.response.send_message(view=view)

@client.tree.command(
    name='help',
    description="Show all available commands")
@app_commands.allowed_installs(guilds=True, users=True)
@app_commands.allowed_contexts(guilds=True, dms=True, private_channels=True)
async def help_command(interaction: discord.Interaction):
    guild_id = interaction.guild.id if interaction.guild else None
    lang = get_guild_lang(guild_id)
    view = CommandInfoView(
        title=get_text(lang, "help_title"),
        description=get_text(lang, "help_description"),
        sections=(
            (get_text(lang, "fix_links"), get_text(lang, "fix_links_value")),
            (get_text(lang, "server_settings"), get_text(lang, "server_settings_value")),
            (get_text(lang, "info"), get_text(lang, "info_value")),
            ("💎 " + get_text(lang, "premium_title"), get_text(lang, "premium_help_value")),
            (get_text(lang, "supported_services"), get_text(lang, "supported_services_value")),
            (get_text(lang, "tip"), get_text(lang, "tip_value")),
            (get_text(lang, "languages_supported"), get_text(lang, "languages_supported_value")),
        ),
        accent_color=get_guild_color(guild_id, discord.Color(0x7289DA)),
        footer=f"Help  ·  v{VERSION}",
        controls=build_install_controls(),
    )
    await interaction.response.send_message(view=view)


@client.tree.command(
    name='invite',
    description="Install FixEmbed to your account or add it to a server")
@app_commands.allowed_installs(guilds=True, users=True)
@app_commands.allowed_contexts(guilds=True, dms=True, private_channels=True)
async def invite(interaction: discord.Interaction):
    guild_id = interaction.guild.id if interaction.guild else None
    view = CommandInfoView(
        title="Install FixEmbed",
        description=(
            "Use FixEmbed anywhere with a personal install, or add it to a server "
            "for automatic link conversion and server settings."
        ),
        sections=(
            (
                "Choose an install",
                "**Install to My Account** — use `/fix` and Apps → Fix Embed in DMs, "
                "group chats, and servers.\n\n"
                "**Add to Server** — automatically convert supported links and unlock "
                "server-wide controls.",
            ),
        ),
        accent_color=get_guild_color(guild_id, discord.Color(0x7289DA)),
        footer=f"Install  ·  v{VERSION}",
        controls=build_install_controls(),
    )
    await interaction.response.send_message(view=view, ephemeral=True)


@client.tree.command(
    name='fix',
    description="Convert social media links into polished FixEmbed links")
@app_commands.describe(link="Paste one or more supported social media links")
@app_commands.allowed_installs(guilds=True, users=True)
@app_commands.allowed_contexts(guilds=True, dms=True, private_channels=True)
async def fix_link(interaction: discord.Interaction, link: str):
    """Convert one or more social media links to Components V2 cards."""
    lang = get_guild_lang(interaction.guild.id if interaction.guild else None)
    links = extract_supported_links(link)

    if not links:
        await interaction.response.send_message(get_text(lang, "no_supported_link"), ephemeral=True)
        return

    await send_components_v2_links(interaction, links)

@client.tree.context_menu(name='Fix Embed')
@app_commands.allowed_installs(guilds=True, users=True)
@app_commands.allowed_contexts(guilds=True, dms=True, private_channels=True)
async def fix_embed_context(interaction: discord.Interaction, message: discord.Message):
    """Convert social media links in a message to Components V2 cards."""
    lang = get_guild_lang(interaction.guild.id if interaction.guild else None)
    links = extract_supported_links(message.content)

    if not links:
        await interaction.response.send_message(get_text(lang, "no_links_found"), ephemeral=True)
        return

    await send_components_v2_links(interaction, links)

async def debug_info(interaction: discord.Interaction, channel: Optional[discord.TextChannel] = None):
    settings = bot_settings.get(
        interaction.guild.id,
        {
            "enabled_services": DEFAULT_ENABLED_SERVICES,
            "mention_users": True,
            "delete_original": True,
            "delivery_mode": "suppress",
            "media_quality": "balanced",
        },
    )
    await interaction.response.send_message(
        view=DebugSettingsView(interaction, settings),
        ephemeral=True,
    )


# Components V2 settings implementation used by the private configuration flow.


class SettingsPageView(ui.LayoutView):
    def __init__(self, interaction, settings, *, timeout=180):
        super().__init__(timeout=timeout)
        self.interaction = interaction
        self.settings = settings

    @property
    def lang(self):
        return self.settings.get("language", "en")

    async def save(self):
        await update_setting(
            client.db,
            self.interaction.guild.id,
            self.settings.get("enabled_services", DEFAULT_ENABLED_SERVICES),
            self.settings.get("mention_users", True),
            self.settings.get("delete_original", True),
            self.settings.get("language", "en"),
            self.settings.get("embed_color"),
            self.settings.get("delivery_mode", "suppress"),
            self.settings.get("media_quality", "balanced"),
            self.settings.get("footer_branding_enabled", False),
            self.settings.get("footer_emoji_id"),
            self.settings.get("show_nsfw", False),
            self.settings.get("show_spoilers", False),
        )

    def render_page(self, *, title, description, status=None, controls=(), accent_color=None, footer="Settings"):
        rows = list(controls)
        if not isinstance(self, SettingsView):
            rows.append((SettingsDropdown(self.interaction, self.settings),))
        render_settings_layout(
            self,
            title=title,
            description=description,
            status=status,
            controls=rows,
            accent_color=accent_color or get_guild_color(self.interaction.guild.id),
            footer=footer,
        )
        return self


class SettingsNoticeView(ui.LayoutView):
    def __init__(self, *, title, description, accent_color, footer, controls=()):
        super().__init__(timeout=180)
        render_settings_layout(
            self,
            title=title,
            description=description,
            controls=controls,
            accent_color=accent_color,
            footer=footer,
        )



def format_premium_activation_checklist(lang, settings, items):
    """Render configured-vs-available checklist lines with /settings paths.

    Each settings path sits on its own line as one NBSP-backed inline-code
    token so Discord cannot wrap mid-path (e.g. after `/` or inside page names).
    """
    lines = []
    for item in items:
        mark = get_text(
            lang,
            "premium_checklist_done" if item.configured else "premium_checklist_todo",
        )
        if item.key == "color":
            if item.configured:
                label = get_text(
                    lang,
                    "premium_item_color_done",
                    color=settings.get("embed_color"),
                )
            else:
                label = get_text(lang, "premium_item_color_todo")
        else:
            suffix = "done" if item.configured else "todo"
            label = get_text(lang, f"premium_item_{item.key}_{suffix}")
        if item.settings_page:
            path = get_text(lang, "premium_item_path", page=item.settings_page)
            lines.append(format_checklist_row(mark, label, path))
        else:
            lines.append(format_checklist_row(mark, label))
    return "\n".join(lines)




async def open_settings_surface(source_interaction, interaction, settings, value):
    """Open the matching /settings page or modal for a dropdown value."""
    if value == "Embed Color":
        status = await guild_premium_status(interaction.guild.id)
        if status == "active":
            await interaction.response.send_modal(
                EmbedColorModal(source_interaction, settings)
            )
            return
        view = PremiumSettingsView(
            source_interaction, settings, unconfirmed=status == "unconfirmed"
        )
        await interaction.response.send_message(view=view, ephemeral=True)
        return
    if value == "Footer Branding":
        # Premium pages take the status so "couldn't confirm" isn't shown as locked (#101).
        premium = await guild_premium_status(interaction.guild.id)
        view = FooterBrandingSettingsView(
            source_interaction, settings, premium=premium
        )
        await interaction.response.send_message(view=view, ephemeral=True)
        return
    if value == "Translation":
        view = TranslationSettingsView(source_interaction, settings)
        await interaction.response.send_message(view=view, ephemeral=True)
        return
    premium_pages = {
        "Card Style": CardStyleSettingsView,
        "Exclusions": ExclusionSettingsView,
    }
    if value in premium_pages:
        premium = await guild_premium_status(interaction.guild.id)
        view = premium_pages[value](
            source_interaction, settings, premium=premium
        )
        await interaction.response.send_message(view=view, ephemeral=True)
        return
    if value == "Analytics":
        premium = await guild_premium_status(interaction.guild.id)
        summary = []
        if premium == "active":
            try:
                summary = await fetch_analytics_summary(
                    client.db, interaction.guild.id, days=30
                )
            except Exception as error:
                logging.warning(
                    "Premium analytics lookup failed for guild %s: %s",
                    interaction.guild.id,
                    error,
                )
        view = AnalyticsSettingsView(
            source_interaction,
            settings,
            premium=premium,
            summary=summary,
        )
        await interaction.response.send_message(view=view, ephemeral=True)
        return
    if value == "Reliability Status":
        await interaction.response.defer(ephemeral=True)
        report = await reliability_client.get_report()
        view = ReliabilitySettingsView(
            source_interaction,
            settings,
            report=report,
        )
        await interaction.followup.send(view=view, ephemeral=True)
        return

    page_types = {
        "FixEmbed": FixEmbedSettingsView,
        "Mention Users": MentionUsersSettingsView,
        "Delivery Method": DeliveryMethodSettingsView,
        "Service Settings": ServiceSettingsView,
        "Quality Profile": QualitySettingsView,
        "Content Visibility": ContentVisibilitySettingsView,
        "Channel Visibility": ChannelVisibilitySettingsView,
        "Channel Rules": ChannelRulesSettingsView,
        "Language": LanguageSettingsView,
        "Debug": DebugSettingsView,
    }
    view = page_types[value](source_interaction, settings)
    await interaction.response.send_message(view=view, ephemeral=True)


class SettingsDropdown(ui.Select):
    def __init__(self, interaction, settings):
        self.source_interaction = interaction
        self.settings = settings
        lang = settings.get("language", "en")
        options = [
            discord.SelectOption(label=get_text(lang, "fixembed_settings"), description=get_text(lang, "fixembed_activate_deactivate"), value="FixEmbed", emoji="⚙️"),
            discord.SelectOption(label=get_text(lang, "mention_users"), description=get_text(lang, "mention_users_toggle"), value="Mention Users", emoji="🔔"),
            discord.SelectOption(label=get_text(lang, "delivery_method"), description=get_text(lang, "delivery_method_toggle"), value="Delivery Method", emoji="📨"),
            discord.SelectOption(label=get_text(lang, "service_settings"), description=get_text(lang, "service_settings_desc"), value="Service Settings", emoji="🧩"),
            discord.SelectOption(label=get_text(lang, "quality_profile"), description=get_text(lang, "quality_profile_desc"), value="Quality Profile", emoji="🎞️"),
            discord.SelectOption(label=get_text(lang, "content_visibility"), description=get_text(lang, "content_visibility_desc"), value="Content Visibility", emoji="👁️"),
            discord.SelectOption(label=get_text(lang, "channel_visibility"), description=get_text(lang, "channel_visibility_desc"), value="Channel Visibility", emoji="🛡️"),
            discord.SelectOption(label=get_text(lang, "channel_rules"), description=get_text(lang, "channel_rules_desc"), value="Channel Rules", emoji="🧭"),
            discord.SelectOption(label=get_text(lang, "reliability_status"), description=get_text(lang, "reliability_status_desc"), value="Reliability Status", emoji="📊"),
            discord.SelectOption(label=get_text(lang, "language"), description=get_text(lang, "language_desc"), value="Language", emoji="🌐"),
            discord.SelectOption(label=get_text(lang, "debug"), description=get_text(lang, "debug_desc"), value="Debug", emoji="🐞"),
            discord.SelectOption(label=get_text(lang, "embed_color"), description=get_text(lang, "embed_color_desc"), value="Embed Color", emoji="💎"),
            discord.SelectOption(label="Card Style", description="Customize social cards (Premium)", value="Card Style", emoji="🎛️"),
            discord.SelectOption(label="Translation", description="Translate every supported platform", value="Translation", emoji="🌐"),
            discord.SelectOption(label="Exclusions", description="Ignore members or roles (Premium)", value="Exclusions", emoji="🛡️"),
            discord.SelectOption(label="Analytics", description="View private 30-day insights (Premium)", value="Analytics", emoji="📈"),
            discord.SelectOption(
                label="Footer Branding",
                description="Use this server's identity in social cards (Premium)",
                value="Footer Branding",
                emoji="🏷️",
            ),
        ]
        super().__init__(placeholder=get_text(lang, "choose_option"), options=options)

    async def callback(self, interaction: discord.Interaction):
        await open_settings_surface(
            self.source_interaction, interaction, self.settings, self.values[0]
        )


class SettingsView(SettingsPageView):
    def __init__(self, interaction, settings, *, premium=False):
        super().__init__(interaction, settings)
        enabled = settings.get("enabled_services", DEFAULT_ENABLED_SERVICES)
        delivery = settings.get("delivery_mode", "suppress")
        quality = settings.get("media_quality", "balanced")
        controls = [(SettingsDropdown(interaction, settings),)]
        if PREMIUM_SKU_ID and not premium:
            controls.append((discord.ui.Button(
                style=discord.ButtonStyle.premium,
                sku_id=int(PREMIUM_SKU_ID),
            ),))
        status = (
            f"**Services:** {len(enabled)}/{len(DEFAULT_ENABLED_SERVICES)} enabled\n"
            f"**Delivery:** {delivery.title()}  ·  **Quality:** {quality.title()}\n"
            f"**Language:** {LANGUAGE_NAMES.get(settings.get('language', 'en'), 'English')}"
        )
        self.render_page(
            title=get_text(self.lang, "settings_title"),
            description=get_text(self.lang, "settings_description"),
            status=status,
            controls=controls,
            footer="Server settings",
        )


class ServiceSelect(ui.Select):
    def __init__(self, view):
        enabled = view.settings.get("enabled_services", DEFAULT_ENABLED_SERVICES)
        options = [
            discord.SelectOption(
                label=service,
                value=service,
                emoji=get_service_select_emoji(view.interaction.guild, service),
                default=service in enabled,
            )
            for service in DEFAULT_ENABLED_SERVICES
        ]
        super().__init__(placeholder="Select services to activate...", min_values=1, max_values=len(options), options=options)
        self.page = view

    async def callback(self, interaction):
        self.page.settings["enabled_services"] = list(self.values)
        await self.page.save()
        self.page.render()
        await interaction.response.edit_message(view=self.page)


class ServiceSettingsView(SettingsPageView):
    def __init__(self, interaction, settings):
        super().__init__(interaction, settings)
        self.render()

    def render(self):
        enabled = self.settings.get("enabled_services", DEFAULT_ENABLED_SERVICES)
        status = "\n".join(
            f"{'\U0001f7e2' if service in enabled else '\U0001f534'} {get_service_display_icon(self.interaction.guild, service)} {service}"
            for service in DEFAULT_ENABLED_SERVICES
        )
        self.render_page(
            title=get_text(self.lang, "service_settings"),
            description=get_text(self.lang, "service_settings_desc"),
            status=status,
            controls=((ServiceSelect(self),),),
            footer="Service settings",
        )


class QualitySelect(ui.Select):
    def __init__(self, view):
        current = view.settings.get("media_quality", "balanced")
        options = [
            discord.SelectOption(label=get_text(view.lang, f"quality_{value}"), value=value, description=get_text(view.lang, f"quality_{value}_desc"), default=current == value)
            for value in ("fastest", "balanced", "highest")
        ]
        super().__init__(placeholder=get_text(view.lang, "quality_select_placeholder"), options=options)
        self.page = view

    async def callback(self, interaction):
        self.page.settings["media_quality"] = self.values[0]
        await self.page.save()
        self.page.render()
        await interaction.response.edit_message(view=self.page)


class QualitySettingsView(SettingsPageView):
    def __init__(self, interaction, settings):
        super().__init__(interaction, settings)
        self.render()

    def render(self):
        current = self.settings.get("media_quality", "balanced")
        self.render_page(
            title=get_text(self.lang, "quality_profile"),
            description=get_text(self.lang, "quality_profile_desc"),
            status=get_text(self.lang, "quality_current_profile", profile=current),
            controls=((QualitySelect(self),),),
            footer="Media quality",
        )


class ContentVisibilitySettingsView(SettingsPageView):
    def __init__(self, interaction, settings):
        super().__init__(interaction, settings)
        self.render()

    def render(self):
        show_nsfw = bool(self.settings.get("show_nsfw", False))
        show_spoilers = bool(self.settings.get("show_spoilers", False))
        nsfw_button = discord.ui.Button(
            label=get_text(
                self.lang,
                "content_visibility_hide_nsfw" if show_nsfw
                else "content_visibility_show_nsfw",
            ),
            style=discord.ButtonStyle.green if show_nsfw else discord.ButtonStyle.secondary,
        )
        nsfw_button.callback = self.toggle_nsfw
        spoilers_button = discord.ui.Button(
            label=get_text(
                self.lang,
                "content_visibility_hide_spoilers" if show_spoilers
                else "content_visibility_show_spoilers",
            ),
            style=discord.ButtonStyle.green if show_spoilers else discord.ButtonStyle.secondary,
        )
        spoilers_button.callback = self.toggle_spoilers
        self.render_page(
            title=get_text(self.lang, "content_visibility_title"),
            description=get_text(self.lang, "content_visibility_instructions"),
            status=get_text(
                self.lang,
                "content_visibility_status",
                nsfw_status="✅" if show_nsfw else "❌",
                spoiler_status="✅" if show_spoilers else "❌",
            ),
            controls=((nsfw_button, spoilers_button),),
            footer="Content visibility",
        )

    async def toggle_nsfw(self, interaction):
        self.settings["show_nsfw"] = not bool(
            self.settings.get("show_nsfw", False)
        )
        await self.save()
        self.render()
        await interaction.response.edit_message(view=self)

    async def toggle_spoilers(self, interaction):
        self.settings["show_spoilers"] = not bool(
            self.settings.get("show_spoilers", False)
        )
        await self.save()
        self.render()
        await interaction.response.edit_message(view=self)


class ChannelVisibilityChannelSelect(ui.ChannelSelect):
    def __init__(self, page):
        super().__init__(
            placeholder=get_text(page.lang, "channel_visibility_pick_channel"),
            channel_types=[
                discord.ChannelType.text,
                discord.ChannelType.news,
                discord.ChannelType.voice,
                discord.ChannelType.stage_voice,
                discord.ChannelType.forum,
                discord.ChannelType.media,
                discord.ChannelType.news_thread,
                discord.ChannelType.public_thread,
                discord.ChannelType.private_thread,
            ],
            min_values=1,
            max_values=1,
            default_values=(
                [page.selected_channel]
                if page.selected_channel is not None
                else []
            ),
        )
        self.page = page

    async def callback(self, interaction):
        self.page.selected_channel_id = self.values[0].id
        self.page.load_selected_override()
        self.page.render()
        await interaction.response.edit_message(view=self.page)


class ChannelVisibilityValueSelect(ui.Select):
    VALUES = {
        "inherit": None,
        "show": True,
        "hide": False,
    }

    def __init__(self, page, setting_name, placeholder_key):
        current = getattr(page, setting_name)
        options = [
            discord.SelectOption(
                label=get_text(page.lang, f"channel_visibility_{value}"),
                value=value,
                default=resolved is current,
            )
            for value, resolved in self.VALUES.items()
        ]
        super().__init__(
            placeholder=get_text(page.lang, placeholder_key),
            options=options,
            disabled=page.selected_channel is None,
        )
        self.page = page
        self.setting_name = setting_name

    async def callback(self, interaction):
        setattr(self.page, self.setting_name, self.VALUES[self.values[0]])
        self.page.render()
        await interaction.response.edit_message(view=self.page)


class ChannelVisibilitySettingsView(SettingsPageView):
    def __init__(self, interaction, settings):
        super().__init__(interaction, settings)
        self.selected_channel_id = getattr(interaction.channel, "id", None)
        self.show_nsfw = None
        self.show_spoilers = None
        self.load_selected_override()
        self.render()

    @property
    def selected_channel(self):
        if self.selected_channel_id is None:
            return None
        return self.interaction.guild.get_channel_or_thread(
            self.selected_channel_id
        )

    def load_selected_override(self):
        if self.selected_channel_id is None:
            self.show_nsfw = None
            self.show_spoilers = None
            return
        override = channel_visibility_overrides.get(
            (self.interaction.guild.id, self.selected_channel_id),
            {},
        )
        self.show_nsfw = override.get("show_nsfw")
        self.show_spoilers = override.get("show_spoilers")

    @staticmethod
    def override_label(value):
        if value is True:
            return "Show"
        if value is False:
            return "Hide"
        return "Inherit"

    def render(self):
        channel = self.selected_channel
        draft_override = {
            "show_nsfw": self.show_nsfw,
            "show_spoilers": self.show_spoilers,
        }
        effective = resolve_content_visibility(
            self.settings,
            draft_override,
            channel_is_nsfw=is_nsfw_channel(channel),
        )
        apply_button = discord.ui.Button(
            label=get_text(self.lang, "channel_visibility_apply"),
            style=discord.ButtonStyle.green,
            disabled=channel is None,
        )
        apply_button.callback = self.apply_override
        self.render_page(
            title=get_text(self.lang, "channel_visibility_title"),
            description=get_text(self.lang, "channel_visibility_instructions"),
            status=get_text(
                self.lang,
                "channel_visibility_status",
                channel=(
                    channel.mention
                    if channel is not None
                    else get_text(self.lang, "channel_visibility_unavailable")
                ),
                nsfw_override=self.override_label(self.show_nsfw),
                nsfw_effective=self.override_label(effective.show_nsfw),
                spoiler_override=self.override_label(self.show_spoilers),
                spoiler_effective=self.override_label(effective.show_spoilers),
            ),
            controls=(
                (ChannelVisibilityChannelSelect(self),),
                (
                    ChannelVisibilityValueSelect(
                        self,
                        "show_nsfw",
                        "channel_visibility_nsfw",
                    ),
                ),
                (
                    ChannelVisibilityValueSelect(
                        self,
                        "show_spoilers",
                        "channel_visibility_spoilers",
                    ),
                ),
                (apply_button,),
            ),
            footer="Channel visibility",
        )

    async def apply_override(self, interaction):
        if self.selected_channel is None:
            self.render()
            await interaction.response.edit_message(view=self)
            return
        key = (self.interaction.guild.id, self.selected_channel_id)
        await set_channel_visibility_override(
            client.db,
            guild_id=key[0],
            channel_id=key[1],
            show_nsfw=self.show_nsfw,
            show_spoilers=self.show_spoilers,
        )
        if self.show_nsfw is None and self.show_spoilers is None:
            channel_visibility_overrides.pop(key, None)
        else:
            channel_visibility_overrides[key] = {
                "show_nsfw": self.show_nsfw,
                "show_spoilers": self.show_spoilers,
            }
        self.render()
        await interaction.response.edit_message(view=self)


class LanguageSelect(ui.Select):
    def __init__(self, view):
        current = view.settings.get("language", "en")
        options = [
            discord.SelectOption(label=name, value=code, emoji=LANGUAGE_FLAG_EMOJIS.get(code, "🌐"), default=code == current)
            for code, name in LANGUAGE_NAMES.items()
        ]
        super().__init__(placeholder=get_text(current, "language_select"), options=options)
        self.page = view

    async def callback(self, interaction):
        self.page.settings["language"] = self.values[0]
        await self.page.save()
        self.page.render()
        await interaction.response.edit_message(view=self.page)


class LanguageSettingsView(SettingsPageView):
    def __init__(self, interaction, settings):
        super().__init__(interaction, settings)
        self.render()

    def render(self):
        current = LANGUAGE_NAMES.get(self.settings.get("language", "en"), "English")
        self.render_page(
            title=get_text(self.lang, "language_title"),
            description=get_text(self.lang, "language_current", language=current),
            controls=((LanguageSelect(self),),),
            footer="Language",
        )


class ToggleSettingsView(SettingsPageView):
    setting_key = ""
    title_key = ""

    def __init__(self, interaction, settings):
        super().__init__(interaction, settings)
        self.render()

    def current_value(self):
        return bool(self.settings.get(self.setting_key, True))

    def description(self):
        status = get_text(self.lang, "activated") if self.current_value() else get_text(self.lang, "deactivated")
        return get_text(self.lang, "user_mentions_status", status=status)

    def render(self):
        active = self.current_value()
        button = discord.ui.Button(
            label=get_text(self.lang, "activated") if active else get_text(self.lang, "deactivated"),
            style=discord.ButtonStyle.green if active else discord.ButtonStyle.red,
        )
        button.callback = self.toggle
        self.render_page(
            title=get_text(self.lang, self.title_key),
            description=self.description(),
            controls=((button,),),
            accent_color=discord.Color.green() if active else discord.Color.red(),
        )

    async def toggle(self, interaction):
        self.settings[self.setting_key] = not self.current_value()
        await self.save()
        self.render()
        await interaction.response.edit_message(view=self)


class MentionUsersSettingsView(ToggleSettingsView):
    setting_key = "mention_users"
    title_key = "mention_users_title"


class FixEmbedSettingsView(SettingsPageView):
    def __init__(self, interaction, settings):
        super().__init__(interaction, settings)
        self.activated = all(channel_states.get(ch.id, True) for ch in interaction.guild.text_channels)
        self.render()

    def render(self):
        status = get_text(self.lang, "activated") if self.activated else get_text(self.lang, "deactivated")
        button = discord.ui.Button(label=status, style=discord.ButtonStyle.green if self.activated else discord.ButtonStyle.red)
        button.callback = self.toggle
        self.render_page(
            title=get_text(self.lang, "fixembed_settings"),
            description=f"**{status}**\n{get_text(self.lang, 'note_apply_changes')}",
            controls=((button,),),
            accent_color=discord.Color.green() if self.activated else discord.Color.red(),
            footer="Activation",
        )

    async def toggle(self, interaction):
        self.activated = not self.activated
        for channel in self.interaction.guild.text_channels:
            channel_states[channel.id] = self.activated
            await update_channel_state(client.db, channel.id, self.activated)
        self.render()
        await interaction.response.edit_message(view=self)


class DeliverySelect(ui.Select):
    MODES = {
        "delete": "Delete source message, post fixed link",
        "suppress": "Keep message, suppress original embed",
        "reply": "Keep original and post fixed link",
    }

    def __init__(self, view):
        current = view.settings.get("delivery_mode", "suppress")
        options = [discord.SelectOption(label=name.title(), value=name, description=description, default=current == name) for name, description in self.MODES.items()]
        super().__init__(placeholder="Choose delivery mode...", options=options)
        self.page = view

    async def callback(self, interaction):
        mode = self.values[0]
        self.page.settings["delivery_mode"] = mode
        self.page.settings["delete_original"] = mode == "delete"
        await self.page.save()
        self.page.render()
        await interaction.response.edit_message(view=self.page)


class DeliveryMethodSettingsView(SettingsPageView):
    def __init__(self, interaction, settings):
        super().__init__(interaction, settings)
        self.render()

    def render(self):
        mode = self.settings.get("delivery_mode", "suppress")
        permissions = self.interaction.channel.permissions_for(
            self.interaction.guild.me
        )
        delivery_decision = resolve_delivery_mode(
            mode,
            legacy_delete_original=self.settings.get("delete_original", True),
            can_manage_messages=permissions.manage_messages,
        )
        self.render_page(
            title=get_text(self.lang, "delivery_method_title"),
            description=DeliverySelect.MODES[delivery_decision.configured_mode],
            status=format_delivery_mode_status(delivery_decision),
            controls=((DeliverySelect(self),),),
            footer="Delivery",
        )


class RuleSelect(ui.Select):
    def __init__(self, page, kind, options, placeholder):
        super().__init__(placeholder=placeholder, options=options)
        self.page = page
        self.kind = kind

    async def callback(self, interaction):
        value = self.values[0]
        setattr(self.page, self.kind, int(value) if self.kind == "selected_channel_id" else value)
        self.page.render()
        await interaction.response.edit_message(view=self.page)


class ChannelRulesSettingsView(SettingsPageView):
    def __init__(self, interaction, settings):
        super().__init__(interaction, settings)
        self.selected_channel_id = interaction.channel.id if interaction.channel else None
        self.selected_service = "Twitter"
        self.selected_action = "default"
        self.render()

    def render(self):
        channels = self.interaction.guild.text_channels[:25]
        channel_options = [discord.SelectOption(label=ch.name[:100], value=str(ch.id), default=ch.id == self.selected_channel_id) for ch in channels]
        service_options = [discord.SelectOption(label=name, value=name, emoji=get_service_select_emoji(self.interaction.guild, name), default=name == self.selected_service) for name in DEFAULT_ENABLED_SERVICES]
        action_options = [discord.SelectOption(label=name.title(), value=name, default=name == self.selected_action) for name in ("on", "off", "default")]
        apply_button = discord.ui.Button(label=get_text(self.lang, "channel_rules_apply"), style=discord.ButtonStyle.green)
        apply_button.callback = self.apply_rule
        channel = self.interaction.guild.get_channel(self.selected_channel_id) if self.selected_channel_id else None
        status = get_text(self.lang, "channel_rules_selections", channel=channel.mention if channel else "None", service=self.selected_service, action=self.selected_action)
        self.render_page(
            title=get_text(self.lang, "channel_rules_title"),
            description=get_text(self.lang, "channel_rules_instructions"),
            status=status,
            controls=(
                (RuleSelect(self, "selected_channel_id", channel_options, get_text(self.lang, "channel_rules_pick_channel")),),
                (RuleSelect(self, "selected_service", service_options, get_text(self.lang, "channel_rules_pick_service")),),
                (RuleSelect(self, "selected_action", action_options, get_text(self.lang, "channel_rules_pick_action")),),
                (apply_button,),
            ),
            footer="Channel rules",
        )

    async def apply_rule(self, interaction):
        guild_id = self.interaction.guild.id
        key = (guild_id, self.selected_channel_id, self.selected_service)
        if self.selected_action == "default":
            await client.db.execute("DELETE FROM channel_service_rules WHERE guild_id = ? AND channel_id = ? AND service = ?", key)
            await client.db.commit()
            channel_service_rules.pop(key, None)
        else:
            await set_channel_service_rule(client.db, *key, self.selected_action)
        self.render()
        await interaction.response.edit_message(view=self)


class StaticSettingsView(SettingsPageView):
    def __init__(self, interaction, settings, *, title, description, status, footer):
        super().__init__(interaction, settings)
        self.render_page(title=title, description=description, status=status, footer=footer)


class ReliabilityRefreshButton(ui.Button):
    def __init__(self, page):
        super().__init__(label="Refresh", style=discord.ButtonStyle.secondary, emoji="🔄")
        self.page = page

    async def callback(self, interaction: discord.Interaction):
        await interaction.response.defer()
        self.page.report = await reliability_client.get_report(force=True)
        self.page.render()
        await interaction.edit_original_response(view=self.page)


class ReliabilitySettingsView(SettingsPageView):
    def __init__(self, interaction, settings, *, report: ReliabilityReport):
        super().__init__(interaction, settings)
        self.report = report
        self.render()

    def render(self):
        status = format_reliability_status(
            self.report,
            icon_for_service=lambda service: get_service_display_icon(
                self.interaction.guild, service
            ),
        )
        status += "\n\n" + format_local_conversion_health(
            conversion_telemetry.snapshot(),
            icon_for_service=lambda service: get_service_display_icon(
                self.interaction.guild, service
            ),
        )
        status += "\n\n" + format_delivery_health(
            delivery_telemetry.snapshot(),
            pending=SEND_QUEUE.qsize(),
        )
        controls = ((
            ReliabilityRefreshButton(self),
            discord.ui.Button(
                label="Public status",
                style=discord.ButtonStyle.link,
                url="https://fixembed.app/status",
            ),
        ),)
        self.render_page(
            title=get_text(self.lang, "reliability_status_title"),
            description=get_text(self.lang, "reliability_status_desc"),
            status=status,
            controls=controls,
            footer="Reliability",
        )


class DebugSettingsView(StaticSettingsView):
    def __init__(self, interaction, settings):
        permissions = interaction.channel.permissions_for(interaction.guild.me)
        checks = (
            ("Read messages", permissions.read_messages),
            ("Send messages", permissions.send_messages),
            ("Embed links", permissions.embed_links),
            ("Manage messages", permissions.manage_messages),
        )
        status = "\n".join(f"{'\u2705' if allowed else '\u274c'} {name}" for name, allowed in checks)
        delivery_decision = resolve_delivery_mode(
            settings.get("delivery_mode", "suppress"),
            legacy_delete_original=settings.get("delete_original", True),
            can_manage_messages=permissions.manage_messages,
        )
        status += "\n\n" + format_delivery_mode_status(delivery_decision)
        status += f"\n\n**Shard:** {interaction.guild.shard_id + 1}  ·  **Version:** {VERSION}\n**Uptime:** {str(discord.utils.utcnow() - client.launch_time).split('.')[0]}"
        super().__init__(interaction, settings, title="Debug Information", description="Permission and runtime diagnostics for this server.", status=status, footer="Diagnostics")


def premium_page_state(premium):
    """(active, unconfirmed) from a ``guild_premium_status`` answer or a bool."""
    return premium is True or premium == "active", premium == "unconfirmed"


class PremiumSettingsView(SettingsPageView):
    def __init__(self, interaction, settings, *, unconfirmed=False):
        super().__init__(interaction, settings)
        controls = ()
        # No purchase button when Discord just couldn't confirm a subscription (#101).
        if PREMIUM_SKU_ID and not unconfirmed:
            controls = ((discord.ui.Button(style=discord.ButtonStyle.premium, sku_id=int(PREMIUM_SKU_ID)),),)
        self.render_page(
            title=get_text(self.lang, "embed_color_title"),
            description=get_text(self.lang, "premium_unconfirmed" if unconfirmed else "premium_required"),
            controls=controls,
            accent_color=discord.Color.gold(),
            footer="Premium",
        )


class PremiumControlsPage(SettingsPageView):
    """Base page that rechecks entitlement before every Premium mutation."""

    def __init__(self, interaction, settings, *, premium):
        super().__init__(interaction, settings)
        self.premium, self.premium_unconfirmed = premium_page_state(premium)

    async def save_premium(self):
        await save_premium_controls(
            client.db, self.interaction.guild.id, self.settings
        )

    def render_locked(self, *, title, description):
        controls = ()
        if PREMIUM_SKU_ID and not self.premium_unconfirmed:
            controls = ((discord.ui.Button(
                style=discord.ButtonStyle.premium,
                sku_id=int(PREMIUM_SKU_ID),
            ),),)
        self.render_page(
            title=title,
            description=description,
            status=(
                get_text(self.lang, "premium_unconfirmed")
                if self.premium_unconfirmed
                else "This is a FixEmbed Premium feature."
            ),
            controls=controls,
            accent_color=discord.Color.gold(),
            footer="Premium",
        )

    async def confirm_premium(self, interaction):
        # Re-check before every mutation; nothing is written unless confirmed active.
        self.premium, self.premium_unconfirmed = premium_page_state(
            await guild_premium_status(interaction.guild.id)
        )
        if self.premium:
            return True
        self.render()
        await interaction.response.edit_message(view=self)
        return False


class CaptionModeSelect(ui.Select):
    def __init__(self, page):
        current = page.settings.get("card_caption_mode", "full")
        super().__init__(
            placeholder="Choose caption length...",
            options=[
                discord.SelectOption(
                    label="Full captions", value="full", default=current == "full"
                ),
                discord.SelectOption(
                    label="Compact captions",
                    description="Trim captions after 280 characters",
                    value="compact",
                    default=current == "compact",
                ),
            ],
        )
        self.page = page

    async def callback(self, interaction):
        if not await self.page.confirm_premium(interaction):
            return
        self.page.settings["card_caption_mode"] = self.values[0]
        await self.page.save_premium()
        self.page.render()
        await interaction.response.edit_message(view=self.page)


class CardStyleSettingsView(PremiumControlsPage):
    def __init__(self, interaction, settings, *, premium):
        super().__init__(interaction, settings, premium=premium)
        self.render()

    def render(self):
        if not self.premium:
            self.render_locked(
                title="Social Card Style",
                description="Control stats, hashtags, caption length, and card color.",
            )
            return
        show_stats = bool(self.settings.get("card_show_stats", True))
        show_hashtags = bool(self.settings.get("card_show_hashtags", True))
        stats = discord.ui.Button(
            label=f"Stats: {'Shown' if show_stats else 'Hidden'}",
            style=discord.ButtonStyle.green if show_stats else discord.ButtonStyle.secondary,
        )
        hashtags = discord.ui.Button(
            label=f"Hashtags: {'Shown' if show_hashtags else 'Hidden'}",
            style=discord.ButtonStyle.green if show_hashtags else discord.ButtonStyle.secondary,
        )
        stats.callback = self.toggle_stats
        hashtags.callback = self.toggle_hashtags
        color = self.settings.get("embed_color") or "Platform default"
        self.render_page(
            title="Social Card Style",
            description="Choose a consistent presentation for every supported Components V2 card.",
            status=(
                f"**Accent:** {color}\n"
                f"**Captions:** {self.settings.get('card_caption_mode', 'full').title()}\n"
                "-# Media playback and quality are never paywalled."
            ),
            controls=((stats, hashtags), (CaptionModeSelect(self),)),
            accent_color=discord.Color.gold(),
            footer="Premium card style",
        )

    async def toggle_stats(self, interaction):
        if not await self.confirm_premium(interaction):
            return
        self.settings["card_show_stats"] = not bool(
            self.settings.get("card_show_stats", True)
        )
        await self.save_premium()
        self.render()
        await interaction.response.edit_message(view=self)

    async def toggle_hashtags(self, interaction):
        if not await self.confirm_premium(interaction):
            return
        self.settings["card_show_hashtags"] = not bool(
            self.settings.get("card_show_hashtags", True)
        )
        await self.save_premium()
        self.render()
        await interaction.response.edit_message(view=self)


class TranslationLanguageSelect(ui.Select):
    def __init__(self, page):
        current = page.settings.get("translation_language")
        options = [
            discord.SelectOption(
                label="Original language", value="none", default=current is None
            )
        ]
        options.extend(
            discord.SelectOption(
                label=name,
                value=code,
                emoji=LANGUAGE_FLAG_EMOJIS.get(code, "🌐"),
                default=code == current,
            )
            for code, name in TRANSLATION_LANGUAGE_NAMES.items()
        )
        super().__init__(placeholder="Choose the default translation language...", options=options)
        self.page = page

    async def callback(self, interaction):
        self.page.settings["translation_language"] = (
            None if self.values[0] == "none" else self.values[0]
        )
        await self.page.save_translation()
        self.page.render()
        await interaction.response.edit_message(view=self.page)


class TranslationSettingsView(SettingsPageView):
    def __init__(self, interaction, settings):
        super().__init__(interaction, settings)
        self.render()

    async def save_translation(self):
        await save_premium_controls(
            client.db, self.interaction.guild.id, self.settings
        )

    def render(self):
        current = self.settings.get("translation_language")
        label = TRANSLATION_LANGUAGE_NAMES.get(current, "Original language")
        self.render_page(
            title="Default Translation",
            description="Translate posts from every supported platform. Explicit link options take priority.",
            status=f"**Default:** {label}",
            controls=((TranslationLanguageSelect(self),),),
            accent_color=discord.Color.blurple(),
            footer="Translation",
        )


class IgnoredUsersSelect(ui.UserSelect):
    def __init__(self, page):
        super().__init__(
            placeholder="Choose members to ignore...", min_values=0, max_values=25
        )
        self.page = page

    async def callback(self, interaction):
        if not await self.page.confirm_premium(interaction):
            return
        self.page.settings["ignored_user_ids"] = [value.id for value in self.values]
        await self.page.save_premium()
        self.page.render()
        await interaction.response.edit_message(view=self.page)


class IgnoredRolesSelect(ui.RoleSelect):
    def __init__(self, page):
        super().__init__(
            placeholder="Choose roles to ignore...", min_values=0, max_values=25
        )
        self.page = page

    async def callback(self, interaction):
        if not await self.page.confirm_premium(interaction):
            return
        self.page.settings["ignored_role_ids"] = [value.id for value in self.values]
        await self.page.save_premium()
        self.page.render()
        await interaction.response.edit_message(view=self.page)


class ExclusionSettingsView(PremiumControlsPage):
    def __init__(self, interaction, settings, *, premium):
        super().__init__(interaction, settings, premium=premium)
        self.render()

    def render(self):
        if not self.premium:
            self.render_locked(
                title="Automatic Processing Exclusions",
                description="Keep selected members or roles out of automatic link processing.",
            )
            return
        user_ids = self.settings.get("ignored_user_ids", [])
        role_ids = self.settings.get("ignored_role_ids", [])
        self.render_page(
            title="Automatic Processing Exclusions",
            description="Links from selected members, or anyone with a selected role, are left untouched.",
            status=(
                f"**Ignored members:** {len(user_ids)}/25\n"
                f"**Ignored roles:** {len(role_ids)}/25"
            ),
            controls=((IgnoredUsersSelect(self),), (IgnoredRolesSelect(self),)),
            accent_color=discord.Color.gold(),
            footer="Premium exclusions",
        )


class AnalyticsSettingsView(PremiumControlsPage):
    def __init__(self, interaction, settings, *, premium, summary):
        super().__init__(interaction, settings, premium=premium)
        self.summary = summary
        self.render()

    def render(self):
        if not self.premium:
            self.render_locked(
                title="Private Analytics",
                description="See aggregate link-processing outcomes from the last 30 days.",
            )
            return
        total_rich = sum(item["rich_count"] for item in self.summary)
        total_fallback = sum(item["fallback_count"] for item in self.summary)
        lines = [
            f"**{escape_component_text(item['service'])}:** "
            f"{item['rich_count']} rich · {item['fallback_count']} fallback"
            for item in self.summary
        ]
        status = (
            f"**Rich cards:** {total_rich}  ·  **Link fallbacks:** {total_fallback}\n\n"
            + ("\n".join(lines) if lines else "No activity recorded yet.")
            + "\n\n-# Stores daily counts only—never message text, links, or member identities."
        )
        self.render_page(
            title="Private 30-Day Analytics",
            description="Understand platform usage and fallback reliability without tracking content.",
            status=status,
            accent_color=discord.Color.gold(),
            footer="Premium analytics · 90-day aggregate retention",
        )


class FooterEmojiSelect(ui.Select):
    def __init__(self, page):
        current_id = page.settings.get("footer_emoji_id")
        options = [
            discord.SelectOption(
                label="No server emoji",
                value="none",
                default=current_id is None,
            )
        ]
        options.extend(
            discord.SelectOption(
                label=emoji.name[:100],
                value=str(emoji.id),
                emoji=emoji,
                default=str(emoji.id) == str(current_id),
            )
            for emoji in page.interaction.guild.emojis[:24]
        )
        super().__init__(placeholder="Choose an optional server emoji...", options=options)
        self.page = page

    async def callback(self, interaction):
        if not await self.page.recheck_premium(interaction):
            return
        value = self.values[0]
        if value == "none":
            emoji_id = None
        else:
            try:
                emoji_id = int(value)
            except ValueError:
                emoji_id = None
            if discord.utils.get(interaction.guild.emojis, id=emoji_id) is None:
                await interaction.response.send_message(
                    "That emoji is no longer available in this server.", ephemeral=True
                )
                return
        self.page.settings["footer_emoji_id"] = emoji_id
        await self.page.save()
        self.page.render()
        await interaction.response.edit_message(view=self.page)


class FooterBrandingSettingsView(SettingsPageView):
    def __init__(self, interaction, settings, *, premium):
        super().__init__(interaction, settings)
        self.premium, self.premium_unconfirmed = premium_page_state(premium)
        self.render()

    async def recheck_premium(self, interaction):
        """Re-check before a mutation; re-render locked or unconfirmed if not active."""
        self.premium, self.premium_unconfirmed = premium_page_state(
            await guild_premium_status(interaction.guild.id)
        )
        if self.premium:
            return True
        self.render()
        await interaction.response.edit_message(view=self)
        return False

    def render(self):
        if not self.premium:
            controls = ()
            if PREMIUM_SKU_ID and not self.premium_unconfirmed:
                controls = ((discord.ui.Button(
                    style=discord.ButtonStyle.premium,
                    sku_id=int(PREMIUM_SKU_ID),
                ),),)
            self.render_page(
                title="Custom Footer Branding",
                description="Use your server name and an optional server emoji on social cards.",
                status=(
                    get_text(self.lang, "premium_unconfirmed")
                    if self.premium_unconfirmed
                    else "This is a FixEmbed Premium feature."
                ),
                controls=controls,
                accent_color=discord.Color.gold(),
                footer="Premium",
            )
            return

        enabled = bool(self.settings.get("footer_branding_enabled", False))
        selected = discord.utils.get(
            self.interaction.guild.emojis,
            id=self.settings.get("footer_emoji_id"),
        )
        safe_name = escape_component_text(self.interaction.guild.name)
        toggle = discord.ui.Button(
            label="Enabled" if enabled else "Disabled",
            style=discord.ButtonStyle.green if enabled else discord.ButtonStyle.secondary,
        )
        toggle.callback = self.toggle
        status = (
            f"**Status:** {'Enabled' if enabled else 'Disabled'}\n"
            f"**Footer identity:** {str(selected) + ' ' if selected else ''}{safe_name}\n"
            "-# Social cards retain a subtle via FixEmbed attribution."
        )
        controls = [(toggle,)]
        if self.interaction.guild.emojis:
            controls.append((FooterEmojiSelect(self),))
        self.render_page(
            title="Custom Footer Branding",
            description="Brand social cards with this server's current name and an optional emoji.",
            status=status,
            controls=controls,
            accent_color=discord.Color.gold(),
            footer="Premium branding",
        )

    async def toggle(self, interaction):
        if not await self.recheck_premium(interaction):
            return
        self.settings["footer_branding_enabled"] = not bool(
            self.settings.get("footer_branding_enabled", False)
        )
        await self.save()
        self.render()
        await interaction.response.edit_message(view=self)


@client.tree.command(name='settings', description="Configure FixEmbed's settings")
@app_commands.guild_only()
@app_commands.default_permissions(manage_guild=True)
@app_commands.checks.has_permissions(manage_guild=True)
async def settings(interaction: discord.Interaction):
    guild_id = interaction.guild.id
    guild_settings = bot_settings.get(guild_id, {"enabled_services": DEFAULT_ENABLED_SERVICES, "mention_users": True, "delete_original": True, "delivery_mode": "suppress", "media_quality": "balanced"})
    premium = await is_guild_premium(guild_id)

    await interaction.response.send_message(
        view=SettingsView(interaction, guild_settings, premium=premium),
        ephemeral=True,
    )

@client.tree.command(name='delivery', description="Power-user alias for delivery mode (also in /settings)")
@app_commands.describe(mode="delete, suppress, or reply")
@app_commands.choices(mode=[
    app_commands.Choice(name="delete original + send fixed link", value="delete"),
    app_commands.Choice(name="suppress original embed + send fixed link", value="suppress"),
    app_commands.Choice(name="keep original + send fixed link", value="reply"),
])
async def delivery(interaction: discord.Interaction, mode: app_commands.Choice[str]):
    guild_id = interaction.guild.id
    settings_obj = bot_settings.setdefault(guild_id, {
        "enabled_services": DEFAULT_ENABLED_SERVICES,
        "mention_users": True,
        "delete_original": True,
        "language": "en",
        "delivery_mode": "suppress",
        "media_quality": "balanced",
    })
    settings_obj["delivery_mode"] = mode.value
    settings_obj["delete_original"] = mode.value == "delete"
    await update_setting(
        client.db, guild_id, settings_obj["enabled_services"], settings_obj["mention_users"],
        settings_obj.get("delete_original", True), settings_obj.get("language", "en"),
        settings_obj.get("embed_color"), settings_obj["delivery_mode"], settings_obj.get("media_quality", "balanced"),
        settings_obj.get("footer_branding_enabled", False), settings_obj.get("footer_emoji_id"),
        settings_obj.get("show_nsfw", False), settings_obj.get("show_spoilers", False)
    )
    view = SettingsNoticeView(
        title="Delivery Method",
        description=f"✅ Delivery mode set to **{mode.value}**.\n{DeliverySelect.MODES[mode.value]}",
        accent_color=get_guild_color(guild_id),
        footer="Delivery",
    )
    await interaction.response.send_message(view=view, ephemeral=True)

@client.tree.command(name='quality', description="Power-user alias for quality profile (also in /settings)")
@app_commands.describe(profile="fastest, balanced, or highest")
@app_commands.choices(profile=[
    app_commands.Choice(name="fastest", value="fastest"),
    app_commands.Choice(name="balanced", value="balanced"),
    app_commands.Choice(name="highest quality", value="highest"),
])
async def quality(interaction: discord.Interaction, profile: app_commands.Choice[str]):
    guild_id = interaction.guild.id
    settings_obj = bot_settings.setdefault(guild_id, {
        "enabled_services": DEFAULT_ENABLED_SERVICES,
        "mention_users": True,
        "delete_original": True,
        "language": "en",
        "delivery_mode": "suppress",
        "media_quality": "balanced",
    })
    settings_obj["media_quality"] = profile.value
    await update_setting(
        client.db, guild_id, settings_obj["enabled_services"], settings_obj["mention_users"],
        settings_obj.get("delete_original", True), settings_obj.get("language", "en"),
        settings_obj.get("embed_color"), settings_obj.get("delivery_mode", "suppress"), settings_obj["media_quality"],
        settings_obj.get("footer_branding_enabled", False), settings_obj.get("footer_emoji_id"),
        settings_obj.get("show_nsfw", False), settings_obj.get("show_spoilers", False)
    )
    view = SettingsNoticeView(
        title="Media Quality",
        description=f"✅ Media quality profile set to **{profile.value}**.",
        accent_color=get_guild_color(guild_id),
        footer="Media quality",
    )
    await interaction.response.send_message(view=view, ephemeral=True)

@client.tree.command(name='rule', description="Power-user alias for channel rules (also in /settings)")
@app_commands.describe(channel="Target channel", service="Service name", action="on, off, or default")
@app_commands.choices(service=[
    app_commands.Choice(name="Twitter", value="Twitter"),
    app_commands.Choice(name="Instagram", value="Instagram"),
    app_commands.Choice(name="Reddit", value="Reddit"),
    app_commands.Choice(name="Threads", value="Threads"),
    app_commands.Choice(name="Pixiv", value="Pixiv"),
    app_commands.Choice(name="Bluesky", value="Bluesky"),
    app_commands.Choice(name="Bilibili", value="Bilibili"),
    app_commands.Choice(name="YouTube", value="YouTube"),
    app_commands.Choice(name="Pinterest", value="Pinterest"),
    app_commands.Choice(name="TikTok", value="TikTok"),
    app_commands.Choice(name="Tumblr", value="Tumblr"),
    app_commands.Choice(name="Twitch", value="Twitch"),
    app_commands.Choice(name="DeviantArt", value="DeviantArt"),
], action=[
    app_commands.Choice(name="force on", value="on"),
    app_commands.Choice(name="force off", value="off"),
    app_commands.Choice(name="default (inherit)", value="default"),
])
async def rule(interaction: discord.Interaction, channel: discord.TextChannel, service: app_commands.Choice[str], action: app_commands.Choice[str]):
    guild_id = interaction.guild.id
    if action.value == "default":
        await client.db.execute("DELETE FROM channel_service_rules WHERE guild_id = ? AND channel_id = ? AND service = ?", (guild_id, channel.id, service.value))
        await client.db.commit()
        channel_service_rules.pop((guild_id, channel.id, service.value), None)
    else:
        await set_channel_service_rule(client.db, guild_id, channel.id, service.value, action.value)
    view = SettingsNoticeView(
        title="Channel Rule Updated",
        description=f"✅ {channel.mention}  ·  **{service.value}**  →  **{action.value}**",
        accent_color=get_guild_color(guild_id),
        footer="Channel rules",
    )
    await interaction.response.send_message(view=view, ephemeral=True)

@client.tree.command(name='status', description="Power-user alias for reliability status (also in /settings)")
@app_commands.guild_only()
async def status(interaction: discord.Interaction):
    await interaction.response.defer(ephemeral=True)
    settings = bot_settings.get(interaction.guild.id, {
        "enabled_services": DEFAULT_ENABLED_SERVICES,
        "language": "en",
    })
    report = await reliability_client.get_report()
    view = ReliabilitySettingsView(
        interaction,
        settings,
        report=report,
    )
    await interaction.edit_original_response(view=view)

@client.event
async def on_message(message):
    if message.author == client.user:
        return

    if not message.guild:
        return

    guild_id = message.guild.id
    guild_settings = bot_settings.get(guild_id, {
        "enabled_services": DEFAULT_ENABLED_SERVICES,
        "mention_users": True,
        "delete_original": True
    })
    enabled_services = guild_settings.get("enabled_services", DEFAULT_ENABLED_SERVICES)
    mention_users = guild_settings.get("mention_users", True)
    delete_original = guild_settings.get("delete_original", True)
    delivery_mode = guild_settings.get("delivery_mode", "suppress")
    media_quality = guild_settings.get("media_quality", "balanced")
    premium = await is_guild_premium(guild_id)
    if should_skip_automatic(message, guild_settings, premium=premium):
        return
    footer_branding = get_footer_branding(message.guild, guild_settings, premium)
    content_visibility = effective_content_visibility(
        guild_settings,
        message.channel,
    )
    card_preferences = preferences_from_settings(
        guild_settings,
        premium=premium,
        content_visibility=content_visibility,
    )

    # Premium perk: skip bot messages only if NOT premium
    if message.author.bot and not premium:
        return
    
    if channel_states.get(message.channel.id, True):
        try:
            links = extract_supported_links(
                message.content,
                include_preconverted=False,
                include_fixembed=False,
            )
            formatted_links = []
            component_layouts = []
            kept_native_preview = False
            for item in links:
                default_enabled = item.service in enabled_services
                service_enabled = get_service_rule(guild_id, message.channel.id, item.service, default_enabled)
                dedup_key = (message.channel.id, item.canonical_url)
                cache_time = processed_link_cache.get(dedup_key, 0)
                recently_processed = (time.time() - cache_time) < DEDUP_WINDOW_SECONDS

                if service_enabled and not recently_processed:
                    rich_card_built = False
                    skipped_for_outage = False
                    translated_item = with_translation_language(
                        item,
                        guild_settings,
                    )
                    automatic_url = build_automatic_url(
                        translated_item,
                        media_quality,
                        os.getenv("AUTO_TWITTER_PROVIDER", "fixembed"),
                    )
                    if item.service in SERVICE_NAMES:
                        try:
                            delivery = await build_components_v2_link(
                                item,
                                guild_settings,
                                footer_branding,
                                card_preferences,
                                premium=premium,
                            )
                            component_layouts.append(delivery)
                            rich_card_built = True
                        except Exception:
                            # Deleted Reddit comments arrive as a success:true
                            # tombstone payload and render above. An exception on a
                            # comment permalink means Reddit was unreachable, so
                            # post nothing and leave the source message unsuppressed:
                            # Discord's native Reddit card stays (#71).
                            if keeps_native_reddit_og_on_failure(
                                item.service,
                                item.canonical_url,
                            ):
                                skipped_for_outage = True
                                kept_native_preview = True
                            else:
                                formatted_links.append(automatic_url)
                    else:
                        formatted_links.append(
                            f"[{item.display_text}]({automatic_url})"
                        )
                    if premium:
                        try:
                            await record_processing_outcome(
                                client.db,
                                guild_id,
                                item.service,
                                rich=rich_card_built,
                            )
                        except Exception as error:
                            logging.warning(
                                "Premium analytics write failed for guild %s: %s",
                                guild_id,
                                error,
                            )
                    # A temporary Reddit failure is not "done": let a retry
                    # inside the dedup window try the card again.
                    if not skipped_for_outage:
                        processed_link_cache[dedup_key] = time.time()
            if formatted_links or component_layouts:
                permissions = message.channel.permissions_for(message.guild.me)
                # A skipped Reddit link relies on the source message and its
                # native preview, so never delete or suppress it (#80).
                delivery_decision = resolve_delivery_mode(
                    delivery_mode,
                    legacy_delete_original=delete_original,
                    can_manage_messages=permissions.manage_messages,
                    keep_source_preview=kept_native_preview,
                )
                effective_delivery_mode = delivery_decision.effective_mode
                if delivery_decision.downgrade_reason == "kept_native_preview":
                    logging.info(
                        "Delivery mode %s downgraded to reply: kept_native_preview",
                        delivery_decision.configured_mode,
                    )
                elif delivery_decision.downgrade_reason:
                    delivery_telemetry.mode_downgraded(
                        delivery_decision.downgrade_reason
                    )

                async def suppress_source_message():
                    return await message.edit(suppress=True)

                if effective_delivery_mode == "delete":
                    delivery_outcomes = []
                    if not premium:
                        sender = message.author.mention if mention_users else message.author.display_name
                        formatted_links.append(f"Sent by {sender}")
                    tagged_users = format_tagged_users(message.mentions, message.author.id)
                    if tagged_users:
                        formatted_links.append(tagged_users)
                    # Only the "Sent by" line may ping, and only the poster.
                    sender_mentions = sender_allowed_mentions(
                        message.author,
                        ping_author=bool(mention_users and not premium),
                    )
                    for chunk in chunk_lines(formatted_links):
                        delivery_outcomes.append(
                            await rate_limited_send(
                                message.channel,
                                content=chunk,
                                allowed_mentions=sender_mentions,
                            )
                        )
                    for delivery in component_layouts:
                        delivery_outcomes.append(
                            await rate_limited_send(
                                message.channel,
                                view=delivery.view,
                                files=delivery.files,
                                fallback_content=delivery.fallback_url,
                                allowed_mentions=no_mentions(),
                            )
                        )
                    if should_apply_source_message_action(
                        "delete", delivery_outcomes
                    ):
                        await apply_source_message_action(
                            "delete",
                            delete_message=message.delete,
                            suppress_message=suppress_source_message,
                            forbidden_errors=(discord.Forbidden,),
                            on_permission_recovery=delivery_telemetry.mode_downgraded,
                        )
                elif effective_delivery_mode == "suppress":
                    delivery_outcomes = []
                    for chunk in chunk_lines(formatted_links):
                        delivery_outcomes.append(
                            await rate_limited_send(
                                message.channel,
                                content=chunk,
                                allowed_mentions=no_mentions(),
                            )
                        )
                    for delivery in component_layouts:
                        delivery_outcomes.append(
                            await rate_limited_send(
                                message.channel,
                                view=delivery.view,
                                files=delivery.files,
                                fallback_content=delivery.fallback_url,
                                allowed_mentions=no_mentions(),
                            )
                        )
                    if should_apply_source_message_action(
                        "suppress", delivery_outcomes
                    ):
                        await apply_source_message_action(
                            "suppress",
                            delete_message=message.delete,
                            suppress_message=suppress_source_message,
                            forbidden_errors=(discord.Forbidden,),
                            on_permission_recovery=delivery_telemetry.mode_downgraded,
                        )
                else:
                    for chunk in chunk_lines(formatted_links):
                        await rate_limited_send(
                            message.channel,
                            content=chunk,
                            allowed_mentions=no_mentions(),
                        )
                    for delivery in component_layouts:
                        await rate_limited_send(
                            message.channel,
                            view=delivery.view,
                            files=delivery.files,
                            fallback_content=delivery.fallback_url,
                            allowed_mentions=no_mentions(),
                        )

        except discord.Forbidden as error:
            logging.warning("Missing permissions in channel %s: %s", message.channel.id, error)
        except discord.NotFound:
            logging.debug(f"Message already deleted in channel {message.channel.id}")
        except discord.HTTPException as e:
            logging.error(f"HTTP error in on_message: {e}")
        except Exception as e:
            logging.error(f"Unexpected error in on_message: {e}", exc_info=True)

@client.event
async def on_guild_join(guild):
    guild_id = guild.id
    if guild_id not in bot_settings:
        bot_settings[guild_id] = {
            "enabled_services": DEFAULT_ENABLED_SERVICES,
            "mention_users": True,
            "delete_original": True,
            "language": "en",
            "delivery_mode": "suppress",
            "media_quality": "balanced",
            "footer_branding_enabled": False,
            "footer_emoji_id": None,
            "show_nsfw": False,
            "show_spoilers": False,
        }
        await update_setting(
            client.db,
            guild_id,
            bot_settings[guild_id]["enabled_services"],
            bot_settings[guild_id]["mention_users"],
            bot_settings[guild_id]["delete_original"],
            bot_settings[guild_id]["language"],
            bot_settings[guild_id].get("embed_color"),
            bot_settings[guild_id].get("delivery_mode", "suppress"),
            bot_settings[guild_id].get("media_quality", "balanced"),
            bot_settings[guild_id].get("footer_branding_enabled", False),
            bot_settings[guild_id].get("footer_emoji_id"),
            bot_settings[guild_id].get("show_nsfw", False),
            bot_settings[guild_id].get("show_spoilers", False),
        )
    if await send_onboarding_dm(guild):
        logging.info("Sent onboarding DM for guild %s", guild_id)


class PremiumActivationDeepLinkSelect(ui.Select):
    """Deep-link unfinished (or all) activation rows into matching /settings pages."""

    PAGE_LABELS = {
        "Embed Color": ("💎", "Card color"),
        "Footer Branding": ("🏷️", "Footer branding"),
        "Card Style": ("🎛️", "Card style"),
        "Exclusions": ("🛡️", "Exclusions"),
        "Analytics": ("📈", "Analytics"),
    }

    def __init__(self, interaction, settings, items, lang):
        self.source_interaction = interaction
        self.settings = settings
        self.lang = lang
        options = []
        for item in checklist_settings_targets(items):
            emoji, label = self.PAGE_LABELS.get(
                item.settings_page, ("⚙️", item.settings_page)
            )
            status = "Configured" if item.configured else "Not configured yet"
            options.append(
                discord.SelectOption(
                    label=label,
                    description=status,
                    value=item.settings_page,
                    emoji=emoji,
                )
            )
        super().__init__(
            placeholder=get_text(lang, "premium_configure_placeholder"),
            options=options or [
                discord.SelectOption(
                    label="Settings",
                    value="Embed Color",
                    description="Open /settings",
                )
            ],
            min_values=1,
            max_values=1,
        )

    async def callback(self, interaction: discord.Interaction):
        perms = getattr(interaction.user, "guild_permissions", None)
        if perms is None or not perms.manage_guild:
            view = SettingsNoticeView(
                title=get_text(self.lang, "premium_title"),
                description=get_text(self.lang, "premium_need_manage_guild"),
                accent_color=discord.Color.gold(),
                footer="Premium",
            )
            await interaction.response.send_message(view=view, ephemeral=True)
            return
        await open_settings_surface(
            self.source_interaction,
            interaction,
            self.settings,
            self.values[0],
        )


class PremiumActivationView:
    """Build control rows for the active-subscriber /premium activation card."""

    def __init__(self, interaction, settings, *, items, lang):
        select = PremiumActivationDeepLinkSelect(
            interaction, settings, items, lang
        )
        self.controls = ((select,),)


# --- Premium Command ---
@client.tree.command(name='premium', description="View FixEmbed Premium subscription info")
@app_commands.allowed_installs(guilds=True, users=True)
@app_commands.allowed_contexts(guilds=True, dms=True, private_channels=True)
async def premium_command(interaction: discord.Interaction):
    lang = get_guild_lang(interaction.guild.id if interaction.guild else None)
    premium = False
    unconfirmed = False
    if interaction.guild:
        premium, unconfirmed = premium_page_state(
            await guild_premium_status(interaction.guild.id)
        )

    if premium and interaction.guild:
        guild_settings = bot_settings.get(
            interaction.guild.id,
            {
                "enabled_services": DEFAULT_ENABLED_SERVICES,
                "mention_users": True,
                "delete_original": True,
                "language": lang,
            },
        )
        summary = []
        try:
            summary = await fetch_analytics_summary(
                client.db, interaction.guild.id, days=30
            )
        except Exception as error:
            logging.warning(
                "Premium activation analytics lookup failed for guild %s: %s",
                interaction.guild.id,
                error,
            )
        items = evaluate_activation_checklist(
            guild_settings, analytics_summary=summary
        )
        checklist = format_premium_activation_checklist(
            lang, guild_settings, items
        )
        configured = sum(1 for item in items if item.configured)
        description = (
            f"{get_text(lang, 'premium_active')}\n\n"
            f"**{get_text(lang, 'premium_checklist_title')}** "
            f"({configured}/{len(items)})\n"
            f"{get_text(lang, 'premium_checklist_intro')}\n\n"
            f"{checklist}\n\n"
            f"**{get_text(lang, 'premium_manage_title')}**\n"
            f"{get_text(lang, 'premium_manage_body')}"
        )
        view = PremiumActivationView(
            interaction, guild_settings, items=items, lang=lang
        )
        view = SettingsNoticeView(
            title=get_text(lang, "premium_title"),
            description=description,
            accent_color=discord.Color.gold(),
            footer="Premium",
            controls=view.controls,
        )
        await interaction.response.send_message(view=view, ephemeral=True)
        return

    controls = ()
    # A subscriber whose status couldn't be confirmed must not be asked to buy again (#101).
    if PREMIUM_SKU_ID and not premium and not unconfirmed:
        subscribe_button = discord.ui.Button(
            style=discord.ButtonStyle.premium,
            sku_id=int(PREMIUM_SKU_ID))
        controls = ((subscribe_button,),)
    if premium:
        status = get_text(lang, "premium_active")
    elif unconfirmed:
        status = get_text(lang, "premium_unconfirmed")
    else:
        status = get_text(lang, "premium_not_active")
    view = SettingsNoticeView(
        title=get_text(lang, "premium_title"),
        description=f"{get_text(lang, 'premium_description')}\n\n**Status**\n{status}\n\n**{get_text(lang, 'premium_perks_title')}**\n{get_text(lang, 'premium_perks')}",
        accent_color=discord.Color.gold(),
        footer="Premium",
        controls=controls,
    )

    await interaction.response.send_message(view=view, ephemeral=True)

# --- Embed Color Modal ---
class EmbedColorModal(ui.Modal, title="Set Embed Color"):
    color_input = ui.TextInput(
        label="Hex Color Code",
        placeholder="#FF5733 or 'reset'",
        required=True,
        max_length=7)
    
    def __init__(self, interaction, settings):
        super().__init__()
        self.original_interaction = interaction
        self.settings = settings
    
    async def on_submit(self, interaction: discord.Interaction):
        lang = self.settings.get("language", "en")
        value = self.color_input.value.strip()
        guild_id = self.original_interaction.guild.id
        
        if value.lower() == "reset":
            self.settings["embed_color"] = None
            await update_setting(
                client.db, guild_id,
                self.settings.get("enabled_services", DEFAULT_ENABLED_SERVICES),
                self.settings.get("mention_users", True),
                self.settings.get("delete_original", True),
                self.settings.get("language", "en"),
                None,
                self.settings.get("delivery_mode", "suppress"),
                self.settings.get("media_quality", "balanced"),
                self.settings.get("footer_branding_enabled", False),
                self.settings.get("footer_emoji_id"),
                self.settings.get("show_nsfw", False),
                self.settings.get("show_spoilers", False))
            view = SettingsNoticeView(
                title=get_text(lang, "embed_color_title"),
                description=get_text(lang, "embed_color_reset"),
                accent_color=discord.Color.green(),
                footer="Embed color",
            )
            await interaction.response.send_message(view=view, ephemeral=True)
        else:
            # Validate hex color
            hex_color = value.lstrip('#')
            if len(hex_color) == 6:
                try:
                    int(hex_color, 16)
                    color_str = f"#{hex_color.upper()}"
                    self.settings["embed_color"] = color_str
                    await update_setting(
                        client.db, guild_id,
                        self.settings.get("enabled_services", DEFAULT_ENABLED_SERVICES),
                        self.settings.get("mention_users", True),
                        self.settings.get("delete_original", True),
                        self.settings.get("language", "en"),
                        color_str,
                        self.settings.get("delivery_mode", "suppress"),
                        self.settings.get("media_quality", "balanced"),
                        self.settings.get("footer_branding_enabled", False),
                        self.settings.get("footer_emoji_id"),
                        self.settings.get("show_nsfw", False),
                        self.settings.get("show_spoilers", False))
                    view = SettingsNoticeView(
                        title=get_text(lang, "embed_color_title"),
                        description=get_text(lang, "embed_color_set", color=color_str),
                        accent_color=discord.Color(int(hex_color, 16)),
                        footer="Embed color",
                    )
                    await interaction.response.send_message(view=view, ephemeral=True)
                    return
                except ValueError:
                    pass
            view = SettingsNoticeView(
                title=get_text(lang, "embed_color_title"),
                description=get_text(lang, "embed_color_invalid"),
                accent_color=discord.Color.red(),
                footer="Embed color",
            )
            await interaction.response.send_message(view=view, ephemeral=True)

# --- Entitlement Events ---
@client.event
async def on_entitlement_create(entitlement):
    """Called when a user subscribes to premium."""
    if entitlement.guild_id:
        guild_id = entitlement.guild_id
        record_guild_premium(premium_status_cache, guild_id, True)
        logging.info(f"Premium activated for guild {guild_id}")
    if PREMIUM_SKU_ID:
        await sync_supporter_role(
            client, entitlement, int(PREMIUM_SKU_ID), SUPPORT_GUILD_ID, SUPPORTER_ROLE_ID)

@client.event
async def on_entitlement_update(entitlement):
    """Called when an entitlement is updated."""
    if entitlement.guild_id:
        guild_id = entitlement.guild_id
        is_active = entitlement_is_active(entitlement)
        record_guild_premium(premium_status_cache, guild_id, is_active)
        logging.info(f"Premium {'activated' if is_active else 'deactivated'} for guild {guild_id}")
    if PREMIUM_SKU_ID:
        await sync_supporter_role(
            client, entitlement, int(PREMIUM_SKU_ID), SUPPORT_GUILD_ID, SUPPORTER_ROLE_ID)

@client.event
async def on_entitlement_delete(entitlement):
    """Called when a user's subscription to premium is removed."""
    if entitlement.guild_id:
        guild_id = entitlement.guild_id
        record_guild_premium(premium_status_cache, guild_id, False)
        logging.info(f"Premium removed for guild {guild_id}")
    if PREMIUM_SKU_ID:
        await sync_supporter_role(
            client,
            entitlement,
            int(PREMIUM_SKU_ID),
            SUPPORT_GUILD_ID,
            SUPPORTER_ROLE_ID,
            active=False,
        )


@client.event
async def on_member_join(member):
    """Grant returning Premium purchasers their Supporters role on join."""
    if PREMIUM_SKU_ID and member.guild.id == SUPPORT_GUILD_ID:
        await sync_supporter_role_for_member(
            client,
            member,
            int(PREMIUM_SKU_ID),
            SUPPORT_GUILD_ID,
            SUPPORTER_ROLE_ID,
        )

# Loading the bot token from .env
load_dotenv()
bot_token = os.getenv('BOT_TOKEN')
PREMIUM_SKU_ID = os.getenv('PREMIUM_SKU_ID')
client.run(bot_token)