Breehavior-Monitor/cogs/sentiment.py

import asyncio
import logging
from collections import deque
from datetime import datetime, timedelta, timezone

import discord
from discord.ext import commands, tasks

logger = logging.getLogger("bcs.sentiment")

# How often to flush dirty user states to DB (seconds)
STATE_FLUSH_INTERVAL = 300  # 5 minutes


class SentimentCog(commands.Cog):
    def __init__(self, bot: commands.Bot):
        self.bot = bot
        # Per-channel message history for context: {channel_id: deque of (author, content)}
        self._channel_history: dict[int, deque] = {}
        # Track which user IDs have unsaved in-memory changes
        self._dirty_users: set[int] = set()
        # Per-user redirect cooldown: {user_id: last_redirect_datetime}
        self._redirect_cooldowns: dict[int, datetime] = {}
        # Debounce buffer: keyed by (channel_id, user_id), stores list of messages
        self._message_buffer: dict[tuple[int, int], list[discord.Message]] = {}
        # Pending debounce timer tasks
        self._debounce_tasks: dict[tuple[int, int], asyncio.Task] = {}
        # Per-channel poll cooldown: {channel_id: last_poll_datetime}
        self._poll_cooldowns: dict[int, datetime] = {}

    async def cog_load(self):
        self._flush_states.start()

    async def cog_unload(self):
        self._flush_states.cancel()
        # Cancel all pending debounce timers and process remaining buffers
        for task in self._debounce_tasks.values():
            task.cancel()
        self._debounce_tasks.clear()
        for key in list(self._message_buffer):
            await self._process_buffered(key)
        # Final flush on shutdown
        await self._flush_dirty_states()

    @commands.Cog.listener()
    async def on_message(self, message: discord.Message):
        logger.info("MSG from %s in #%s: %s", message.author, getattr(message.channel, 'name', 'DM'), message.content[:80] if message.content else "(empty)")

        # Ignore bots (including ourselves)
        if message.author.bot:
            return

        # Ignore DMs
        if not message.guild:
            return

        config = self.bot.config
        monitoring = config.get("monitoring", {})

        if not monitoring.get("enabled", True):
            return

        # Check if channel is monitored
        monitored_channels = monitoring.get("channels", [])
        if monitored_channels and message.channel.id not in monitored_channels:
            return

        # Check ignored users
        if message.author.id in monitoring.get("ignored_users", []):
            return

        # Check immune roles
        immune_roles = set(monitoring.get("immune_roles", []))
        if immune_roles and any(
            r.id in immune_roles for r in message.author.roles
        ):
            return

        # Check per-user immunity
        if self.bot.drama_tracker.is_immune(message.author.id):
            return

        # Skip sentiment analysis for messages directed at the bot
        # (mentions, replies to bot) — users interacting with the bot
        # in roast/chat modes shouldn't have those messages scored as toxic
        directed_at_bot = self.bot.user in message.mentions
        if not directed_at_bot and message.reference and message.reference.message_id:
            ref = message.reference.cached_message
            if ref and ref.author.id == self.bot.user.id:
                directed_at_bot = True
        if directed_at_bot:
            return

        # Store message in channel history for context
        self._store_context(message)

        # Skip if empty
        if not message.content or not message.content.strip():
            return

        # Buffer the message and start/reset debounce timer
        key = (message.channel.id, message.author.id)
        if key not in self._message_buffer:
            self._message_buffer[key] = []
        self._message_buffer[key].append(message)

        # Cancel existing debounce timer for this user+channel
        existing_task = self._debounce_tasks.get(key)
        if existing_task and not existing_task.done():
            existing_task.cancel()

        # Skip debounce when bot is @mentioned so warnings fire before chat replies
        if self.bot.user in message.mentions:
            batch_window = 0
        else:
            batch_window = config.get("sentiment", {}).get("batch_window_seconds", 3)

        self._debounce_tasks[key] = asyncio.create_task(
            self._debounce_then_process(key, batch_window)
        )

    async def _debounce_then_process(self, key: tuple[int, int], delay: float):
        """Sleep for the debounce window, then process the buffered messages."""
        try:
            await asyncio.sleep(delay)
            await self._process_buffered(key)
        except asyncio.CancelledError:
            pass  # Timer was reset by a new message — expected

    async def _process_buffered(self, key: tuple[int, int]):
        """Combine buffered messages and run the analysis pipeline once."""
        messages = self._message_buffer.pop(key, [])
        self._debounce_tasks.pop(key, None)

        if not messages:
            return

        # Use the last message as the reference for channel, author, guild, etc.
        message = messages[-1]
        combined_content = "\n".join(m.content for m in messages if m.content and m.content.strip())

        if not combined_content.strip():
            return

        batch_count = len(messages)
        if batch_count > 1:
            logger.info(
                "Batched %d messages from %s in #%s",
                batch_count, message.author.display_name,
                getattr(message.channel, 'name', 'unknown'),
            )

        config = self.bot.config
        monitoring = config.get("monitoring", {})
        sentiment_config = config.get("sentiment", {})

        # Build channel context for game detection
        game_channels = config.get("game_channels", {})
        channel_context = self._build_channel_context(message, game_channels)

        # Analyze the combined message (triage with lightweight model)
        context = self._get_context(message)
        user_notes = self.bot.drama_tracker.get_user_notes(message.author.id)
        result = await self.bot.llm.analyze_message(
            combined_content, context, user_notes=user_notes,
            channel_context=channel_context,
        )

        if result is None:
            return

        # Escalation: re-analyze with heavy model if triage flags something
        escalation_threshold = sentiment_config.get("escalation_threshold", 0.25)
        needs_escalation = (
            result["toxicity_score"] >= escalation_threshold
            or result.get("off_topic", False)
            or result.get("coherence_score", 1.0) < 0.6
        )
        if needs_escalation:
            triage_score = result["toxicity_score"]
            heavy_result = await self.bot.llm_heavy.analyze_message(
                combined_content, context, user_notes=user_notes,
                channel_context=channel_context,
            )
            if heavy_result is not None:
                logger.info(
                    "Escalated to heavy model (triage_score=%.2f) for %s",
                    triage_score, message.author.display_name,
                )
                result = heavy_result

        score = result["toxicity_score"]
        categories = result["categories"]
        reasoning = result["reasoning"]

        # Track the result
        self.bot.drama_tracker.add_entry(
            message.author.id, score, categories, reasoning
        )

        drama_score = self.bot.drama_tracker.get_drama_score(message.author.id)

        logger.info(
            "User %s (%d) | msg_score=%.2f | drama_score=%.2f | categories=%s | %s",
            message.author.display_name,
            message.author.id,
            score,
            drama_score,
            categories,
            reasoning,
        )

        # Topic drift detection
        off_topic = result.get("off_topic", False)
        topic_category = result.get("topic_category", "general_chat")
        topic_reasoning = result.get("topic_reasoning", "")

        # Save message + analysis to DB (awaited — need message_id for action links)
        db_message_id = await self.bot.db.save_message_and_analysis(
            guild_id=message.guild.id,
            channel_id=message.channel.id,
            user_id=message.author.id,
            username=message.author.display_name,
            content=combined_content,
            message_ts=message.created_at.replace(tzinfo=timezone.utc),
            toxicity_score=score,
            drama_score=drama_score,
            categories=categories,
            reasoning=reasoning,
            off_topic=off_topic,
            topic_category=topic_category,
            topic_reasoning=topic_reasoning,
            coherence_score=result.get("coherence_score"),
            coherence_flag=result.get("coherence_flag"),
        )

        if off_topic:
            await self._handle_topic_drift(message, topic_category, topic_reasoning, db_message_id)

        # Game channel redirect detection
        detected_game = result.get("detected_game")
        if detected_game and game_channels and not monitoring.get("dry_run", False):
            await self._handle_channel_redirect(message, detected_game, game_channels, db_message_id)

        # Coherence / intoxication detection
        coherence_score = result.get("coherence_score", 0.85)
        coherence_flag = result.get("coherence_flag", "normal")
        coherence_config = config.get("coherence", {})
        if coherence_config.get("enabled", True):
            degradation = self.bot.drama_tracker.update_coherence(
                user_id=message.author.id,
                score=coherence_score,
                flag=coherence_flag,
                drop_threshold=coherence_config.get("drop_threshold", 0.3),
                absolute_floor=coherence_config.get("absolute_floor", 0.5),
                cooldown_minutes=coherence_config.get("cooldown_minutes", 30),
            )
            if degradation and not config.get("monitoring", {}).get("dry_run", False):
                await self._handle_coherence_alert(message, degradation, coherence_config, db_message_id)

        # Disagreement poll detection
        polls_config = config.get("polls", {})
        if (
            polls_config.get("enabled", False)
            and result.get("disagreement_detected", False)
            and result.get("disagreement_summary")
            and not monitoring.get("dry_run", False)
        ):
            await self._handle_disagreement_poll(message, result["disagreement_summary"], polls_config)

        # Capture LLM note updates about this user
        note_update = result.get("note_update")
        if note_update:
            self.bot.drama_tracker.update_user_notes(message.author.id, note_update)
            self._dirty_users.add(message.author.id)

        # Mark dirty for coherence baseline drift even without actions
        self._dirty_users.add(message.author.id)

        # Always log analysis to #bcs-log if it exists
        await self._log_analysis(message, score, drama_score, categories, reasoning, off_topic, topic_category)

        # Dry-run mode: skip warnings/mutes
        dry_run = config.get("monitoring", {}).get("dry_run", False)
        if dry_run:
            return

        # Check thresholds — use relaxed thresholds if the active mode says so
        mode_config = self.bot.get_mode_config()
        moderation_level = mode_config.get("moderation", "full")
        if moderation_level == "relaxed" and "relaxed_thresholds" in mode_config:
            rt = mode_config["relaxed_thresholds"]
            warning_threshold = rt.get("warning_threshold", 0.80)
            base_mute_threshold = rt.get("mute_threshold", 0.85)
            spike_warn = rt.get("spike_warning_threshold", 0.70)
            spike_mute = rt.get("spike_mute_threshold", 0.85)
        else:
            warning_threshold = sentiment_config.get("warning_threshold", 0.6)
            base_mute_threshold = sentiment_config.get("mute_threshold", 0.75)
            spike_warn = sentiment_config.get("spike_warning_threshold", 0.5)
            spike_mute = sentiment_config.get("spike_mute_threshold", 0.8)
        mute_threshold = self.bot.drama_tracker.get_mute_threshold(
            message.author.id, base_mute_threshold
        )

        # Mute: rolling average OR single message spike
        if drama_score >= mute_threshold or score >= spike_mute:
            effective_score = max(drama_score, score)
            await self._mute_user(message, effective_score, categories, db_message_id)
        # Warn: rolling average OR single message spike
        elif drama_score >= warning_threshold or score >= spike_warn:
            effective_score = max(drama_score, score)
            await self._warn_user(message, effective_score, db_message_id)

    async def _mute_user(
        self,
        message: discord.Message,
        score: float,
        categories: list[str],
        db_message_id: int | None = None,
    ):
        member = message.author
        if not isinstance(member, discord.Member):
            return

        # Check bot permissions
        if not message.guild.me.guild_permissions.moderate_members:
            logger.warning("Missing moderate_members permission, cannot mute.")
            return

        # Record offense and get escalating timeout
        offense_num = self.bot.drama_tracker.record_offense(member.id)
        timeout_config = self.bot.config.get("timeouts", {})
        escalation = timeout_config.get("escalation_minutes", [5, 15, 30, 60])
        idx = min(offense_num - 1, len(escalation) - 1)
        duration_minutes = escalation[idx]

        try:
            await member.timeout(
                timedelta(minutes=duration_minutes),
                reason=f"BCS auto-mute: drama score {score:.2f}",
            )
        except discord.Forbidden:
            logger.warning("Cannot timeout %s — role hierarchy issue.", member)
            return
        except discord.HTTPException as e:
            logger.error("Failed to timeout %s: %s", member, e)
            return

        # Build embed
        messages_config = self.bot.config.get("messages", {})
        cat_str = ", ".join(c for c in categories if c != "none") or "general negativity"

        embed = discord.Embed(
            title=messages_config.get("mute_title", "BREEHAVIOR ALERT"),
            description=messages_config.get("mute_description", "").format(
                username=member.display_name,
                duration=f"{duration_minutes} minutes",
                score=f"{score:.2f}",
                categories=cat_str,
            ),
            color=discord.Color.red(),
        )
        embed.set_footer(
            text=f"Offense #{offense_num} | Timeout: {duration_minutes}m"
        )

        await message.channel.send(embed=embed)
        await self._log_action(
            message.guild,
            f"**MUTE** | {member.mention} | Score: {score:.2f} | "
            f"Duration: {duration_minutes}m | Offense #{offense_num} | "
            f"Categories: {cat_str}",
        )

        logger.info(
            "Muted %s for %d minutes (offense #%d, score %.2f)",
            member,
            duration_minutes,
            offense_num,
            score,
        )

        # Persist mute action and updated user state (fire-and-forget)
        asyncio.create_task(self.bot.db.save_action(
            guild_id=message.guild.id,
            user_id=member.id,
            username=member.display_name,
            action_type="mute",
            message_id=db_message_id,
            details=f"duration={duration_minutes}m offense={offense_num} score={score:.2f} categories={cat_str}",
        ))
        self._save_user_state(member.id)

    async def _warn_user(self, message: discord.Message, score: float, db_message_id: int | None = None):
        timeout_config = self.bot.config.get("timeouts", {})
        cooldown = timeout_config.get("warning_cooldown_minutes", 5)

        if not self.bot.drama_tracker.can_warn(message.author.id, cooldown):
            return

        self.bot.drama_tracker.record_warning(message.author.id)

        # React with warning emoji
        try:
            await message.add_reaction("\u26a0\ufe0f")
        except discord.HTTPException:
            pass

        # Send warning message
        messages_config = self.bot.config.get("messages", {})
        warning_text = messages_config.get(
            "warning",
            "Easy there, {username}. The Breehavior Monitor is watching.",
        ).format(username=message.author.display_name)

        await message.channel.send(warning_text)
        await self._log_action(
            message.guild,
            f"**WARNING** | {message.author.mention} | Score: {score:.2f}",
        )

        logger.info("Warned %s (score %.2f)", message.author, score)

        # Persist warning action (fire-and-forget)
        asyncio.create_task(self.bot.db.save_action(
            guild_id=message.guild.id,
            user_id=message.author.id,
            username=message.author.display_name,
            action_type="warning",
            message_id=db_message_id,
            details=f"score={score:.2f}",
        ))

    async def _handle_topic_drift(
        self, message: discord.Message, topic_category: str, topic_reasoning: str,
        db_message_id: int | None = None,
    ):
        config = self.bot.config.get("topic_drift", {})
        if not config.get("enabled", True):
            return

        # Check if we're in dry-run mode — still track but don't act
        dry_run = self.bot.config.get("monitoring", {}).get("dry_run", False)
        if dry_run:
            return

        tracker = self.bot.drama_tracker
        user_id = message.author.id
        cooldown = config.get("remind_cooldown_minutes", 10)

        if not tracker.can_topic_remind(user_id, cooldown):
            return

        count = tracker.record_off_topic(user_id)
        escalation_threshold = config.get("escalation_count", 3)
        messages_config = self.bot.config.get("messages", {})

        if count >= escalation_threshold and not tracker.was_owner_notified(user_id):
            # DM the server owner
            tracker.mark_owner_notified(user_id)
            owner = message.guild.owner
            if owner:
                dm_text = messages_config.get(
                    "topic_owner_dm",
                    "Heads up: {username} keeps going off-topic in #{channel}. Reminded {count} times.",
                ).format(
                    username=message.author.display_name,
                    channel=message.channel.name,
                    count=count,
                )
                try:
                    await owner.send(dm_text)
                except discord.HTTPException:
                    logger.warning("Could not DM server owner about topic drift.")

            await self._log_action(
                message.guild,
                f"**TOPIC DRIFT — OWNER NOTIFIED** | {message.author.mention} | "
                f"Off-topic count: {count} | Category: {topic_category}",
            )
            logger.info("Notified owner about %s topic drift (count %d)", message.author, count)

            asyncio.create_task(self.bot.db.save_action(
                guild_id=message.guild.id, user_id=user_id,
                username=message.author.display_name,
                action_type="topic_escalation", message_id=db_message_id,
                details=f"off_topic_count={count} category={topic_category}",
            ))
            self._save_user_state(user_id)

        elif count >= 2:
            # Firmer nudge
            nudge_text = messages_config.get(
                "topic_nudge",
                "{username}, let's keep it to gaming talk in here.",
            ).format(username=message.author.display_name)
            await message.channel.send(nudge_text)
            await self._log_action(
                message.guild,
                f"**TOPIC NUDGE** | {message.author.mention} | "
                f"Off-topic count: {count} | Category: {topic_category}",
            )
            logger.info("Topic nudge for %s (count %d)", message.author, count)

            asyncio.create_task(self.bot.db.save_action(
                guild_id=message.guild.id, user_id=user_id,
                username=message.author.display_name,
                action_type="topic_nudge", message_id=db_message_id,
                details=f"off_topic_count={count} category={topic_category}",
            ))
            self._save_user_state(user_id)

        else:
            # Friendly first reminder
            remind_text = messages_config.get(
                "topic_remind",
                "Hey {username}, this is a gaming server — maybe take the personal stuff to DMs?",
            ).format(username=message.author.display_name)
            await message.channel.send(remind_text)
            await self._log_action(
                message.guild,
                f"**TOPIC REMIND** | {message.author.mention} | "
                f"Category: {topic_category} | {topic_reasoning}",
            )
            logger.info("Topic remind for %s (count %d)", message.author, count)

            asyncio.create_task(self.bot.db.save_action(
                guild_id=message.guild.id, user_id=user_id,
                username=message.author.display_name,
                action_type="topic_remind", message_id=db_message_id,
                details=f"off_topic_count={count} category={topic_category} reasoning={topic_reasoning}",
            ))
            self._save_user_state(user_id)

    async def _handle_coherence_alert(
        self, message: discord.Message, degradation: dict, coherence_config: dict,
        db_message_id: int | None = None,
    ):
        flag = degradation["flag"]
        messages_map = coherence_config.get("messages", {})
        alert_text = messages_map.get(flag, messages_map.get(
            "default", "You okay there, {username}? That message was... something."
        )).format(username=message.author.display_name)

        await message.channel.send(alert_text)
        await self._log_action(
            message.guild,
            f"**COHERENCE ALERT** | {message.author.mention} | "
            f"Score: {degradation['current']:.2f} | Baseline: {degradation['baseline']:.2f} | "
            f"Drop: {degradation['drop']:.2f} | Flag: {flag}",
        )
        logger.info(
            "Coherence alert for %s: score=%.2f baseline=%.2f drop=%.2f flag=%s",
            message.author, degradation["current"], degradation["baseline"],
            degradation["drop"], flag,
        )

        asyncio.create_task(self.bot.db.save_action(
            guild_id=message.guild.id,
            user_id=message.author.id,
            username=message.author.display_name,
            action_type="coherence_alert",
            message_id=db_message_id,
            details=f"score={degradation['current']:.2f} baseline={degradation['baseline']:.2f} drop={degradation['drop']:.2f} flag={flag}",
        ))
        self._save_user_state(message.author.id)

    async def _handle_disagreement_poll(
        self, message: discord.Message, summary: dict, polls_config: dict,
    ):
        """Create a Discord poll to settle a detected disagreement."""
        ch_id = message.channel.id
        cooldown_minutes = polls_config.get("cooldown_minutes", 60)
        now = datetime.now(timezone.utc)

        # Check per-channel cooldown
        last_poll = self._poll_cooldowns.get(ch_id)
        if last_poll and (now - last_poll) < timedelta(minutes=cooldown_minutes):
            return

        topic = summary.get("topic", "Who's right?")
        side_a = summary.get("side_a", "Side A")
        side_b = summary.get("side_b", "Side B")
        user_a = summary.get("user_a", "")
        user_b = summary.get("user_b", "")

        # Build poll question
        question_text = f"Settle this: {topic}"[:300]

        # Build answer labels with usernames
        label_a = f"{side_a} ({user_a})" if user_a else side_a
        label_b = f"{side_b} ({user_b})" if user_b else side_b

        duration_hours = polls_config.get("duration_hours", 4)

        try:
            poll = discord.Poll(
                question=question_text,
                duration=timedelta(hours=duration_hours),
            )
            poll.add_answer(text=label_a[:55])
            poll.add_answer(text=label_b[:55])

            await message.channel.send(poll=poll)
            self._poll_cooldowns[ch_id] = now

            await self._log_action(
                message.guild,
                f"**AUTO-POLL** | #{message.channel.name} | "
                f"{question_text} | {label_a} vs {label_b}",
            )
            logger.info(
                "Auto-poll created in #%s: %s | %s vs %s",
                message.channel.name, topic, label_a, label_b,
            )
        except discord.HTTPException as e:
            logger.error("Failed to create disagreement poll: %s", e)

    def _save_user_state(self, user_id: int) -> None:
        """Fire-and-forget save of a user's current state to DB."""
        user_data = self.bot.drama_tracker.get_user(user_id)
        asyncio.create_task(self.bot.db.save_user_state(
            user_id=user_id,
            offense_count=user_data.offense_count,
            immune=user_data.immune,
            off_topic_count=user_data.off_topic_count,
            baseline_coherence=user_data.baseline_coherence,
            user_notes=user_data.notes or None,
        ))
        self._dirty_users.discard(user_id)

    @tasks.loop(seconds=STATE_FLUSH_INTERVAL)
    async def _flush_states(self):
        await self._flush_dirty_states()

    @_flush_states.before_loop
    async def _before_flush(self):
        await self.bot.wait_until_ready()

    async def _flush_dirty_states(self) -> None:
        """Save all dirty user states to DB."""
        if not self._dirty_users:
            return
        dirty = list(self._dirty_users)
        self._dirty_users.clear()
        for user_id in dirty:
            user_data = self.bot.drama_tracker.get_user(user_id)
            await self.bot.db.save_user_state(
                user_id=user_id,
                offense_count=user_data.offense_count,
                immune=user_data.immune,
                off_topic_count=user_data.off_topic_count,
                baseline_coherence=user_data.baseline_coherence,
                user_notes=user_data.notes or None,
            )
        logger.info("Flushed %d dirty user states to DB.", len(dirty))

    def _build_channel_context(self, message: discord.Message, game_channels: dict) -> str:
        """Build a channel context string for LLM game detection."""
        if not game_channels:
            return ""
        channel_name = getattr(message.channel, "name", "")
        current_game = game_channels.get(channel_name)
        lines = []
        if current_game:
            lines.append(f"Current channel: #{channel_name} ({current_game})")
        else:
            lines.append(f"Current channel: #{channel_name}")
        channel_list = ", ".join(f"#{ch} ({game})" for ch, game in game_channels.items())
        lines.append(f"Game channels: {channel_list}")
        return "\n".join(lines)

    async def _handle_channel_redirect(
        self, message: discord.Message, detected_game: str,
        game_channels: dict, db_message_id: int | None = None,
    ):
        """Send a redirect message if the user is talking about a different game."""
        channel_name = getattr(message.channel, "name", "")

        # Only redirect if message is in a game channel
        if channel_name not in game_channels:
            return

        # No redirect needed if detected game matches current channel
        if detected_game == channel_name:
            return

        # Detected game must be a valid game channel
        if detected_game not in game_channels:
            return

        # Find the target channel in the guild
        target_channel = discord.utils.get(
            message.guild.text_channels, name=detected_game
        )
        if not target_channel:
            return

        # Check per-user cooldown (reuse topic_drift remind_cooldown_minutes)
        user_id = message.author.id
        cooldown_minutes = self.bot.config.get("topic_drift", {}).get("remind_cooldown_minutes", 10)
        now = datetime.now(timezone.utc)
        last_redirect = self._redirect_cooldowns.get(user_id)
        if last_redirect and (now - last_redirect) < timedelta(minutes=cooldown_minutes):
            return

        self._redirect_cooldowns[user_id] = now

        # Send redirect message
        messages_config = self.bot.config.get("messages", {})
        game_name = game_channels[detected_game]
        redirect_text = messages_config.get(
            "channel_redirect",
            "Hey {username}, that sounds like {game} talk — head over to {channel} for that!",
        ).format(
            username=message.author.display_name,
            game=game_name,
            channel=target_channel.mention,
        )

        await message.channel.send(redirect_text)

        await self._log_action(
            message.guild,
            f"**CHANNEL REDIRECT** | {message.author.mention} | "
            f"#{channel_name} → #{detected_game} ({game_name})",
        )
        logger.info(
            "Redirected %s from #%s to #%s (%s)",
            message.author, channel_name, detected_game, game_name,
        )

        asyncio.create_task(self.bot.db.save_action(
            guild_id=message.guild.id,
            user_id=user_id,
            username=message.author.display_name,
            action_type="channel_redirect",
            message_id=db_message_id,
            details=f"from=#{channel_name} to=#{detected_game} game={game_name}",
        ))

    def _store_context(self, message: discord.Message):
        ch_id = message.channel.id
        if ch_id not in self._channel_history:
            max_ctx = self.bot.config.get("sentiment", {}).get(
                "context_messages", 8
            )
            self._channel_history[ch_id] = deque(maxlen=max_ctx)
        self._channel_history[ch_id].append(
            (message.author.display_name, message.content, datetime.now(timezone.utc))
        )

    def _get_context(self, message: discord.Message) -> str:
        """Build a timestamped chat log from recent channel messages.

        Excludes messages currently buffered for this user+channel
        (those appear in the TARGET MESSAGE section instead).
        """
        ch_id = message.channel.id
        history = self._channel_history.get(ch_id, deque())
        if not history:
            return "(no prior context)"

        now = datetime.now(timezone.utc)

        # Collect IDs of messages in the current debounce batch so we can skip them
        batch_key = (ch_id, message.author.id)
        batch_msgs = self._message_buffer.get(batch_key, [])
        # Build a set of (author, content) from the batch for fast lookup
        batch_set = {(m.author.display_name, m.content) for m in batch_msgs}

        lines = []
        for name, content, ts in history:
            if (name, content) in batch_set:
                continue
            delta = now - ts
            rel = self._format_relative_time(delta)
            lines.append(f"[{rel}] {name}: {content}")

        if not lines:
            return "(no prior context)"
        return "\n".join(lines)

    @staticmethod
    def _format_relative_time(delta: timedelta) -> str:
        total_seconds = int(delta.total_seconds())
        if total_seconds < 60:
            return f"~{total_seconds}s ago"
        minutes = total_seconds // 60
        if minutes < 60:
            return f"~{minutes}m ago"
        hours = minutes // 60
        return f"~{hours}h ago"

    async def _log_analysis(
        self, message: discord.Message, score: float, drama_score: float,
        categories: list[str], reasoning: str, off_topic: bool, topic_category: str,
    ):
        log_channel = discord.utils.get(
            message.guild.text_channels, name="bcs-log"
        )
        if not log_channel:
            return

        # Only log notable messages (score > 0.1) to avoid spam
        if score <= 0.1:
            return

        cat_str = ", ".join(c for c in categories if c != "none") or "none"
        embed = discord.Embed(
            title=f"Analysis: {message.author.display_name}",
            description=f"#{message.channel.name}: {message.content[:200]}",
            color=self._score_color(score),
        )
        embed.add_field(name="Message Score", value=f"{score:.2f}", inline=True)
        embed.add_field(name="Rolling Drama", value=f"{drama_score:.2f}", inline=True)
        embed.add_field(name="Categories", value=cat_str, inline=True)
        embed.add_field(name="Reasoning", value=reasoning[:1024] or "n/a", inline=False)
        try:
            await log_channel.send(embed=embed)
        except discord.HTTPException:
            pass

    @staticmethod
    def _score_color(score: float) -> discord.Color:
        if score >= 0.75:
            return discord.Color.red()
        if score >= 0.6:
            return discord.Color.orange()
        if score >= 0.3:
            return discord.Color.yellow()
        return discord.Color.green()

    async def _log_action(self, guild: discord.Guild, text: str):
        log_channel = discord.utils.get(guild.text_channels, name="bcs-log")
        if log_channel:
            try:
                await log_channel.send(text)
            except discord.HTTPException:
                pass


async def setup(bot: commands.Bot):
    await bot.add_cog(SentimentCog(bot))