package game

import (
	"fmt"

	"muhq.space/muhqs-game/go/log"
	"muhq.space/muhqs-game/go/utils"
)

type eventType int

const (
	destruction eventType = iota
	eot
	sacrifice
	play
	target
	etb
	damageDealt
	shuffle
	declaredAction
	resolvedAction
	discard
	phaseChange
)

var EventTypes = struct {
	Destruction    eventType
	Eot            eventType
	Sacrifice      eventType
	Play           eventType
	Target         eventType
	Etb            eventType
	DamageDealt    eventType
	Shuffle        eventType
	DeclaredAction eventType
	ResolvedAction eventType
	Discard        eventType
	PhaseChange    eventType
}{
	Destruction:    destruction,
	Eot:            eot,
	Sacrifice:      sacrifice,
	Play:           play,
	Target:         target,
	Etb:            etb,
	DamageDealt:    damageDealt,
	Shuffle:        shuffle,
	DeclaredAction: declaredAction,
	ResolvedAction: resolvedAction,
	Discard:        discard,
	PhaseChange:    phaseChange,
}

func (e eventType) String() string {
	switch e {
	case destruction:
		return "destruction"
	case eot:
		return "eot"
	case sacrifice:
		return "sacrifice"
	case play:
		return "play"
	case target:
		return "target"
	case etb:
		return "etb"
	case damageDealt:
		return "damageDealt"
	case shuffle:
		return "shuffle"
	case declaredAction:
		return "declaredAction"
	case resolvedAction:
		return "resolvedAction"
	case discard:
		return "discard"
	case phaseChange:
		return "phaseChange"
	}

	log.Panicf("Unknown eventType: %d", e)
	return ""
}

type Event struct {
	eventType eventType
	sources   []any
	affected  []any
}

func (e Event) String() string {
	if e.eventType == phaseChange {
		return fmt.Sprintf("%s", e.sources[0])
	}

	if len(e.sources) == 0 {
		return e.eventType.String()
	}

	return fmt.Sprintf("%v:%v", e.sources, e.eventType)
}

func newEotEvent() Event {
	return Event{eventType: eot}
}

func newTargetEvent(source any, targets *Targets) Event {
	affected := make([]any, 0, len(targets.ts))
	for _, t := range targets.ts {
		affected = append(affected, t.sel...)
	}
	return Event{eventType: target, sources: []any{source}, affected: affected}
}

func newShuffleEvent(p *Player, affected []PileOfCards) Event {
	return Event{
		eventType: shuffle,
		sources:   []any{p},
		affected:  utils.TypedSliceToInterfaceSlice(affected),
	}
}

func newDeclaredActionEvent(action Action) Event {
	return Event{eventType: declaredAction, sources: []any{action}}
}

func newResolvedActionEvent(action Action, err error) Event {
	return Event{
		eventType: resolvedAction,
		affected:  []any{action, err},
	}
}

func newPhaseChangeEvent(old, next PhaseType) Event {
	return Event{eventType: phaseChange, sources: []any{old}, affected: []any{next}}
}

func (s *LocalState) fireEvent(e Event) {
	log.Game(e)
	s.events = append(s.events, e)
}