Untitled

package controllers

import (
	"bytes"
	"crypto/rand"
	"crypto/tls"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"math/big"
	"net/http"
	"time"

	"github.com/gofiber/fiber/v2"
	"github.com/ibibe/mines/models"
	"github.com/ibibe/mines/services.go"
)

func generateRandomMines(totalPositions, mineCount int) []int {
	positions := make(map[int]bool)
	for len(positions) < mineCount {
		nBig, _ := rand.Int(rand.Reader, big.NewInt(int64(totalPositions)))
		pos := int(nBig.Int64())
		if pos < totalPositions && !positions[pos] {
			positions[pos] = true
		}
	}

	result := make([]int, 0, len(positions))
	for pos := range positions {
		result = append(result, pos)
	}
	return result
}

func generateGridResults(minePositions []int, totalPositions int) []string {
	results := make([]string, totalPositions)

	for i := range results {
		results[i] = "Closed"
	}

	for _, pos := range minePositions {
		results[pos] = "Mine"
	}

	return results
}

func PlayController(c *fiber.Ctx) error {
	var req models.PlayRequest
	if err := c.BodyParser(&req); err != nil {
		fmt.Println(err)
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Invalid request"})
	}

	if req.Action == "play" {
		//game logic here
		const totalPositions = 25
		const mineCount = 5

		gRx := models.GameRx{
			ClientId:         req.ClientId,
			RTP:              services.GetGameRtp(services.StringToInt(req.ClientId)),
			PayoutMultiplier: req.Multiplier,
			RequestSalt:      "",
			BetAmount:        req.StakeAmount,
		}

		//generate mine positions
		minePositions := generateRandomMines(totalPositions, mineCount)

		results := generateGridResults(minePositions, totalPositions)

		// generate random number
		randomBig, _ := rand.Int(rand.Reader, big.NewInt(100))
		randomValue := float64(randomBig.Int64()) / 100.0

		targetRTP := gRx.RTP / 100.0
		isWin := randomValue <= targetRTP

		payoutAmount := 0.0
		if isWin {
			payoutAmount = req.StakeAmount * req.Multiplier
		}
		return c.JSON(models.GameResponse{
			Payout: models.ResponsePayout{
				Amount:   payoutAmount,
				Currency: "USD",
			},
			Nonce:        int(time.Now().Unix()),
			PayoutFactor: req.Multiplier,
			Balance: models.ResponseBalance{
				UpdatedOn: time.Now(),
				Amount:    1000.00, //replace with actual balance
				Currency:  "USD",
			},
			Id: req.BetId,
			Data: models.ResponseData{
				Results:    results,
				DataType:   "game_results",
				Multiplier: req.Multiplier,
			},
		})
	}

	if req.Action == "cashout" {
		return c.JSON(models.GameResponse{
			Stake: models.ResponseStake{
				Amount:   req.StakeAmount,
				Currency: "USD",
			},
			Balance: models.ResponseBalance{
				UpdatedOn: time.Now(),
				Amount:    req.StakeAmount * req.Multiplier,
				Currency:  "USD",
			},
			Id: req.BetId,
		})
	}

	return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Invalid action"})
}

func CommonPostReturn(postUrl string, postData interface{}) []byte {
	marshalJson, _ := json.Marshal(postData)
	req, err := http.NewRequest("POST", postUrl, bytes.NewBuffer(marshalJson))
	req.Header.Set("X-Requested-With", "XMLHttpRequest")
	req.Header.Set("Content-Type", "application/json")
	tr := &http.Transport{
		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
	}
	client := &http.Client{Transport: tr}
	resp, err := client.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := ioutil.ReadAll(resp.Body)
	return body
}