package subex

// TODO: Simplify this implementation by combining similar states into one type
// e.g. Combine all of the copy states into a single type that has a filter function

import (
	"main/walk"
)

// A state of execution for the transducer
type SubexState interface {
	// Eat a Atom and transition to any number of new states
	eat(aux auxiliaryState, char walk.Edible) []SubexBranch
	// Find accepting states reachable through epsilon transitions and return their outputs
	accepting(aux auxiliaryState) []OutputStack
}

// Try first, if it fails then try second
type SubexGroupState struct {
	first, second SubexState
}
func (state SubexGroupState) eat(aux auxiliaryState, char walk.Edible) []SubexBranch {
	otherAux := aux.cloneStore()
	return append(state.first.eat(aux, char), state.second.eat(otherAux, char)...)
}
func (state SubexGroupState) accepting(aux auxiliaryState) []OutputStack {
	otherAux := aux.cloneStore()
	return append(state.first.accepting(aux), state.second.accepting(otherAux)...)
}

type SubexCopyState struct {
	next SubexState
	filter valueFilter
}
func (state SubexCopyState) eat(aux auxiliaryState, edible walk.Edible) []SubexBranch {
	value, isValue := edible.(walk.Value)
	if !isValue || !state.filter.valueFilter(value) {
		return nil
	}
	return []SubexBranch{{
		state: state.next,
		aux: aux.topAppend(walk.ValueList{value}),
	}}
}
func (state SubexCopyState) accepting(aux auxiliaryState) []OutputStack {
	return nil
}

type SubexCopyRuneState struct {
	next SubexState
	filter runeFilter
}
func (state SubexCopyRuneState) eat(aux auxiliaryState, edible walk.Edible) []SubexBranch {
	r, isRune := edible.(walk.StringRuneAtom)
	if !isRune || !state.filter.runeFilter(r) {
		return nil
	}
	return []SubexBranch{{
		state: state.next,
		aux: aux.topAppend(walk.RuneList{r}),
	}}
}
func (state SubexCopyRuneState) accepting(aux auxiliaryState) []OutputStack {
	return nil
}

// Just pushes to the OutputStack and hands over to the next state
// Used to capture the output of the state being handed over to
type SubexCaptureBeginState struct {
	next SubexState
}
func (state SubexCaptureBeginState) eat(aux auxiliaryState, char walk.Edible) []SubexBranch {
	return state.next.eat(aux.pushOutput(walk.ValueList{}), char)
}
func (state SubexCaptureBeginState) accepting(aux auxiliaryState) []OutputStack {
	return state.next.accepting(aux.pushOutput(walk.ValueList{}))
}
func (state SubexCaptureBeginState) String() string {
	return "CaptureBeginState"
}

type SubexCaptureRunesBeginState struct {
	next SubexState
}
func (state SubexCaptureRunesBeginState) eat(aux auxiliaryState, char walk.Edible) []SubexBranch {
	return state.next.eat(aux.pushOutput(walk.RuneList{}), char)
}
func (state SubexCaptureRunesBeginState) accepting(aux auxiliaryState) []OutputStack {
	return state.next.accepting(aux.pushOutput(walk.RuneList{}))
}

// Discard the top of the OutputStack
type SubexDiscardState struct {
	next SubexState
}
func (state SubexDiscardState) eat(aux auxiliaryState, char walk.Edible) []SubexBranch {
	_, newAux := aux.popOutput()
	return state.next.eat(newAux, char)
}
func (state SubexDiscardState) accepting(aux auxiliaryState) []OutputStack {
	_, newAux := aux.popOutput()
	return state.next.accepting(newAux)
}

// Pop the top of the OutputStack which contains the stuff outputted since the start of the store
// This outputted data gets stored in a slot
type SubexStoreEndState struct {
	slot int
	next SubexState
}
func (state SubexStoreEndState) eat(aux auxiliaryState, char walk.Edible) []SubexBranch {
	toStore, aux := aux.popOutput()
	aux = aux.withValue(state.slot, toStore)
	return state.next.eat(aux, char)
}
func (state SubexStoreEndState) accepting(aux auxiliaryState) []OutputStack {
	toStore, aux := aux.popOutput()
	aux = aux.withValue(state.slot, toStore)
	return state.next.accepting(aux)
}

// A part of an output literal, either an Atom or a slot from which to load
type OutputContent interface {
	// Given the current store, return the []Atom produced by the TransducerOutput
	build(Store) walk.ValueList
}

// An OutputContent which is just an Atom literal
type OutputAtomLiteral struct {
	atom walk.Value
}
func (replacement OutputAtomLiteral) build(store Store) walk.ValueList {
	return walk.ValueList{replacement.atom}
}

// An OutputContent which is a slot that is loaded from
type OutputLoad struct {
	slot int
}
func (replacement OutputLoad) build(store Store) walk.ValueList {
	values, isValues := store[replacement.slot].(walk.ValueList)
	if !isValues {
		panic("Tried to output non-values list")
	}
	return values
}

// Don't read in anything, just output the series of data and slots specified
type SubexOutputState struct {
	content []OutputContent
	next SubexState
}
// Given a store, return what is outputted by an epsilon transition from this state
// TODO: separate into buildValues and buildRunes
func (state SubexOutputState) build(store Store) walk.ValueList {
	var result walk.ValueList
	for _, part := range state.content {
		result = append(result, part.build(store)...)
	}
	return result
}
func (state SubexOutputState) eat(aux auxiliaryState, char walk.Edible) []SubexBranch {
	content := state.build(aux.store)
	nextStates := state.next.eat(aux.topAppend(content), char)
	return nextStates
}
func (state SubexOutputState) accepting(aux auxiliaryState) []OutputStack {
	content := state.build(aux.store)
	outputStacks := state.next.accepting(aux.topAppend(content))
	return outputStacks
}

