package main

import (
	"encoding/json"
	"flag"
	"fmt"
	"io/ioutil"
	"log"
	"math/rand"
	"os"
	"strings"
	"time"
)

func main() {
	cards_f := flag.String("f", "../cards.json", "Path to json file with all cards.")
	count_f := flag.Int("c", 10, "Number of cards.")
	d_sets_f := flag.String("d", "", "Do not play with these sets. (comma separated)")
	o_sets_f := flag.String("o", "", "Only play with these sets. (comma separated)")
	list_f := flag.Bool("l", false, "List all available sets.")
	expired_f := flag.Bool("v1", false, "Play with (officially removed) cards (from the first edition)")
	event_f := flag.Bool("e", false, "Pick only events.")
	landmark_f := flag.Bool("v", false, "Pick only landmarks.")

	flag.Parse()

	d_sets := strings.Split(*d_sets_f, ",")
	sets := strings.Split(*o_sets_f, ",")

	raw, err := ioutil.ReadFile(*cards_f)
	if err != nil {
		log.Fatal(err)
	}

	var cards []Card
	var bane_card_needed bool
	var bane_card Card
	picked := make(map[string]bool)
	json.Unmarshal(raw, &cards)

	if *list_f {
		fmt.Println("List all available Editions:")
		printed := make(map[string]bool)
		for _, v := range cards {
			if printed[v.Set_de] {
				continue
			}
			fmt.Printf("  Name (en/de): '%s' / '%s'\n", v.Set, v.Set_de)
			printed[v.Set_de] = true
		}
		return
	}

	for i := 0; i < *count_f; i++ {

		v := get_card(cards, picked, sets, d_sets, *expired_f, *event_f, *landmark_f)
		picked[v.Name] = true

		if v.Name_de == "Junge Hexe" {
			bane_card_needed = true
			for {
				bane_card = get_card(cards, picked, sets, d_sets, *expired_f, *event_f, *landmark_f)
				if bane_card.Cost.Coin == 2 || bane_card.Cost.Coin == 3 {
					picked[bane_card.Name] = true
					break
				}
			}
		}
		fmt.Printf("'%s' aus '%s' | Kosten: %d Münzen, %d Tränke, %d Schulden\n", v.Name_de, v.Set_de, v.Cost.Coin, v.Cost.Potion, v.Cost.Debt)
		if bane_card_needed {
			fmt.Printf("    Bannkarte: '%s' aus '%s' | Kosten: %d Münzen, %d Tränke, %d Schulden\n", bane_card.Name_de, bane_card.Set_de, bane_card.Cost.Coin, bane_card.Cost.Potion, bane_card.Cost.Debt)
			bane_card_needed = false
		}
	}
}

func get_card(cards []Card, picked map[string]bool, sets []string, d_sets []string, v1 bool, event, landmark bool) Card {
	for {

		r := rand.New(rand.NewSource(time.Now().UnixNano()))
		rndm := r.Int() % len(cards)

		if event && (cards[rndm].Type != "Event") {
			continue
		}
		if landmark && (cards[rndm].Type != "Landmark") {
			continue
		}

		if !event && !landmark && !cards[rndm].IsKingdom {
			continue
		}
		if v1 {
			// play with removed cards from base v1
			if cards[rndm].IsEdition2 {
				continue
			}
		} else {
			if cards[rndm].IsEdition1 {
				continue
			}
		}
		if picked[cards[rndm].Name] {
			continue
		}
		if len(d_sets) > 0 && d_sets[0] != "" {
			_set := setExists(d_sets, cards)
			if "" != _set {
				fmt.Println("Error: This set does not exists. (" + _set + ")")
				os.Exit(1)
			}
			if stringInSlice(cards[rndm].Set, d_sets) || stringInSlice(cards[rndm].Set_de, d_sets) {
				continue
			} else {
				return cards[rndm]
			}
		}
		if len(sets) > 0 && sets[0] != "" {
			_set := setExists(sets, cards)
			if "" != _set {
				fmt.Println("Error: This set does not exists. (" + _set + ")")
				os.Exit(1)
			}
			if stringInSlice(cards[rndm].Set, sets) || stringInSlice(cards[rndm].Set_de, sets) {
				return cards[rndm]
			} else {
				continue
			}
		}
		return cards[rndm]
	}
	return Card{}
}

func stringInSlice(a string, list []string) bool {
	a = strings.ToLower(a)
	for _, b := range list {
		b = strings.TrimSpace(strings.ToLower(b))
		if b == a {
			return true
		}
	}
	return false
}

func setExists(sets []string, cards []Card) string {
	matched := make(map[string]bool)
	for _, set := range sets {
		for _, v := range cards {
			if strings.ToLower(set) == strings.ToLower(v.Set_de) || strings.ToLower(set) == strings.ToLower(v.Set) {
				matched[set] = true
			}
		}
	}
	for _, set := range sets {
		if !matched[set] {
			return set
		}
	}
	return ""

}