package game

import (
	"fmt"
	"log"
)

type eventType int

const (
	destruction eventType = iota
	eot
	sacrifice
	play
)

var EventTypes = struct {
	Destruction eventType
	Eot         eventType
	Sacrifice   eventType
	Play        eventType
}{
	Destruction: destruction,
	Eot:         eot,
	Play:        play,
}

func (e eventType) String() string {
	switch e {
	case destruction:
		return "destruction"
	case eot:
		return "eot"
	case sacrifice:
		return "sacrifice"
	case play:
		return "play"
	}

	log.Panicf("Unknown evenType", e)
	return ""
}

type Event struct {
	eventType eventType
	sources   []interface{}
}

func (e Event) String() string {
	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}
}

type Trigger interface {
	Card() *Card
	String() string
	trigger(*State, Event) ([]*TriggeredAction, bool)
}

type triggerBase struct {
	card        *Card
	condition   func(*State, Event) (bool, bool)
	resolveFunc ActionResolveFunc
	costFunc    ActionCostFunc
	desc        string
}

func (t *triggerBase) Card() *Card {
	return t.card
}

func (t *triggerBase) String() string {
	return t.desc
}

func (t *triggerBase) trigger(s *State, e Event) ([]*TriggeredAction, bool) {
	triggered, remove := t.condition(s, e)
	if !triggered {
		return nil, remove
	}

	return []*TriggeredAction{newTriggeredAction(e, t, t.resolveFunc, t.costFunc)}, remove
}