game

This system involves a complex betting application with the following requirements and features. I'll break it down and provide a detailed solution for each aspect:

Core Features

User Inputs:
- A 6-digit number (e.g., 458646).
- fAmount (First Bet Amount) and sAmount (Second Bet Amount), which are optional but may be used together.
- A game name and game ID, which have a start and end time.
- Ability to edit bets within a specified time frame (e.g., 9 minutes before the game starts).
Generated Numbers:
- Based on the 6-digit input, generate multiple combinations (e.g., 50 numbers).
Bet Details Table:
- Display a table with all generated numbers, along with:
  - fAmount (editable by the user).
  - sAmount (editable by the user).
  - Calculated total bets.
- Apply min/max bet validation.
- Show total bets and amount spent per game.
Admin Features:
- Enter a winning number after the game ends.
- Match the winning number to determine winners and losses.
History:
- Store all bets, wins, and losses.
- Include details like total spent, winning number, total winnings, and total losses.
- Allow day-wise history views.
Win/Loss Calculation:
- If a user's number matches the admin's winning number, calculate the payout based on bet amounts (fAmount and sAmount).
- Show win/loss messages in the user interface.

Database Design

1. User Schema

Stores user data for tracking credit/debit and bet history.

javascript
const userSchema = new mongoose.Schema({
  name: String,
  email: String,
  password: String,
  balance: { type: Number, default: 0 }, // Tracks current balance
  history: [
    {
      gameId: { type: mongoose.Schema.Types.ObjectId, ref: 'Game' },
      bets: [
        {
          number: String,
          fAmount: Number,
          sAmount: Number,
          result: String, // "Win" or "Loss"
          payout: Number, // Amount won or lost
        },
      ],
      totalSpent: Number,
      totalWon: Number,
      totalLost: Number,
    },
  ],
});

2. Game Schema

Stores game details like start/end time and winning number.

javascript
const gameSchema = new mongoose.Schema({
  name: String,
  gameId: String,
  startTime: Date,
  endTime: Date,
  winningNumber: { type: String, default: null }, // Admin sets this after the game ends
  bets: [
    {
      userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
      number: String,
      fAmount: Number,
      sAmount: Number,
      totalBet: Number,
      result: String, // "Win" or "Loss"
      payout: Number,
    },
  ],
});

3. Bet Schema

Tracks individual bets for a user and links to a game.

javascript
const betSchema = new mongoose.Schema({
  userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
  gameId: { type: mongoose.Schema.Types.ObjectId, ref: 'Game' },
  number: String,
  fAmount: Number,
  sAmount: Number,
  totalBet: Number,
  result: String, // "Win" or "Loss"
  payout: Number,
});

Backend Logic

1. Generating Numbers

Generate numbers based on the input:

javascript
function generateNumbers(input) {
  const numbers = [];
  for (let i = 0; i < 50; i++) {
    const generatedNumber = input.split('').sort(() => Math.random() - 0.5).join('');
    if (!numbers.includes(generatedNumber)) {
      numbers.push(generatedNumber);
    }
  }
  return numbers;
}

2. Placing Bets

Save the generated bets and their amounts in the database.

javascript
const placeBets = async (userId, gameId, input, fAmount, sAmount) => {
  const generatedNumbers = generateNumbers(input);
  const bets = generatedNumbers.map((number) => ({
    userId,
    gameId,
    number,
    fAmount,
    sAmount,
    totalBet: fAmount + sAmount,
  }));

  // Save bets in the database
  await Bet.insertMany(bets);

  // Update user's history
  const totalSpent = bets.reduce((sum, bet) => sum + bet.totalBet, 0);
  await User.findByIdAndUpdate(userId, {
    $inc: { balance: -totalSpent },
    $push: {
      history: { gameId, bets, totalSpent },
    },
  });

  return bets;
};

3. Determining Winners

Admin sets the winning number, and the system calculates results.

javascript
const determineWinners = async (gameId, winningNumber) => {
  const game = await Game.findById(gameId);
  const bets = await Bet.find({ gameId });

  bets.forEach(async (bet) => {
    const isWin = bet.number === winningNumber;
    const payout = isWin ? (bet.fAmount + bet.sAmount) * 10 : 0; // Example payout multiplier

    await Bet.findByIdAndUpdate(bet._id, {
      result: isWin ? 'Win' : 'Loss',
      payout,
    });

    if (isWin) {
      await User.findByIdAndUpdate(bet.userId, {
        $inc: { balance: payout },
      });
    }
  });

  await Game.findByIdAndUpdate(gameId, { winningNumber });
};

Frontend Features

1. Betting Interface

Form: Input number, fAmount, sAmount, and select game.
Table: Display generated numbers and editable bet amounts.
Validation: Min/max bet amount per number.

2. History View

Show all past bets with:
- Total spent, total won, total lost.
- Winning number and results.
- Day-wise filter.

3. Real-Time Updates

Disable editing bets 9 minutes before the game starts.
Show results after the admin sets the winning number.

Suggested Features

Bet Limits: Enforce minimum and maximum bet amounts.
Leaderboard: Show top winners across games.
Notifications: Notify users when the game results are published.
Reports: Generate daily reports for admin, showing total bets, payouts, and platform earnings.
Audit Logs: Track all admin actions, including setting the winning number.

This structure provides a scalable solution for your betting application. Let me know if you need detailed code for any specific part!