package cardsim

import (
	"fmt"
	"reflect"
	"sort"
	"strings"
)

// A StatsCollection contains stats.
type StatsCollection interface {
	// Stats returns all the stats in this collection. It's okay for
	// these to be copies rather than pointers. Stats will be presented
	// to the player in this order.
	Stats() []Stat
}

// A Stat is some value that can be printed as part of player status.
// It may not be an actual stored value -- it might only be calculated.
type Stat interface {
	// StatName returns the name of this stat, as displayed to the player.
	StatName() string
	// String prints the value of the stat.
	String() string // compatible with fmt.Stringer
	// Visible returns whether this stat should be displayed to the player
	// during regular gameplay. (Invisible stats are important for debugging.)
	Visible() bool
}

// Stored is a generic Stat implementation that stores a stat value and name.
// It's visible to the player.
type Stored[T any] struct {
	// Display name of this Stat.
	Name string
	// Value of this Stat. Can be overwritten.
	Value T
}

// Statname implements Stat.
func (s Stored[T]) StatName() string {
	return s.Name
}

// String implements Stat and fmt.Stringer.
func (s Stored[T]) String() string {
	return fmt.Sprint(s.Value)
}

// Visible implements Stat.
func (Stored[T]) Visible() bool {
	return true
}

// Invisible is a generic Stat implementation that stores a stat value and name.
// It's not visible to the player.
type Invisible[T any] struct {
	// Display name of this Stat.
	Name string
	// Value of this Stat. Can be overwritten.
	Value T
}

// Statname implements Stat.
func (i Invisible[T]) StatName() string {
	return i.Name
}

// String implements Stat and fmt.Stringer.
func (i Invisible[T]) String() string {
	return fmt.Sprint(i.Value)
}

// Visible implements Stat.
func (Invisible[T]) Visible() bool {
	return false
}

// StatFunc names a function as a stat visible to the player.
func StatFunc[T any](name string, f func() T) Stat {
	return statFunc[T]{
		f:       f,
		name:    name,
		visible: true,
	}
}

// InvisibleStatFunc names a function as a stat not visible to the player.
func InvisibleStatFunc[T any](name string, f func() T) Stat {
	return statFunc[T]{
		f:       f,
		name:    name,
		visible: false,
	}
}

// statFunc wraps a function as a stat.
type statFunc[T any] struct {
	f       func() T
	name    string
	visible bool
}

func (s statFunc[T]) StatName() string {
	return s.name
}

func (s statFunc[T]) String() string {
	return fmt.Sprint(s.f())
}

func (s statFunc[T]) Visible() bool {
	return s.visible
}

// ExtractStats pulls all exported Stat fields (not functions) out of a struct.
// If x cannot be resolved to a struct, it panics. It unwraps interfaces and
// follows pointers to try to find a struct.
func ExtractStats(x any) []Stat {
	v := reflect.ValueOf(x)
	for k := v.Kind(); k == reflect.Pointer || k == reflect.Interface; k = v.Kind() {
		v = v.Elem()
	}
	if v.Kind() != reflect.Struct {
		panic(fmt.Errorf("%T is not a struct", x))
	}

	var ret []Stat
	lim := v.NumField()
	for i := 0; i < lim; i++ {
		f := v.Field(i)
		if !f.CanInterface() {
			continue
		}
		x := f.Interface()
		if s, ok := x.(Stat); ok {
			ret = append(ret, s)
		}
	}
	return ret
}

// SortStats sorts the provided slice of stats in place. It puts all visible
// stats before all invisible stats, then alphabetizes (case-insensitive).
func SortStats(ss []Stat) {
	sort.Sort(statSorter(ss))
}

// statSorter implements sort.Interface for []Stat.
type statSorter []Stat

// Len implements sort.Interface.
func (s statSorter) Len() int {
	return len(s)
}

// Swap implements sort.Interface.
func (s statSorter) Swap(i, j int) {
	s[i], s[j] = s[j], s[i]
}

// Less implements sort.Interface.
func (s statSorter) Less(i, j int) bool {
	lhs, rhs := s[i], s[j]
	if lhs.Visible() != rhs.Visible() {
		return lhs.Visible()
	}
	ln, rn := strings.ToLower(lhs.StatName()), strings.ToLower(rhs.StatName())
	if ln != rn {
		return ln < rn
	}
	// Names differ only by capitalization, if that.
	return lhs.StatName() < rhs.StatName()
}