sportbet.py

import discord
from discord import app_commands
import aiohttp
import asyncio
from datetime import datetime, timezone
from cash import user_cash

user_bets = {}

async def fetch_nhl_scores():
    async with aiohttp.ClientSession() as session:
        async with session.get("https://nhl-score-api.herokuapp.com/api/scores/latest") as response:
            return await response.json()

class SportSelect(discord.ui.Select):
    def __init__(self):
        options = [
            discord.SelectOption(label="NHL", value="nhl", description="National Hockey League")
        ]
        super().__init__(placeholder="Select a sport", options=options)

class GameSelect(discord.ui.Select):
    def __init__(self, games):
        options = [
            discord.SelectOption(
                label=f"{game['teams']['away']['teamName']} vs {game['teams']['home']['teamName']}",
                value=f"{game['teams']['away']['abbreviation']}_{game['teams']['home']['abbreviation']}",
                description=f"Start time: <t:{int(datetime.fromisoformat(game['startTime'].replace('Z', '+00:00')).timestamp())}:R>"
            ) for game in games
        ]
        super().__init__(placeholder="Select a game", options=options)

class TeamSelect(discord.ui.Select):
    def __init__(self, away_team, home_team):
        options = [
            discord.SelectOption(label=away_team['teamName'], value=away_team['abbreviation']),
            discord.SelectOption(label=home_team['teamName'], value=home_team['abbreviation'])
        ]
        super().__init__(placeholder="Select a team to bet on", options=options)

class BetModal(discord.ui.Modal, title="Place Your Bet"):
    bet_amount = discord.ui.TextInput(label="Bet Amount", placeholder="Enter bet amount")

    def __init__(self, team, user_id, game_data):
        super().__init__()
        self.team = team
        self.user_id = user_id
        self.game_data = game_data

    async def on_submit(self, interaction: discord.Interaction):
        try:
            bet_amount = int(self.bet_amount.value)
            if bet_amount <= 0:
                raise ValueError("Bet more than 0 dollars")
            if bet_amount > user_cash.get(self.user_id, 0):
                raise ValueError("you are too poor check ur balance and try again")

            user_cash[self.user_id] -= bet_amount
            await interaction.response.send_message(f"Bet placed on {self.team} for ${bet_amount}")
            
            user = await interaction.client.fetch_user(self.user_id)
            embed = discord.Embed(title="Bet Placed", color=0x787878)
            embed.add_field(name="Team", value=self.team, inline=False)
            embed.add_field(name="Amount", value=f"${bet_amount}", inline=False)
            embed.add_field(name="Game", value=f"{self.game_data['teams']['away']['teamName']} vs {self.game_data['teams']['home']['teamName']}", inline=False)
            embed.add_field(name="Start Time", value=f"<t:{int(datetime.fromisoformat(self.game_data['startTime'].replace('Z', '+00:00')).timestamp())}:R>", inline=False)
            await user.send(embed=embed)

            if self.user_id not in user_bets:
                user_bets[self.user_id] = []
            user_bets[self.user_id].append({
                "team": self.team,
                "amount": bet_amount,
                "game_data": self.game_data
            })
            
            asyncio.create_task(self.monitor_game(interaction, bet_amount))
        except ValueError as e:
            await interaction.response.send_message(str(e), ephemeral=True)

    async def monitor_game(self, interaction, bet_amount):
        game_start = datetime.fromisoformat(self.game_data['startTime'].replace('Z', '+00:00'))
        await asyncio.sleep((game_start - datetime.now(timezone.utc)).total_seconds())

        previous_scores = {'away': 0, 'home': 0}

        while True:
            scores = await fetch_nhl_scores()
            game = next((g for g in scores['games'] if g['teams']['away']['abbreviation'] == self.game_data['teams']['away']['abbreviation'] and 
                         g['teams']['home']['abbreviation'] == self.game_data['teams']['home']['abbreviation']), None)
            
            current_scores = game['scores']
            
            for team in ['away', 'home']:
                if current_scores[team] > previous_scores[team]:
                    team_name = game['teams'][team]['teamName']
                    await interaction.user.send(f"{team_name} SCORED! Current score: {current_scores['away']} - {current_scores['home']}")
            
            previous_scores = current_scores.copy()
            
            if game['status']['state'] == 'FINAL':
                winner = 'away' if game['scores']['away'] > game['scores']['home'] else 'home'
                if game['teams'][winner]['abbreviation'] == self.team:
                    winnings = bet_amount * 2
                    user_cash[self.user_id] += winnings
                    await interaction.user.send(f"Congratulations! Your team won. You won ${winnings}!")
                else:
                    await interaction.user.send(f"Sorry, your team lost CRY")
                
                user_bets[self.user_id] = [bet for bet in user_bets[self.user_id] if bet['game_data'] != self.game_data]
                break
            
            await asyncio.sleep(60)  # Check for updates every minute

