package hanabi

import "core:fmt"
import "core:math/rand"

COLORS :: enum {
	RED,
	GREEN,
	WHITE,
	BLUE,
	YELLOW,
	RAINBOW,
}

Card :: struct {
	value: int,
	color: COLORS,
}

VALUES: []int : {1, 1, 1, 2, 2, 3, 3, 4, 4, 5}

Player :: struct {
	hand: [dynamic]Card,
}

Game :: struct {
	num_players: int,
	hint_tokens: int,
	lives_left:  int,
	players:     [dynamic]Player,
	deck:        [dynamic]Card,
}

hand_size :: proc(g: Game) -> int {
	return g.num_players <= 3 ? 5 : 4
}

create_deck :: proc() -> (deck: [dynamic]Card) {
	for c in COLORS {
		for v in VALUES {
			append(&deck, Card{v, c})
		}
	}
	rand.shuffle(deck[:])
	return
}

create_player :: proc(g: ^Game) -> (p: Player) {
	for i in 0 ..< hand_size(g^) {
		append(&p.hand, pop(&g.deck))
	}
	return
}

create_game :: proc(hint_tokens, lives_left, num_players: int) -> (s: Game) {
	assert(num_players >= 2 && num_players <= 5)
	s.num_players = num_players
	s.hint_tokens = hint_tokens
	s.lives_left = lives_left
	s.deck = create_deck()
	for i in 0 ..< num_players {
		append(&s.players, create_player(&s))
	}
	return
}

delete_game :: proc(g: ^Game) {
	delete(g.deck)
	for &p in g.players {
		delete(p.hand)
	}
	delete(g.players)
}

print_game :: proc(g: Game) {
	for p in g.players {
		fmt.println("---")
		for c in p.hand {
			fmt.println(c.value, c.color)
		}
	}
	// fmt.println("---")
	// for c in s.deck {
	// 	fmt.println(c.value, c.color)
	// }
	// fmt.println("---")
	// fmt.println(len(s.deck))
}