package game

import (
	"log"
	"math/rand"
	"strconv"
	"strings"
)

type Deck struct {
	PileOfCardsBase
}

func NewDeck() *Deck {
	d := Deck{PileOfCardsBase{[]*Card{}}}
	return &d
}

func (d *Deck) Shuffle(r *rand.Rand) {
	r.Shuffle(d.Size(), func(i, j int) {
		d.cards[i], d.cards[j] = d.cards[j], d.cards[i]
	})
}

func (d *Deck) Draw(amount int) []*Card {
	if d.Size() < amount {
		drawn := d.cards
		d.cards = []*Card{}
		return drawn
	}

	drawn := d.cards[0:amount]
	d.cards = d.cards[amount:]
	return drawn
}

func (d *Deck) DrawOne() *Card {
	drawn := d.Draw(1)
	if len(drawn) == 0 {
		return nil
	}
	return drawn[0]
}

func NewDeckFrom(cards PileOfCards) *Deck {
	d := NewDeck()
	cards.MoveInto(d)
	return d
}

func NewDeckFromCardPaths(cardPaths []string) *Deck {
	d := NewDeck()
	for _, cardPath := range cardPaths {
		card := NewCard(cardPath)
		d.AddCard(card)
	}
	return d
}

func NewDeckFromDeckList(deckList string) *Deck {
	cardPaths := []string{}

	// trim last trailing newline
	deckList = strings.Trim(deckList, "\n")

	lines := strings.SplitSeq(deckList, "\n")
	for line := range lines {
		tokens := strings.SplitN(line, " ", 2)
		cardPath := tokens[1]
		amount, err := strconv.Atoi(tokens[0])
		if err != nil {
			log.Fatal(err)
		}

		for range amount {
			cardPaths = append(cardPaths, cardPath)
		}
	}

	return NewDeckFromCardPaths(cardPaths)
}

func NewRandomDeck(n int, sets []SetIdentifier) *Deck {
	deck := NewDeck()
	pool := NewDeck()
	for _, set := range sets {
		NewDeckFromCardPaths(set.CardPaths()).MoveInto(pool)
	}

	cards := NewRandomPackFromPool(pool, n)
	cards.MoveInto(deck)
	return deck
}