// A final state, transitions to nothing but is accepting
type SubexNoneState struct {}
func (state SubexNoneState) eat(aux auxiliaryState, char walk.Edible) []SubexBranch {
	return nil
}
func (state SubexNoneState) accepting(aux auxiliaryState) []OutputStack {
	return []OutputStack{aux.outputStack}
}

// A dead end state, handy for making internals work nicer but technically redundant
type SubexDeadState struct {}
func (state SubexDeadState) eat(aux auxiliaryState, char walk.Edible) []SubexBranch {
	return nil
}
func (state SubexDeadState) accepting (aux auxiliaryState) []OutputStack {
	return nil
}

// Read in an Atom and apply a map to generate an Atom to output
// If the input isn't in the map transition to nothing
// TODO
// type SubexRangeState struct {
// 	parts map[walk.Atom]walk.Atom
// 	next SubexState
// }
// func (state SubexRangeState) eat(aux auxiliaryState, char walk.Atom) []SubexBranch {
// 	out, exists := state.parts[char]
// 	if !exists {
// 		return nil
// 	} else {
// 		return []SubexBranch{{
// 			state: state.next,
// 			outputStack: topAppend(outputStack, []walk.Atom{out}),
// 			store: store,
// 		}}
// 	}
// }
// func (state SubexRangeState) accepting(aux auxiliaryState) []OutputStack {
// 	return nil
// }


type SubexArithmeticEndState struct {
	next SubexState
	calculate func(walk.ValueList) (walk.ValueList, error)
}
func (state SubexArithmeticEndState) eat(aux auxiliaryState, char walk.Edible) []SubexBranch {
	toCompute, aux := aux.popOutput()
	values, isValues := toCompute.(walk.ValueList)
	if !isValues {
		panic("Tried to do arithmetic on non-values")
	}
	result, err := state.calculate(values)
	if err != nil {
		return nil
	}
	return state.next.eat(aux.topAppend(result), char)
}
func (state SubexArithmeticEndState) accepting(aux auxiliaryState) []OutputStack {
	toCompute, aux := aux.popOutput()
	values, isValues := toCompute.(walk.ValueList)
	if !isValues {
		panic("Tried to do arithmetic on non-values")
	}
	result, err := state.calculate(values)
	if err != nil {
		return nil
	}
	return state.next.accepting(aux.topAppend(result))
}

type SubexDiscardTerminalState struct {
	terminal walk.Terminal
	next SubexState
}
func (state SubexDiscardTerminalState) eat(aux auxiliaryState, edible walk.Edible) []SubexBranch {
	if edible != state.terminal {
		return nil
	}
	return []SubexBranch{{
		state: state.next,
		aux: aux,
	}}
}
func (state SubexDiscardTerminalState) accepting(aux auxiliaryState) []OutputStack {
	return nil
}

type SubexConstructArrayState struct {
	next SubexState
}
func (state SubexConstructArrayState) eat(aux auxiliaryState, edible walk.Edible) []SubexBranch {
	outputs, aux := aux.popOutput()
	values, isValues := outputs.(walk.ValueList)
	if !isValues {
		panic("Tried to create an array from non-values")
	}
	array := walk.ArrayStructure(values)
	return state.next.eat(aux.topAppend(walk.ValueList{array}), edible)
}
func (state SubexConstructArrayState) accepting(aux auxiliaryState) []OutputStack {
	outputs, aux := aux.popOutput()
	values, isValues := outputs.(walk.ValueList)
	if !isValues {
		panic("Tried to create an array from non-values")
	}
	array := walk.ArrayStructure(values)
	return state.next.accepting(aux.topAppend(walk.ValueList{array}))
}

type SubexConstructStringState struct {
	next SubexState
}
func (state SubexConstructStringState) eat(aux auxiliaryState, edible walk.Edible) []SubexBranch {
	outputs, aux := aux.popOutput()
	runes, isRunes := outputs.(walk.RuneList)
	if !isRunes {
		panic("Tried to create a string from non-runes")
	}
	s := walk.StringStructure(runes)
	return state.next.eat(aux.topAppend(walk.ValueList{s}), edible)
}
func (state SubexConstructStringState) accepting(aux auxiliaryState) []OutputStack {
	outputs, aux := aux.popOutput()
	runes, isRunes := outputs.(walk.RuneList)
	if !isRunes {
		panic("Tried to create a string from non-runes")
	}
	s := walk.StringStructure(runes)
	return state.next.accepting(aux.topAppend(walk.ValueList{s}))
}

type SubexIncrementNestState struct {
	next SubexState
}
func (state SubexIncrementNestState) eat(aux auxiliaryState, edible walk.Edible) []SubexBranch {
	return state.next.eat(aux.incNest(), edible)
}
func (state SubexIncrementNestState) accepting(aux auxiliaryState) []OutputStack {
	return state.next.accepting(aux.incNest())
}
func (state SubexIncrementNestState) String() string {
	return "IncrementNestState"
}

type SubexDecrementNestState struct {
	next SubexState
}
func (state SubexDecrementNestState) eat(aux auxiliaryState, edible walk.Edible) []SubexBranch {
	return state.next.eat(aux.decNest(), edible)
}
func (state SubexDecrementNestState) accepting(aux auxiliaryState) []OutputStack {
	return state.next.accepting(aux.decNest())
}