class SportBetView(discord.ui.View):
    def __init__(self):
        super().__init__()

    @discord.ui.button(label="Bet Again", style=discord.ButtonStyle.primary)
    async def bet_again(self, interaction: discord.Interaction, button: discord.ui.Button):
        await show_sport_selection(interaction)

    @discord.ui.button(label="View Bets", style=discord.ButtonStyle.secondary)
    async def view_bets(self, interaction: discord.Interaction, button: discord.ui.Button):
        await show_current_bets(interaction)

async def show_sport_selection(interaction: discord.Interaction):
    view = discord.ui.View()
    sport_select = SportSelect()
    view.add_item(sport_select)

    await interaction.response.send_message("Select a sport to bet on:", view=view)

    async def sport_callback(interaction: discord.Interaction):
        selected_sport = sport_select.values[0]
        if selected_sport == "nhl":
            await show_game_selection(interaction)

    sport_select.callback = sport_callback

async def show_game_selection(interaction: discord.Interaction):
    scores = await fetch_nhl_scores()
    upcoming_games = [game for game in scores['games'] if game['status']['state'] == 'PREVIEW']

    if not upcoming_games:
        await interaction.response.send_message("No games available for betting.")
        return

    view = discord.ui.View()
    game_select = GameSelect(upcoming_games)
    view.add_item(game_select)

    await interaction.response.edit_message(content="Select a game to bet on:", view=view)

    async def game_callback(interaction: discord.Interaction):
        selected_game = next(game for game in upcoming_games if f"{game['teams']['away']['abbreviation']}_{game['teams']['home']['abbreviation']}" == game_select.values[0])
        
        team_view = discord.ui.View()
        team_select = TeamSelect(selected_game['teams']['away'], selected_game['teams']['home'])
        team_view.add_item(team_select)

        await interaction.response.edit_message(content="Select a team to bet on:", view=team_view)

        async def team_callback(interaction: discord.Interaction):
            selected_team = team_select.values[0]
            await interaction.response.send_modal(BetModal(selected_team, interaction.user.id, selected_game))

        team_select.callback = team_callback

    game_select.callback = game_callback

async def show_current_bets(interaction: discord.Interaction):
    user_id = interaction.user.id
    if user_id not in user_bets or not user_bets[user_id]:
        await interaction.response.send_message("You have no active bets.")
        return

    embed = discord.Embed(title="Your Current Bets", color=0x787878)
    scores = await fetch_nhl_scores()
    
    for i, bet in enumerate(user_bets[user_id]):
        game = next((g for g in scores['games'] if g['teams']['away']['abbreviation'] == bet['game_data']['teams']['away']['abbreviation'] and 
                     g['teams']['home']['abbreviation'] == bet['game_data']['teams']['home']['abbreviation']), None)
        
        start_time = datetime.fromisoformat(bet['game_data']['startTime'].replace('Z', '+00:00'))
        current_time = datetime.now(timezone.utc)
        
        if current_time < start_time:
            status = f"Starts <t:{int(start_time.timestamp())}:R>"
            score = "N/A"
        else:
            status = game['status']['state']
            score = f"{game['scores']['away']} - {game['scores']['home']}"
        
        embed.add_field(name=f"Bet {i+1}", value=(
            f"Team: {bet['team']}\n"
            f"Amount: ${bet['amount']}\n"
            f"Game: {bet['game_data']['teams']['away']['teamName']} vs {bet['game_data']['teams']['home']['teamName']}\n"
            f"Status: {status}\n"
            f"Current Score: {score}\n"
            f"Start Time: <t:{int(start_time.timestamp())}:F>"
        ), inline=False)

    view = discord.ui.View()
    cancel_select = discord.ui.Select(placeholder="Select a bet to cancel", options=[
        discord.SelectOption(label=f"Bet {i+1}", value=str(i)) for i in range(len(user_bets[user_id]))
    ])
    view.add_item(cancel_select)

    async def cancel_callback(interaction: discord.Interaction):
        bet_index = int(cancel_select.values[0])
        cancelled_bet = user_bets[user_id].pop(bet_index)
        user_cash[user_id] += cancelled_bet['amount']
        await interaction.response.send_message(f"Bet cancelled. ${cancelled_bet['amount']} has been refunded to your balance.")

    cancel_select.callback = cancel_callback

    await interaction.response.send_message(embed=embed, view=view)

@app_commands.command(name="sportbet", description="Bet on sports games")
async def sportbet(interaction: discord.Interaction):
    user_id = interaction.user.id
    if user_id in user_bets and user_bets[user_id]:
        view = SportBetView()
        await interaction.response.send_message("?", view=view)
    else:
        await show_sport_selection(interaction)