package game

import (
	"errors"
	"log"
	"net/http"
	"path"
	"strings"

	"golang.org/x/net/html"
)

type SetIdentifier int

const (
	Base SetIdentifier = iota + 1
	Magic
	Equipments
	Misc
	Nautics
	Potions
	Kraken
	Tyrant
	Exp1
)

var ErrUnknownSet = errors.New("Unknown set")

func (si SetIdentifier) String() string {
	switch si {
	case Base:
		return "base"
	case Magic:
		return "magic"
	case Equipments:
		return "equipments"
	case Misc:
		return "misc"
	case Nautics:
		return "nautics"
	case Potions:
		return "potions"
	case Kraken:
		return "kraken"
	case Tyrant:
		return "tyrant"
	case Exp1:
		return "exp1"
	}
	log.Panicf("Switch not exhausting %d", si)
	return ""
}

var Sets = struct {
	Base       SetIdentifier
	Magic      SetIdentifier
	Equipments SetIdentifier
	Misc       SetIdentifier
	Nautics    SetIdentifier
	Potions    SetIdentifier
	Kraken     SetIdentifier
	Tyrant     SetIdentifier
	Exp1       SetIdentifier
}{
	Base:       Base,
	Magic:      Magic,
	Equipments: Equipments,
	Misc:       Misc,
	Nautics:    Nautics,
	Potions:    Potions,
	Kraken:     Kraken,
	Tyrant:     Tyrant,
	Exp1:       Exp1,
}

var SetNames = map[string]SetIdentifier{
	"base":       Base,
	"magic":      Magic,
	"equipments": Equipments,
	"misc":       Misc,
	"nautics":    Nautics,
	"potions":    Potions,
	"kraken":     Kraken,
	"tyrant":     Tyrant,
	"exp1":       Exp1,
}

func (set SetIdentifier) CardPaths() []string {
	url := PROTOCOL + path.Join(BASE_URL, CARD_DATA_URL, set.String())
	log.Printf("loading %s\n", url)
	resp, err := http.Get(url)
	if err != nil {
		log.Fatal(err)
	}

	defer resp.Body.Close()

	doc, err := html.Parse(resp.Body)
	if err != nil {
		log.Fatal(err)
	}

	paths := []string{}
	var walk func(*html.Node)
	walk = func(n *html.Node) {
		if n.Type == html.ElementNode && n.Data == "a" {
			for _, a := range n.Attr {
				if a.Key == "href" {
					paths = append(paths, path.Join(set.String(), strings.TrimSuffix(a.Val, ".yml")))
					break
				}
			}
		}
		for c := n.FirstChild; c != nil; c = c.NextSibling {
			walk(c)
		}
	}
	walk(doc)
	return paths
}

func SetListToSets(setList string) ([]SetIdentifier, error) {
	sets := []SetIdentifier{}
	setList = strings.ReplaceAll(setList, " ", "")
	for s := range strings.SplitSeq(setList, ",") {
		set, found := SetNames[s]
		if found {
			sets = append(sets, set)
		} else {
			return sets, ErrUnknownSet
		}
	}
	return sets, nil
}