package thirteen

import (
	"fmt"
	"strings"
	"testing"
)

// 牌序- A, K, Q, J,10, 9, 8, 7, 6, 5, 4, 3, 2
// 黑桃-51,50,49,48,47,46,45,44,43,42,41,40,39
// 红桃-38,37,36,35,34,33,32,31,30,29,28,27,26
// 梅花-25,24,23,22,21,20,19,18,17,16,15,14,13
// 方片-12,11,10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0
var pokersTest = []int{12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 38,
	37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39}

var pokers2Test = append(pokersTest, pokersTest...)

func arrEqual(a, b [][]int) bool {
	if len(a) != len(b) {
		return false
	}

	for i := 0; i < len(a); i++ {
		if len(a[i]) != len(b[i]) {
			return false
		}

		cp := make([]int, len(a[i]))
		copy(cp, a[i])
		for _, v := range b[i] {
			cp = DelCards(cp, []int{v})
		}
		if len(cp) > 0 {
			return false
		}
	}
	return true
}

type item struct {
	cards  []int
	lai    []int
	target []int
}

func goResult(cards []int) string {
	buf := strings.Builder{}
	buf.WriteString("[]int{")

	for m, n := range cards {
		buf.WriteString(fmt.Sprint(n))
		if m < len(cards)-1 {
			buf.WriteString(",")
		}
	}

	buf.WriteString("}")
	return buf.String()
}

func printTest(t *testing.T, cards []int, target, result, change []int) {
	// 牌应该都在原牌堆中存在，这里检查一下
	for _, vv := range result {
		has := false
		for _, c := range cards {
			if vv == c {
				has = true
			}
		}
		if !has {
			t.Logf("%v,%v 不存在\n", PokerName(vv), vv)
		}
	}

	t.Logf("goResult: %s", goResult(result))
	t.Fatal()
}

func findFuncTest(t *testing.T, data []item, find func([]int, []int) ([]int, []int)) {
	for _, v := range data {
		result, change := find(v.cards, v.lai)
		t.Logf(" cards: %s\n", PokersShow(v.cards))
		t.Logf(" cards: %v\n", v.cards)
		t.Logf("target: %s %v\n", PokersShow(v.target), v.target)
		t.Logf("result: %s %v \n", PokersShow(result), result)
		t.Logf("change: %s %v \n\n", PokersShow(change), change)
		if !arrEqual([][]int{v.target}, [][]int{result}) {
			printTest(t, v.cards, v.target, result, change)
		}
	}
}

func TestFindMaxPairs(t *testing.T) {
	data := []item{
		{
			cards:  []int{9, 8, 7, 6, 5, 20, 19, 18, 17, 16, 32, 31, 30, 29, 28, 27, 26, 38},
			target: []int{20, 7},
		},
		{
			cards:  []int{5, 4, 3, 2, 1, 0, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13},
			target: []int{18, 5},
		},
		{
			cards:  pokers2Test,
			target: []int{51, 51},
		},
		{
			cards:  pokers2Test,
			lai:    []int{52, 53},
			target: []int{51, 51},
		},
		{
			cards:  []int{51, 0, 2, 3, 52, 53},
			lai:    []int{52, 53},
			target: []int{51, 53},
		},
		{
			cards:  []int{1, 0, 2, 3, 52, 53},
			lai:    []int{52, 53},
			target: []int{53, 52},
		},
	}
	findFuncTest(t, data, FindMaxPairs)
}

func TestFindMaxThreeAAA(t *testing.T) {
	data := []item{
		{
			cards:  pokersTest,
			target: []int{25, 38, 51},
		},
		{
			cards:  pokers2Test,
			target: []int{51, 51, 38},
		},
		{
			cards:  []int{51, 0, 2, 3, 52, 53},
			lai:    []int{52, 53},
			target: []int{51, 53, 52},
		},
		{
			cards:  []int{1, 0, 2, 3, 52, 53},
			lai:    []int{52, 53},
			target: []int{3, 53, 52},
		},
		{
			cards:  []int{1, 0, 2, 3, 52, 53, 52},
			lai:    []int{52, 53},
			target: []int{53, 52, 52},
		},
	}
	findFuncTest(t, data, FindMaxThreeAAA)
}

