package controller

import (
	"log"
	"math/rand"
	"reflect"
	"sort"

	"github.com/kataras/iris/v12"
	"github.com/kataras/iris/v12/sessions"
)

type GameController struct {
	Ctx     iris.Context
	Session *sessions.Session
}

func play() {

	slice := createCardGroup()
	washCard(slice)
	// log.Println(slice)

	players := map[int][]card{
		0: {},
		1: {},
		2: {},
	}
	count := 17
	players[0] = slice[:count]
	slice = slice[count:]
	players[1] = slice[:count]
	slice = slice[count:]
	players[2] = slice[:count]
	slice = slice[count:]

	// t := 0
	// for {
	// 	length := len(slice)
	// 	if length == 0 {
	// 		break
	// 	}
	// 	var i int = 0
	// 	if length != 1 {
	// 		i = rand.Intn(length - 1)
	// 	}
	// 	index := t % 3
	// 	players[index] = append(players[index], slice[i])
	// 	slice = append(slice[:i], slice[i+1:]...)
	// 	t++

	// }
	player1 := players[0]
	player2 := players[1]
	player3 := players[2]
	sort.Sort(cards(player1))
	sort.Sort(cards(player2))
	sort.Sort(cards(player3))
	log.Println(player1)
	log.Println(player2)
	log.Println(player3)
	log.Println(slice)

	log.Println(len(player1), len(player2), len(player3), len(slice))

}

type card struct {
	Icon string
	Numb string
	// IconIdx int
	// NumbIdx int
	Score int
}

type cards []card

func (c cards) Len() int {
	return len(c)
}

func (c cards) Swap(i, j int) {
	c[i], c[j] = c[j], c[i]
}

func (c cards) Less(i, j int) bool {
	return c[i].Score < c[j].Score
}

func createCardGroup() []card {
	ico := []string{"方块", "梅花", "红心", "黑桃"}
	num := []string{"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"}
	slice := []card{}
	for numIdx, numb := range num {
		// slice = append(slice, ico[0]+v, ico[1]+v, ico[2]+v, ico[3]+v)
		for icoIdx, icon := range ico {
			length := len(slice)
			preScoreMax := 0
			if length > 0 {
				preScoreMax = slice[length-1].Score
			}

			score := (numIdx+1)*(icoIdx+1) + preScoreMax
			c := card{
				Icon: icon,
				Numb: numb,
				// IconIdx: icoIdx,
				// NumbIdx: numIdx,
				Score: score,
			}
			slice = append(slice, c)
		}

	}
	slice = append(slice, card{Icon: "小王", Numb: "1", Score: slice[len(slice)-1].Score + (14 * 1)})
	slice = append(slice, card{Icon: "大王", Numb: "2", Score: slice[len(slice)-1].Score + (14 * 2)})
	return slice
}

func washCard(slice interface{}) {
	//切片乱序
	rv := reflect.ValueOf(slice)
	if rv.Type().Kind() != reflect.Slice {
		return
	}

	length := rv.Len()
	if length < 2 {
		return
	}

	swap := reflect.Swapper(slice)
	// rand.Seed(time.Now().Unix())
	for i := length - 1; i >= 0; i-- {
		j := rand.Intn(length)
		swap(i, j)
	}
}