package dg5_config

import (
	"encoding/json"
	"fmt"
	"math/rand"
	"os"
	"path/filepath"
)

type Config struct {
	Reel              [][]int             `json:"reel"`
	ReelWeight        [][]int             `json:"reelWeight"`
	ReelFree1         [][]int             `json:"reelFree1"`
	ReelFreeWeight1   [][]int             `json:"reelFreeWeight1"`
	ReelFree2         [][]int             `json:"reelFree2"`
	ReelFreeWeight2   [][]int             `json:"reelFreeWeight2"`
	ReelFree3         [][]int             `json:"reelFree3"`
	ReelFreeWeight3   [][]int             `json:"reelFreeWeight3"`
	ReelFree4         [][]int             `json:"reelFree4"`
	ReelFreeWeight4   [][]int             `json:"reelFreeWeight4"`
	ReelFree5         [][]int             `json:"reelFree5"`
	ReelFreeWeight5   [][]int             `json:"reelFreeWeight5"`
	FreeGameSpinCount map[string]int      `json:"freeGameSpinCount"`
	FreeGameMulPro    map[int]map[int]int `json:"freeGameMulPro"`
	FuMulPro          map[int]int         `json:"fuMulPro"`
	Weight            int                 `json:"Weight"`
}

type AxisConfig struct {
	Reels             []*AxisWeight
	FreeGameSpinCount map[string]int
	FreeGameMulPro    map[int]map[int]int
	FuMulPro          map[int]int
	Weight            int
}

type AxisWeight struct {
	Reel       [][]int
	ReelWeight [][]int
	AllWeight  []int
	Col        int // 行
}

var AxisConfigs []*AxisConfig
var allWeight = 0

func LoadConfig(cfgName string, target any) {
	rootDir, _ := os.Getwd()
	cfgDefPath := filepath.Join(rootDir, "../../config/dg5", cfgName)

	file, err := os.Open(cfgDefPath)
	if err != nil {
		fmt.Println("Error opening file:", err)
		return
	}
	defer file.Close()

	decoder := json.NewDecoder(file)
	if err := decoder.Decode(target); err != nil {
		fmt.Println("Error decoding JSON:", err)
		return
	}
}

func Init() {
	cfs := []string{"rtp_90.json"}
	for i := 0; i < len(cfs); i++ {
		cfg := &Config{}
		LoadConfig(cfs[i], cfg)
		reels := []*AxisWeight{}
		reels = append(reels, newAxisWeight(cfg.Reel, cfg.ReelWeight, 3))
		reels = append(reels, newAxisWeight(cfg.ReelFree1, cfg.ReelFreeWeight1, 3))
		reels = append(reels, newAxisWeight(cfg.ReelFree2, cfg.ReelFreeWeight2, 3))
		reels = append(reels, newAxisWeight(cfg.ReelFree3, cfg.ReelFreeWeight3, 3))
		reels = append(reels, newAxisWeight(cfg.ReelFree4, cfg.ReelFreeWeight4, 3))
		reels = append(reels, newAxisWeight(cfg.ReelFree5, cfg.ReelFreeWeight5, 3))

		axisConfig := &AxisConfig{
			Reels:             reels,
			FreeGameSpinCount: cfg.FreeGameSpinCount,
			FreeGameMulPro:    cfg.FreeGameMulPro,
			FuMulPro:          cfg.FuMulPro,
			Weight:            cfg.Weight,
		}

		AxisConfigs = append(AxisConfigs, axisConfig)
		allWeight += cfg.Weight
	}
}

func GetAxisConfig(idx int) (*AxisConfig, int) {
	if idx == -1 {
		randin := rand.Intn(allWeight)
		w := 0
		for i := 0; i < len(AxisConfigs); i++ {
			w += AxisConfigs[i].Weight
			if w > randin {
				return AxisConfigs[i], i
			}
		}
	}
	if idx >= 0 && idx < len(AxisConfigs) {
		return AxisConfigs[idx], idx
	}
	return AxisConfigs[0], 0
}

func newAxisWeight(reel [][]int, reelWeight [][]int, col int) *AxisWeight {
	r := &AxisWeight{
		Reel:       reel,
		ReelWeight: reelWeight,
		Col:        col,
	}
	all := make([]int, len(reelWeight))
	for i := 0; i < len(reelWeight); i++ {
		all[i] = 0
		for _, w := range reelWeight[i] {
			all[i] += w
		}
	}
	r.AllWeight = all
	return r
}

func (s *AxisWeight) Randmon(i int, randin int) []int {
	w := 0
	cards := []int{}
	for j := 0; j < len(s.ReelWeight[i]); j++ {
		w += s.ReelWeight[i][j]
		if w > randin {
			for m := 0; m < s.Col; m++ {
				cards = append(cards, s.Reel[i][(j+m)%len(s.Reel[i])])
			}
			break
		}
	}
	return cards
}