package game

import (
	"encoding/json"
	"fmt"
	"math/rand"
	"time"
)

type Deck struct {
	Cards []Card `json:"cards"`
}

func (d *Deck) String() string {
	if d == nil {
		return "||"
	}
	return fmt.Sprintf("|%v|", d.Cards)
}

func NewDeck() *Deck {
	cards := []Card{CreateCard(0)}
	for i := 0; i < 3; i++ {
		for j := 1; j < 9; j++ {
			cards = append(cards, Card(CreateCard(j)))
		}
	}
	return &Deck{
		Cards: cards,
	}
}

func DeckFromCards(c []Card) *Deck {
	return &Deck{
		Cards: c,
	}
}

func (d *Deck) Shuffle() {
	cards := d.Cards
	r := rand.New(rand.NewSource(time.Now().UnixNano()))
	for i := range cards {
		j := r.Intn(i + 1)
		cards[i], cards[j] = cards[j], cards[i]
	}
	d.Cards = cards
}

func (d *Deck) Scry(s int) []Card {
	seen := []Card{}
	if len(d.Cards) < s {
		seen = d.Cards
		d.Cards = []Card{}
		return seen
	}
	seen = d.Cards[(len(d.Cards) - s):len(d.Cards)]
	d.Cards = d.Cards[0 : len(d.Cards)-s]
	return seen
}

func (d *Deck) Bottom(result []Card) {
	d.Cards = append(result, d.Cards...) //Should shuffle result first?
}

func (d *Deck) Size() int {
	return len(d.Cards)
}

func (d *Deck) MarshalJSON() ([]byte, error) {
	var ported []*PortableCard
	for i, _ := range d.Cards {
		ported = append(ported, d.Cards[i].Port())
	}
	return json.Marshal(ported)
}

func (d *Deck) UnmarshalJSON(data []byte) (err error) {
	var ported []PortableCard
	err = json.Unmarshal(data, &ported)
	if err != nil {
		return err
	}
	cards := []Card{}
	for _, v := range ported {
		c := NewCard(v.Type, v.ID)
		if v.Sick {
			c.Act()
		} else {
			c.Refresh()
		}
		cards = append(cards, c)
	}
	d.Cards = cards
	return
}