major-domo-v2/commands/dice/rolls.py

"""
Dice Rolling Commands

Implements slash commands for dice rolling functionality required for gameplay.
"""
import random
from typing import Optional

import discord
from discord.ext import commands

from models.team import Team
from services.team_service import team_service
from utils import team_utils
from utils.logging import get_contextual_logger
from utils.decorators import logged_command
from utils.team_utils import get_user_major_league_team
from utils.text_utils import split_text_for_fields
from utils.dice_utils import DiceRoll, parse_and_roll_multiple_dice, parse_and_roll_single_dice
from views.embeds import EmbedColors, EmbedTemplate
from commands.dev.loaded_dice import get_and_consume_loaded_roll
from .chart_data import (
    INFIELD_X_CHART,
    OUTFIELD_X_CHART,
    INFIELD_RANGES,
    OUTFIELD_RANGES,
    CATCHER_RANGES,
    PITCHER_RANGES,
    FIRST_BASE_ERRORS,
    SECOND_BASE_ERRORS,
    THIRD_BASE_ERRORS,
    SHORTSTOP_ERRORS,
    CORNER_OUTFIELD_ERRORS,
    CENTER_FIELD_ERRORS,
    CATCHER_ERRORS,
    PITCHER_ERRORS,
)

class DiceRollCommands(commands.Cog):
    """Dice rolling command handlers for gameplay."""

    def __init__(self, bot: commands.Bot):
        self.bot = bot
        self.logger = get_contextual_logger(f'{__name__}.DiceRollCommands')

    @discord.app_commands.command(
        name="roll",
        description="Roll polyhedral dice using XdY notation (e.g., 2d6, 1d20, 3d8)"
    )
    @discord.app_commands.describe(
        dice="Dice notation - single or multiple separated by semicolon (e.g., 2d6, 1d20;2d6;1d6)"
    )
    @logged_command("/roll")
    async def roll_dice(
        self,
        interaction: discord.Interaction,
        dice: str
    ):
        """Roll dice using standard XdY dice notation. Supports multiple rolls separated by semicolon."""
        await interaction.response.defer()

        # Parse and validate dice notation (supports multiple rolls)
        roll_results = parse_and_roll_multiple_dice(dice)
        if not roll_results:
            await interaction.followup.send(
                "❌ Invalid dice notation. Use format like: 2d6, 1d20, or 1d6;2d6;1d20",
                ephemeral=True
            )
            return

        # Create embed for the roll results
        embed = self._create_multi_roll_embed(dice, roll_results, interaction.user)
        await interaction.followup.send(embed=embed)

    @commands.command(name="roll", aliases=["r", "dice"])
    async def roll_dice_prefix(self, ctx: commands.Context, *, dice: str | None = None):
        """Roll dice using prefix commands (!roll, !r, !dice)."""
        self.logger.info(f"Prefix roll command started by {ctx.author.display_name}", dice_input=dice)

        if dice is None:
            self.logger.debug("No dice input provided")
            await ctx.send("❌ Please provide dice notation. Usage: `!roll 2d6` or `!roll 1d6;2d6;1d20`")
            return

        # Parse and validate dice notation (supports multiple rolls)
        roll_results = parse_and_roll_multiple_dice(dice)
        if not roll_results:
            self.logger.warning("Invalid dice notation provided", dice_input=dice)
            await ctx.send("❌ Invalid dice notation. Use format like: 2d6, 1d20, or 1d6;2d6;1d20")
            return

        self.logger.info(f"Dice rolled successfully", roll_count=len(roll_results))

        # Create embed for the roll results
        embed = self._create_multi_roll_embed(dice, roll_results, ctx.author)
        await ctx.send(embed=embed)

    @discord.app_commands.command(
        name="d20",
        description="Roll a single d20"
    )
    @logged_command("/d20")
    async def d20_dice(self, interaction: discord.Interaction):
        """Roll a single d20."""
        await interaction.response.defer()
        embed_color = await self._get_channel_embed_color(interaction)

        # Roll 1d20
        dice_notation = "1d20"
        roll_results = parse_and_roll_multiple_dice(dice_notation)

        # Create embed for the roll results
        embed = self._create_multi_roll_embed(
            dice_notation,
            roll_results,
            interaction.user,
            set_author=False,
            embed_color=embed_color
        )
        embed.title = f'd20 roll for {interaction.user.display_name}'

        await interaction.followup.send(embed=embed)

    @discord.app_commands.command(
        name="ab",
        description="Roll baseball at-bat dice (1d6;2d6;1d20)"
    )
    @logged_command("/ab")
    async def ab_dice(self, interaction: discord.Interaction):
        """Roll the standard baseball at-bat dice combination."""
        await interaction.response.defer()
        embed_color = await self._get_channel_embed_color(interaction)

        # Check for loaded dice (dev testing)
        loaded = get_and_consume_loaded_roll(interaction.user.id)
        if loaded:
            self.logger.info(
                f"Using loaded dice for {interaction.user}: d6={loaded.d6_1}, 2d6={loaded.d6_2_total}, d20={loaded.d20}"
            )
            # Create DiceRoll objects from loaded values
            # For 2d6, we split the total into two dice (arbitrary split that sums correctly)
            d6_2a = min(loaded.d6_2_total - 1, 6)  # First die (max 6)
            d6_2b = loaded.d6_2_total - d6_2a      # Second die gets remainder
            roll_results = [
                DiceRoll("1d6", 1, 6, [loaded.d6_1], loaded.d6_1),
                DiceRoll("2d6", 2, 6, [d6_2a, d6_2b], loaded.d6_2_total),
                DiceRoll("1d20", 1, 20, [loaded.d20], loaded.d20),
            ]
            dice_notation = "1d6;2d6;1d20"
        else:
            # Use the standard baseball dice combination
            dice_notation = "1d6;2d6;1d20"
            roll_results = parse_and_roll_multiple_dice(dice_notation)

        injury_risk = (roll_results[0].total == 6) and (roll_results[1].total in [7, 8, 9, 10, 11, 12])
        d6_total = roll_results[1].total

        embed_title = 'At bat roll'
        if roll_results[2].total == 1:
            embed_title = 'Wild pitch roll'
            dice_notation = '1d20'
            roll_results = [parse_and_roll_single_dice(dice_notation)]
        elif roll_results[2].total == 2:
            embed_title = 'PB roll'
            dice_notation = '1d20'
            roll_results = [parse_and_roll_single_dice(dice_notation)]

        # Create embed for the roll results
        embed = self._create_multi_roll_embed(
            dice_notation,
            roll_results,
            interaction.user,
            set_author=False,
            embed_color=embed_color
        )
        embed.title = f'{embed_title} for {interaction.user.display_name}'

        if injury_risk and embed_title == 'At bat roll':
            embed.add_field(
                name=f'Check injury for pitcher injury rating {13 - d6_total}',
                value='Oops! All injuries!',
                inline=False
            )

        await interaction.followup.send(embed=embed)

    @commands.command(name="ab", aliases=["atbat"])
    async def ab_dice_prefix(self, ctx: commands.Context):
        """Roll baseball at-bat dice using prefix commands (!ab, !atbat)."""
        self.logger.info(f"At Bat dice command started by {ctx.author.display_name}")
        team = await get_user_major_league_team(user_id=ctx.author.id)
        embed_color = EmbedColors.PRIMARY
        if team is not None and team.color is not None:
            embed_color = int(team.color,16)

        # Use the standard baseball dice combination
        dice_notation = "1d6;2d6;1d20"
        roll_results = parse_and_roll_multiple_dice(dice_notation)

        self.logger.info("At Bat dice rolled successfully", roll_count=len(roll_results))

        # Create embed for the roll results
        embed = self._create_multi_roll_embed(dice_notation, roll_results, ctx.author, set_author=False, embed_color=embed_color)
        embed.title = f'At bat roll for {ctx.author.display_name}'
        await ctx.send(embed=embed)

    @discord.app_commands.command(
        name="scout",
        description="Roll weighted scouting dice (1d6;2d6;1d20) based on card type"
    )
    @discord.app_commands.describe(
        card_type="Type of card being scouted"
    )
    @discord.app_commands.choices(card_type=[
        discord.app_commands.Choice(name="Batter", value="batter"),
        discord.app_commands.Choice(name="Pitcher", value="pitcher")
    ])
    @logged_command("/scout")
    async def scout_dice(
        self,
        interaction: discord.Interaction,
        card_type: discord.app_commands.Choice[str]
    ):
        """Roll weighted scouting dice based on card type (batter or pitcher)."""
        await interaction.response.defer()

        # Get the card type value
        card_type_value = card_type.value

        # Roll weighted scouting dice
        roll_results = self._roll_weighted_scout_dice(card_type_value)

        # Create embed for the roll results
        embed = self._create_multi_roll_embed("1d6;2d6;1d20", roll_results, interaction.user, set_author=False)
        embed.title = f'Scouting roll for {interaction.user.display_name}'
        await interaction.followup.send(embed=embed)

    @discord.app_commands.command(
        name="fielding",
        description="Roll Super Advanced fielding dice for a defensive position"
    )
    @discord.app_commands.describe(
        position="Defensive position"
    )
    @discord.app_commands.choices(position=[
        discord.app_commands.Choice(name="Pitcher (P)", value="P"),
        discord.app_commands.Choice(name="Catcher (C)", value="C"),
        discord.app_commands.Choice(name="First Base (1B)", value="1B"),
        discord.app_commands.Choice(name="Second Base (2B)", value="2B"),
        discord.app_commands.Choice(name="Third Base (3B)", value="3B"),
        discord.app_commands.Choice(name="Shortstop (SS)", value="SS"),
        discord.app_commands.Choice(name="Left Field (LF)", value="LF"),
        discord.app_commands.Choice(name="Center Field (CF)", value="CF"),
        discord.app_commands.Choice(name="Right Field (RF)", value="RF")
    ])
    @logged_command("/fielding")
    async def fielding_roll(
        self,
        interaction: discord.Interaction,
        position: discord.app_commands.Choice[str]
    ):
        """Roll Super Advanced fielding dice for a defensive position."""
        await interaction.response.defer()
        embed_color = await self._get_channel_embed_color(interaction)

        # Get the position value from the choice
        pos_value = position.value

        # Roll the dice - 1d20 and 3d6
        dice_notation = "1d20;3d6;1d100"
        roll_results = parse_and_roll_multiple_dice(dice_notation)

        # Create fielding embed
        embed = self._create_fielding_embed(pos_value, roll_results, interaction.user, embed_color)
        await interaction.followup.send(embed=embed)

    @commands.command(name="f", aliases=["fielding", "saf"])
    async def fielding_roll_prefix(self, ctx: commands.Context, position: str | None = None):
        """Roll Super Advanced fielding dice using prefix commands (!f, !fielding, !saf)."""
        self.logger.info(f"SA Fielding command started by {ctx.author.display_name}", position=position)

        if position is None:
            await ctx.send("❌ Please specify a position. Usage: `!f 3B` or `!fielding SS`")
            return

        # Parse and validate position
        parsed_position = self._parse_position(position)
        if not parsed_position:
            await ctx.send("❌ Invalid position. Use: C, 1B, 2B, 3B, SS, LF, CF, RF")
            return

        # Roll the dice - 1d20 and 3d6 and 1d100
        dice_notation = "1d20;3d6;1d100"
        roll_results = parse_and_roll_multiple_dice(dice_notation)

        self.logger.info("SA Fielding dice rolled successfully", position=parsed_position, d20=roll_results[0].total, d6_total=roll_results[1].total)

        # Create fielding embed
        embed = self._create_fielding_embed(parsed_position, roll_results, ctx.author)
        await ctx.send(embed=embed)

    @discord.app_commands.command(
        name="jump",
        description="Roll for baserunner's jump before stealing"
    )
    @logged_command("/jump")
    async def jump_dice(self, interaction: discord.Interaction):
        """Roll to check for a baserunner's jump before attempting to steal a base."""
        await interaction.response.defer()
        embed_color = await self._get_channel_embed_color(interaction)

        # Roll 1d20 for pickoff/balk check
        check_roll = random.randint(1, 20)

        # Roll 2d6 for jump rating
        jump_result = parse_and_roll_single_dice("2d6")

        # Roll another 1d20 for pickoff/balk resolution
        resolution_roll = random.randint(1, 20)

        # Create embed based on check roll
        embed = self._create_jump_embed(
            check_roll,
            jump_result,
            resolution_roll,
            interaction.user,
            embed_color,
            show_author=False
        )
        await interaction.followup.send(embed=embed)

    @commands.command(name="j", aliases=["jump"])
    async def jump_dice_prefix(self, ctx: commands.Context):
        """Roll for baserunner's jump using prefix commands (!j, !jump)."""
        self.logger.info(f"Jump command started by {ctx.author.display_name}")
        team = await get_user_major_league_team(user_id=ctx.author.id)
        embed_color = EmbedColors.PRIMARY
        if team is not None and team.color is not None:
            embed_color = int(team.color, 16)

        # Roll 1d20 for pickoff/balk check
        check_roll = random.randint(1, 20)

        # Roll 2d6 for jump rating
        jump_result = parse_and_roll_single_dice("2d6")

        # Roll another 1d20 for pickoff/balk resolution
        resolution_roll = random.randint(1, 20)

        self.logger.info("Jump dice rolled successfully", check=check_roll, jump=jump_result.total if jump_result else None, resolution=resolution_roll)

        # Create embed based on check roll
        embed = self._create_jump_embed(
            check_roll,
            jump_result,
            resolution_roll,
            ctx.author,
            embed_color
        )
        await ctx.send(embed=embed)

    async def _get_channel_embed_color(self, interaction: discord.Interaction) -> int:
        # Check if channel is a type that has a name attribute (DMChannel doesn't have one)
        if isinstance(interaction.channel, (discord.TextChannel, discord.VoiceChannel, discord.Thread)):
            channel_starter = interaction.channel.name[:6]
            if '-' in channel_starter:
                abbrev = channel_starter.split('-')[0]
                channel_team = await team_service.get_team_by_abbrev(abbrev)
                if channel_team is not None and channel_team.color is not None:
                    return int(channel_team.color,16)

        team = await get_user_major_league_team(user_id=interaction.user.id)
        if team is not None and team.color is not None:
            return int(team.color,16)

        return EmbedColors.PRIMARY

    def _parse_position(self, position: str) -> str | None:
        """Parse and validate fielding position input for prefix commands."""
        if not position:
            return None

        pos = position.upper().strip()

        # Map common inputs to standard position names
        position_map = {
            'P': 'P', 'PITCHER': 'P',
            'C': 'C', 'CATCHER': 'C',
            '1': '1B', '1B': '1B', 'FIRST': '1B', 'FIRSTBASE': '1B',
            '2': '2B', '2B': '2B', 'SECOND': '2B', 'SECONDBASE': '2B',
            '3': '3B', '3B': '3B', 'THIRD': '3B', 'THIRDBASE': '3B',
            'SS': 'SS', 'SHORT': 'SS', 'SHORTSTOP': 'SS',
            'LF': 'LF', 'LEFT': 'LF', 'LEFTFIELD': 'LF',
            'CF': 'CF', 'CENTER': 'CF', 'CENTERFIELD': 'CF',
            'RF': 'RF', 'RIGHT': 'RF', 'RIGHTFIELD': 'RF'
        }

        return position_map.get(pos)

    def _create_fielding_embed(
            self, 
            position: str, 
            roll_results: list[DiceRoll], 
            user: discord.User | discord.Member, 
            embed_color: int = EmbedColors.PRIMARY
    ) -> discord.Embed:
        """Create an embed for fielding roll results."""
        d20_result = roll_results[0].total
        d6_total = roll_results[1].total
        d6_rolls = roll_results[1].rolls
        d100_result = roll_results[2].total

        # Create base embed
        embed = EmbedTemplate.create_base_embed(
            title=f"SA Fielding roll for {user.display_name}",
            color=embed_color
        )

        # Set user info
        embed.set_author(
            name=user.display_name,
            icon_url=user.display_avatar.url
        )

        # Add dice results in standard format
        dice_notation = "1d20;3d6"
        embed_dice = self._create_multi_roll_embed(dice_notation, roll_results, user)

        # Extract just the dice result part from the field
        dice_field_value = embed_dice.fields[0].value
        embed.add_field(
            name="Dice Results",
            value=dice_field_value,
            inline=False
        )

        # Add fielding check summary
        range_result = self._get_range_result(position, d20_result)
        embed.add_field(
            name=f"{position} Range Result",
            value=f"```md\n 1 | 2 | 3 | 4 | 5\n{range_result}```",
            inline=False
        )

        # Add rare play or error result
        if d100_result == 1:
            error_result = self._get_rare_play(position, d20_result)
            base_field_name = "Rare Play Result"
        else:
            # Add error result
            error_result = self._get_error_result(position, d6_total)
            base_field_name = "Error Result"

        if error_result:
            # Split text if it exceeds Discord's field limit
            result_chunks = split_text_for_fields(error_result, max_length=1024)

            # Add each chunk as a separate field
            for i, chunk in enumerate(result_chunks):
                field_name = base_field_name
                # Add part indicator if multiple chunks
                if len(result_chunks) > 1:
                    field_name += f" (Part {i+1}/{len(result_chunks)})"

                embed.add_field(
                    name=field_name,
                    value=chunk,
                    inline=False
                )

        # Add help commands
        embed.add_field(
            name="Help Commands",
            value="Run /charts for full chart readout",
            inline=False
        )

        # # Add references
        # embed.add_field(
        #     name="References",
        #     value="Range Chart / Error Chart / Result Reference",
        #     inline=False
        # )

        return embed

    def _create_jump_embed(
        self,
        check_roll: int,
        jump_result: DiceRoll | None,
        resolution_roll: int,
        user: discord.User | discord.Member,
        embed_color: int = EmbedColors.PRIMARY,
        show_author: bool = True
    ) -> discord.Embed:
        """Create an embed for jump roll results."""
        # Create base embed
        embed = EmbedTemplate.create_base_embed(
            title=f"Jump roll for {user.name}",
            color=embed_color
        )

        if show_author:
            # Set user info
            embed.set_author(
                name=user.name,
                icon_url=user.display_avatar.url
            )

        # Check for pickoff or balk
        if check_roll == 1:
            # Pickoff attempt
            embed.add_field(
                name="Special",
                value="```md\nCheck pickoff```",
                inline=False
            )
            embed.add_field(
                name="Pickoff roll",
                value=f"```md\n# {resolution_roll}\nDetails:[1d20 ({resolution_roll})]```",
                inline=False
            )
        elif check_roll == 2:
            # Balk
            embed.add_field(
                name="Special",
                value="```md\nCheck balk```",
                inline=False
            )
            embed.add_field(
                name="Balk roll",
                value=f"```md\n# {resolution_roll}\nDetails:[1d20 ({resolution_roll})]```",
                inline=False
            )
        else:
            # Normal jump - show 2d6 result
            if jump_result:
                rolls_str = ' '.join(str(r) for r in jump_result.rolls)
                embed.add_field(
                    name="Result",
                    value=f"```md\n# {jump_result.total}\nDetails:[2d6 ({rolls_str})]```",
                    inline=False
                )

        return embed

    def _get_range_result(self, position: str, d20_roll: int) -> str:
        """Get the range result display for a position and d20 roll."""
        if position == 'P':
            return self._get_pitcher_range(d20_roll)
        elif position in ['1B', '2B', '3B', 'SS']:
            return self._get_infield_range(d20_roll)
        elif position in ['LF', 'CF', 'RF']:
            return self._get_outfield_range(d20_roll)
        elif position == 'C':
            return self._get_catcher_range(d20_roll)
        return "Unknown position"

    def _get_infield_range(self, d20_roll: int) -> str:
        """Get infield range result based on d20 roll."""
        return INFIELD_RANGES.get(d20_roll, 'Unknown')

    def _get_outfield_range(self, d20_roll: int) -> str:
        """Get outfield range result based on d20 roll."""
        return OUTFIELD_RANGES.get(d20_roll, 'Unknown')

    def _get_catcher_range(self, d20_roll: int) -> str:
        """Get catcher range result based on d20 roll."""
        return CATCHER_RANGES.get(d20_roll, 'Unknown')

    def _get_pitcher_range(self, d20_roll: int) -> str:
        """Get pitcher range result based on d20 roll."""
        return PITCHER_RANGES.get(d20_roll, 'Unknown')
    
    def _get_rare_play(self, position: str, d20_total: int) -> str:
        """Get the rare play result for a position and d20 total"""
        starter = 'Rare play! Take the range result from above and consult the chart below.\n\n'
        if position == 'P':
            return starter + self._get_pitcher_rare_play(d20_total)
        elif position == '1B':
            return starter + self._get_infield_rare_play(d20_total)
        elif position == '2B':
            return starter + self._get_infield_rare_play(d20_total)
        elif position == '3B':
            return starter + self._get_infield_rare_play(d20_total)
        elif position == 'SS':
            return starter + self._get_infield_rare_play(d20_total)
        elif position in ['LF', 'RF']:
            return starter + self._get_outfield_rare_play(d20_total)
        elif position == 'CF':
            return starter + self._get_outfield_rare_play(d20_total)
        
        raise ValueError(f'Unknown position: {position}')

    def _get_error_result(self, position: str, d6_total: int) -> str:
        """Get the error result for a position and 3d6 total."""
        # Get the appropriate error chart
        if position == 'P':
            return self._get_pitcher_error(d6_total)
        elif position == '1B':
            return self._get_1b_error(d6_total)
        elif position == '2B':
            return self._get_2b_error(d6_total)
        elif position == '3B':
            return self._get_3b_error(d6_total)
        elif position == 'SS':
            return self._get_ss_error(d6_total)
        elif position in ['LF', 'RF']:
            return self._get_corner_of_error(d6_total)
        elif position == 'CF':
            return self._get_cf_error(d6_total)
        elif position == 'C':
            return self._get_catcher_error(d6_total)

        # Should never reach here due to position validation, but follow "Raise or Return" pattern
        raise ValueError(f"Unknown position: {position}")

    def _get_3b_error(self, d6_total: int) -> str:
        """Get 3B error result based on 3d6 total."""
        return THIRD_BASE_ERRORS.get(d6_total, 'No error')

    def _get_1b_error(self, d6_total: int) -> str:
        """Get 1B error result based on 3d6 total."""
        return FIRST_BASE_ERRORS.get(d6_total, 'No error')

    def _get_2b_error(self, d6_total: int) -> str:
        """Get 2B error result based on 3d6 total."""
        return SECOND_BASE_ERRORS.get(d6_total, 'No error')

    def _get_ss_error(self, d6_total: int) -> str:
        """Get SS error result based on 3d6 total."""
        return SHORTSTOP_ERRORS.get(d6_total, 'No error')

    def _get_corner_of_error(self, d6_total: int) -> str:
        """Get LF/RF error result based on 3d6 total."""
        return CORNER_OUTFIELD_ERRORS.get(d6_total, 'No error')

    def _get_cf_error(self, d6_total: int) -> str:
        """Get CF error result based on 3d6 total."""
        return CENTER_FIELD_ERRORS.get(d6_total, 'No error')

    def _get_catcher_error(self, d6_total: int) -> str:
        """Get Catcher error result based on 3d6 total."""
        return CATCHER_ERRORS.get(d6_total, 'No error')

    def _get_pitcher_error(self, d6_total: int) -> str:
        """Get Pitcher error result based on 3d6 total."""
        return PITCHER_ERRORS.get(d6_total, 'No error')

    def _get_pitcher_rare_play(self, d20_total: int) -> str:
        return (
            f'**G3**: {INFIELD_X_CHART["g3"]["rp"]}\n'
            f'**G2**: {INFIELD_X_CHART["g2"]["rp"]}\n'
            f'**G1**: {INFIELD_X_CHART["g1"]["rp"]}\n'
            f'**SI1**: {INFIELD_X_CHART["si1"]["rp"]}\n'
        )

    def _get_infield_rare_play(self, d20_total: int) -> str:
        return (
            f'**G3**: {INFIELD_X_CHART["g3"]["rp"]}\n'
            f'**G2**: {INFIELD_X_CHART["g2"]["rp"]}\n'
            f'**G1**: {INFIELD_X_CHART["g1"]["rp"]}\n'
            f'**SI1**: {INFIELD_X_CHART["si1"]["rp"]}\n'
            f'**SI2**: {OUTFIELD_X_CHART["si2"]["rp"]}\n'
        )

    def _get_outfield_rare_play(self, d20_total: int) -> str:
        return (
            f'**F1**: {OUTFIELD_X_CHART["f1"]["rp"]}\n'
            f'**F2**: {OUTFIELD_X_CHART["f2"]["rp"]}\n'
            f'**F3**: {OUTFIELD_X_CHART["f3"]["rp"]}\n'
            f'**SI2**: {OUTFIELD_X_CHART["si2"]["rp"]}\n'
            f'**DO2**: {OUTFIELD_X_CHART["do2"]["rp"]}\n'
            f'**DO3**: {OUTFIELD_X_CHART["do3"]["rp"]}\n'
            f'**TR3**: {OUTFIELD_X_CHART["tr3"]["rp"]}\n'
        )


    def _roll_weighted_scout_dice(self, card_type: str) -> list[DiceRoll]:
        """
        Roll scouting dice with weighted first d6 based on card type.

        Args:
            card_type: Either "batter" (1-3) or "pitcher" (4-6) for first d6

        Returns:
            List of 3 roll result dataclasses: weighted 1d6, normal 2d6, normal 1d20
        """
        # First die (1d6) - weighted based on card type
        if card_type == "batter":
            first_roll = random.randint(1, 3)
        else:  # pitcher
            first_roll = random.randint(4, 6)

        first_d6_result = DiceRoll(
            dice_notation='1d6',
            num_dice=1,
            die_sides=6,
            rolls=[first_roll],
            total=first_roll
        )

        # Second roll (2d6) - normal
        second_result = parse_and_roll_single_dice("2d6")

        # Third roll (1d20) - normal
        third_result = parse_and_roll_single_dice("1d20")

        return [first_d6_result, second_result, third_result]

    def _create_multi_roll_embed(self, dice_notation: str, roll_results: list[DiceRoll], user: discord.User | discord.Member, set_author: bool = True, embed_color: int = EmbedColors.PRIMARY) -> discord.Embed:
        """Create an embed for multiple dice roll results."""
        embed = EmbedTemplate.create_base_embed(
            title="🎲 Dice Roll",
            color=embed_color
        )

        if set_author:
            # Set user info
            embed.set_author(
                name=user.name,
                icon_url=user.display_avatar.url
            )

        # Create summary line with totals
        totals = [str(result.total) for result in roll_results]
        summary = f"# {','.join(totals)}"

        # Create details line in the specified format: Details:[1d6;2d6;1d20 (5 - 5 6 - 13)]
        dice_notations = [result.dice_notation for result in roll_results]

        # Create the rolls breakdown part - group dice within each roll, separate roll groups with dashes
        roll_groups = []
        for result in roll_results:
            rolls = result.rolls
            if len(rolls) == 1:
                # Single die: just the number
                roll_groups.append(str(rolls[0]))
            else:
                # Multiple dice: space-separated within the group
                roll_groups.append(' '.join(str(r) for r in rolls))

        details = f"Details:[{';'.join(dice_notations)} ({' - '.join(roll_groups)})]"

        # Set as description
        embed.add_field(
            name='Result',
            value=f"```md\n{summary}\n{details}```"
        )

        return embed


async def setup(bot: commands.Bot):
    """Load the dice roll commands cog."""
    await bot.add_cog(DiceRollCommands(bot))