package wildapeslot

import (
	"encoding/json"
	"os"

	"bet24.com/log"
)

type Slot struct {
	SlotID  int // 编号
	IsMagic int // 万能牌
	IsBonus bool
	IsFree  bool
	Name    string  // 名字
	Win3    float64 // 3个连线赔率
	Win4    float64 // 4个连线赔率
	Win5    float64 // 5个连线赔率
}

//读取配置的时候初始化
var FREE_ID int
var BONUS_ID int
var MAGIC_ID int

func (s *Slot) isMagic() bool {
	return s.IsMagic > 0
}

type SlotManager struct {
	Slots []Slot
}

func newSlotManager() *SlotManager {
	log.Color(LogColor, "newSlotManager")
	ret := new(SlotManager)
	ret.loadData()
	return ret
}

func (sm *SlotManager) getMagicSlotId() int {
	for _, v := range sm.Slots {
		if v.isMagic() {
			return v.SlotID
		}
	}
	return -1
}

func (sm *SlotManager) loadData() {
	data, err := os.ReadFile("slotconf/wildapeslot.json")
	if err != nil {
		log.Error("SlotManager.loadData read wildapeslot.json failed")
	}

	err = json.Unmarshal(data, &sm.Slots)
	if err != nil {
		log.Error("SlotManager.loadData Unmarshal wildapeslot.json failed err:%v", err)
		return
	}

	for _, v := range sm.Slots {
		if v.isMagic() {
			MAGIC_ID = v.SlotID
		} else if v.IsFree {
			FREE_ID = v.SlotID
		} else if v.IsBonus {
			BONUS_ID = v.SlotID
		}
	}
}

func (sm *SlotManager) getSlot(slotId int) *Slot {
	for _, v := range sm.Slots {
		if v.SlotID == slotId {
			return &v
		}
	}
	return nil
}

func (sm *SlotManager) isMagic(slotId int) bool {
	s := sm.getSlot(slotId)
	if s == nil {
		log.Color(LogColor, "SlotManager.isMagic invlaid SlotId %d", slotId)
		return false
	}
	return s.isMagic()
}

func (sm *SlotManager) getBonusCount(slots []int) int {
	count := 0
	for _, v := range slots {
		if sm.getSlot(v).IsBonus {
			count++
		}
	}
	return count
}

// 查看5个组合是否中
// func (sm *SlotManager) getResult(slots []int) (slotId, count int, winMultiple float64) {
// 	slotId = -1
// 	winMultiple = 0.0
// 	count = 0
// 	if len(slots) != COLUMN_COUNT {
// 		log.Color(LogColor, "SlotManager.getResult invalid len %v", slots)
// 		return
// 	}
// 	for i := 0; i < COLUMN_COUNT; i++ {
// 		if sm.isMagic(slots[i]) {
// 			count++
// 			continue
// 		}

// 		if slotId == -1 {
// 			slotId = slots[i]
// 			count++
// 			continue
// 		}
// 		if slots[i] != slotId {
// 			break
// 		}
// 		count++
// 	}
// 	if slotId == -1 {
// 		return
// 	}
// 	slot := sm.getSlot(slotId)
// 	if slot == nil {
// 		return
// 	}
// 	switch count {
// 	case 3:
// 		winMultiple = slot.Win3
// 	case 4:
// 		winMultiple = slot.Win4
// 	case 5:
// 		winMultiple = slot.Win5
// 	default:
// 		return
// 	}

// 	return
// }

// func (sm *SlotManager) getResults(slots []int) []Result {
// 	var ret []Result
// 	for r1 := 0; r1 < ROW_COUNT; r1++ {
// 		for r2 := 0; r2 < ROW_COUNT; r2++ {
// 			for r3 := 0; r3 < ROW_COUNT; r3++ {
// 				for r4 := 0; r4 < ROW_COUNT; r4++ {
// 					for r5 := 0; r5 < ROW_COUNT; r5++ {
// 						slotId, count, winMultiple := sm.getResult([]int{
// 							slots[r1*COLUMN_COUNT],
// 							slots[r2*COLUMN_COUNT+1],
// 							slots[r3*COLUMN_COUNT+2],
// 							slots[r4*COLUMN_COUNT+3],
// 							slots[r5*COLUMN_COUNT+4],
// 						})
// 						if winMultiple > 0 {
// 							winShape := 0
// 							if count == 3 {
// 								winShape = (r1+1)*100 + (r2+1)*10 + r3 + 1
// 							} else if count == 4 {
// 								winShape = (r1+1)*1000 + (r2+1)*100 + (r3+1)*10 + r4 + 1
// 							} else if count == 5 {
// 								winShape = (r1+1)*10000 + (r2+1)*1000 + (r3+1)*100 + (r4+1)*10 + r5 + 1
// 							}
// 							ret = append(ret, Result{
// 								SlotID:    slotId,
// 								SlotCount: count,
// 								WinShape:  winShape,
// 								WinRate:   winMultiple,
// 							})
// 						}
// 					}
// 				}
// 			}
// 		}
// 	}
// 	// 去重，把短的去掉
// 	if len(ret) == 0 {
// 		return ret
// 	}
// 	sort.Slice(ret, func(i, j int) bool {
// 		return ret[i].WinShape < ret[j].WinShape
// 	})
// 	for i := 0; i < len(ret)-1; {
// 		flag := false
// 		for j := i + 1; j < len(ret); j++ {
// 			if ret[i].WinShape == ret[j].WinShape ||
// 				ret[i].WinShape == ret[j].WinShape/10 ||
// 				ret[i].WinShape == ret[j].WinShape/100 {
// 				flag = true
// 				break
// 			}
// 		}
// 		if flag {
// 			ret = append(ret[:i], ret[i+1:]...)
// 		} else {
// 			i++
// 		}
// 	}
// 	return ret
// }