func TestFindMaxFlush(t *testing.T) {
	data := []item{
		{
			cards:  pokersTest,
			target: []int{47, 48, 49, 50, 51},
		},
		{
			cards:  []int{12, 3, 2, 1, 0},
			target: []int{12, 0, 1, 2, 3},
		},
		{
			cards:  pokers2Test,
			target: []int{47, 48, 49, 50, 51},
		},
		{
			cards:  []int{0, 1, 2, 3, 4, 5},
			lai:    []int{52, 53},
			target: []int{5, 4, 3, 2, 1},
		},
		{
			cards:  []int{0, 2, 4, 5, 7, 8, 52, 53},
			lai:    []int{52, 53},
			target: []int{53, 8, 7, 52, 5},
		},
		{
			cards:  []int{0, 2, 4, 8, 9, 10, 52, 53},
			lai:    []int{52, 53},
			target: []int{53, 52, 10, 9, 8},
		},
		{
			cards:  []int{51, 0, 1, 2, 4, 6, 52, 53},
			lai:    []int{52, 53},
			target: []int{6, 53, 4, 52, 2},
		},
		{
			cards:  []int{51, 0, 1, 2, 8, 9, 52, 53},
			lai:    []int{52, 53},
			target: []int{51, 53, 52, 9, 8},
		},
		{
			cards:  []int{51, 0, 1, 2, 8, 52},
			lai:    []int{52, 53},
			target: []int{52, 2, 1, 0, 51},
		},
	}
	findFuncTest(t, data, FindMaxFlush)
}

func TestFindMaxSameColors(t *testing.T) {
	data := []item{
		{
			cards:  pokersTest,
			target: []int{47, 48, 49, 50, 51},
		},
		{
			cards:  pokers2Test,
			target: []int{49, 50, 50, 51, 51},
		},
		{
			cards:  []int{39, 38, 34, 33, 30},
			target: []int{},
		},
		{
			cards:  []int{51, 0, 1, 2, 8, 52},
			lai:    []int{52, 53},
			target: []int{8, 2, 1, 0, 52},
		},
		{
			cards:  []int{51, 0, 1, 2, 22, 52, 53},
			lai:    []int{52, 53},
			target: []int{2, 1, 0, 53, 52},
		},
		{
			cards:  []int{51, 50, 1, 2, 22, 52, 53, 52},
			lai:    []int{52, 53},
			target: []int{51, 50, 53, 52, 52},
		},
	}
	findFuncTest(t, data, FindMaxSameColors)
}

func TestFindMaxGourdCards(t *testing.T) {
	data := []item{
		{
			cards:  pokersTest,
			target: []int{25, 37, 38, 50, 51},
		},
		{
			cards:  pokers2Test,
			target: []int{51, 51, 38, 38, 25},
		},
		{
			cards:  []int{51, 50, 1, 2, 22, 52, 53, 52},
			lai:    []int{52, 53},
			target: []int{51, 53, 52, 50, 52},
		},
		{
			cards:  []int{51, 12, 50, 1, 2, 22, 52, 53, 52},
			lai:    []int{52, 53},
			target: []int{51, 12, 53, 52, 52},
		},
	}
	findFuncTest(t, data, FindMaxGourdCards)
}

func TestFindMaxFourAAAA(t *testing.T) {
	data := []item{
		{
			cards:  pokersTest,
			target: []int{12, 25, 38, 51},
		},
		{
			cards:  pokers2Test,
			target: []int{51, 51, 38, 38},
		},
		{
			cards:  []int{51, 12, 50, 1, 2, 22, 52, 53, 52},
			lai:    []int{52, 53},
			target: []int{51, 12, 53, 52},
		},
		{
			cards:  []int{12, 50, 1, 2, 22, 52, 53, 52},
			lai:    []int{52, 53},
			target: []int{12, 53, 52, 52},
		},
		{
			cards:  []int{50, 1, 2, 22, 52, 53, 52, 52},
			lai:    []int{52, 53},
			target: []int{53, 52, 52, 52},
		},
		{
			cards:  []int{50, 1, 2, 22, 52, 53, 52},
			lai:    []int{52, 53},
			target: []int{50, 53, 52, 52},
		},
	}
	findFuncTest(t, data, FindMaxFourAAAA)
}

func TestFindMaxSameColorFlush(t *testing.T) {
	data := []item{
		{
			cards:  pokersTest,
			target: []int{47, 48, 49, 50, 51},
		},
		{
			cards:  pokers2Test,
			target: []int{47, 48, 49, 50, 51},
		},
		{
			cards:  []int{50, 1, 2, 22, 52, 53, 52},
			lai:    []int{52, 53},
			target: []int{53, 52, 52, 2, 1},
		},
		{
			cards:  []int{0, 1, 2, 4, 9, 52},
			lai:    []int{52, 53},
			target: []int{4, 52, 2, 1, 0},
		},
		{
			cards:  []int{12, 1, 2, 3, 9, 52},
			lai:    []int{52, 53},
			target: []int{3, 2, 1, 52, 12},
		},
	}
	findFuncTest(t, data, FindMaxSameColorFlush)
}

func TestFindMaxFive(t *testing.T) {
	data := []item{
		{
			cards:  pokersTest,
			target: []int{},
		},
		{
			cards:  pokers2Test,
			target: []int{51, 51, 38, 38, 25},
		},
		{
			cards:  []int{50, 1, 2, 22, 52, 53, 52},
			lai:    []int{52, 53},
			target: []int{},
		},
		{
			cards:  []int{51, 51, 51, 51, 12, 52},
			lai:    []int{52, 53},
			target: []int{51, 51, 51, 51, 12},
		},
	}
	findFuncTest(t, data, FindMaxFive)
}