package subex

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(store Store, outputStack OutputStack, char walk.Atom) []SubexBranch
	// Find accepting states reachable through epsilon transitions and return their outputs
	accepting(store Store, outputStack OutputStack) []OutputStack
}

// Try first, if it fails then try second
type SubexGroupState struct {
	first, second SubexState
}
func (state SubexGroupState) eat(store Store, outputStack OutputStack, char walk.Atom) []SubexBranch {
	otherStore := store.clone()
	return append(state.first.eat(store, outputStack, char), state.second.eat(otherStore, outputStack, char)...)
}
func (state SubexGroupState) accepting(store Store, outputStack OutputStack) []OutputStack {
	return append(state.first.accepting(store, outputStack), state.second.accepting(store, outputStack)...)
}

// 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(store Store, outputStack OutputStack, char walk.Atom) []SubexBranch {
	return state.next.eat(store, outputStack.push(nil), char)
}
func (state SubexCaptureBeginState) accepting(store Store, outputStack OutputStack) []OutputStack {
	return state.next.accepting(store, outputStack.push(nil))
}

// Discard the top of the OutputStack
type SubexDiscardState struct {
	next SubexState
}
func (state SubexDiscardState) eat(store Store, outputStack OutputStack, char walk.Atom) []SubexBranch {
	_, newStack := outputStack.pop()
	return state.next.eat(store, newStack, char)
}
func (state SubexDiscardState) accepting(store Store, outputStack OutputStack) []OutputStack {
	_, newStack := outputStack.pop()
	return state.next.accepting(store, newStack)
}

// 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 rune
	next SubexState
}
func (state SubexStoreEndState) eat(store Store, outputStack OutputStack, char walk.Atom) []SubexBranch {
	toStore, newStack := outputStack.pop()
	return state.next.eat(store.withValue(state.slot, toStore), newStack, char)
}
func (state SubexStoreEndState) accepting(store Store, outputStack OutputStack) []OutputStack {
	toStore, newStack := outputStack.pop()
	return state.next.accepting(store.withValue(state.slot, toStore), newStack)
}

// 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.Atom
}

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

// An OutputContent which is a slot that is loaded from
type OutputLoad struct {
	slot rune
}
func (replacement OutputLoad) build(store Store) []walk.Atom {
	return store[replacement.slot]
}

// 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
func (state SubexOutputState) build(store Store) []walk.Atom {
	var result []walk.Atom
	for _, part := range state.content {
		result = append(result, part.build(store)...)
	}
	return result
}
func (state SubexOutputState) eat(store Store, outputStack OutputStack, char walk.Atom) []SubexBranch {
	content := state.build(store)
	nextStates := state.next.eat(store, topAppend(outputStack, content), char)
	return nextStates
}
func (state SubexOutputState) accepting(store Store, outputStack OutputStack) []OutputStack {
	content := state.build(store)
	outputStacks := state.next.accepting(store, topAppend(outputStack, content))
	return outputStacks
}

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

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

// Read in a specific Atom and output it
type SubexCopyAtomState struct {
	atom walk.Atom
	next SubexState
}
func (state SubexCopyAtomState) eat(store Store, outputStack OutputStack, char walk.Atom) []SubexBranch {
	// TODO can I compare Atom values with == ?
	if char == state.atom {
		return []SubexBranch{{
			state: state.next,
			outputStack: topAppend(outputStack, []walk.Atom{char}),
			store: store,
		}}
	}
	return nil
}
func (state SubexCopyAtomState) accepting(store Store, outputStack OutputStack) []OutputStack {
	return nil
}

// Read in a boolean atom and output it
type SubexCopyBoolState struct {
	next SubexState
}
func (state SubexCopyBoolState) eat(store Store, outputStack OutputStack, char walk.Atom) []SubexBranch {
	_, isBool := char.(walk.ValueBool)
	if isBool {
		return []SubexBranch{{
			state: state.next,
			outputStack: topAppend(outputStack, []walk.Atom{char}),
			store: store,
		}}
	}
	return nil
}
func (state SubexCopyBoolState) accepting(store Store, outputStack OutputStack) []OutputStack {
	return nil
}

// Read in a number atom and output it
type SubexCopyNumberState struct {
	next SubexState
}
func (state SubexCopyNumberState) eat(store Store, outputStack OutputStack, char walk.Atom) []SubexBranch {
	_, isNumber := char.(walk.ValueNumber)
	if isNumber {
		return []SubexBranch{{
			state: state.next,
			outputStack: topAppend(outputStack, []walk.Atom{char}),
			store: store,
		}}
	}
	return nil
}
func (state SubexCopyNumberState) accepting(store Store, outputStack OutputStack) []OutputStack {
	return nil
}

// Read in a string atom and output it
type SubexCopyStringAtomState struct {
	next SubexState
}
func (state SubexCopyStringAtomState) eat(store Store, outputStack OutputStack, char walk.Atom) []SubexBranch {
	_, isStringAtom := char.(walk.StringAtom)
	if isStringAtom {
		return []SubexBranch{{
			state: state.next,
			outputStack: topAppend(outputStack, []walk.Atom{char}),
			store: store,
		}}
	}
	return nil
}
func (state SubexCopyStringAtomState) accepting(store Store, outputStack OutputStack) []OutputStack {
	return nil
}

// Read in an atom and copy it out as long as it is not part of a string
type SubexCopyNonStringAtomState struct {
	next SubexState
}
func (state SubexCopyNonStringAtomState) eat(store Store, outputStack OutputStack, char walk.Atom) []SubexBranch {
	_, isStringAtom := char.(walk.StringAtom)
	_, isStringTerminal := char.(walk.StringTerminal)
	if isStringAtom || isStringTerminal {
		return nil
	}
	return []SubexBranch{{
		state: state.next,
		outputStack: topAppend(outputStack, []walk.Atom{char}),
		store: store,
	}}
}
func (state SubexCopyNonStringAtomState) accepting(store Store, outputStack OutputStack) []OutputStack {
	return nil
}

// Read in any Atom and output it
type SubexCopyAnyState struct {
	next SubexState
}
func (state SubexCopyAnyState) eat(store Store, outputStack OutputStack, char walk.Atom) []SubexBranch {
	return []SubexBranch{{
		state: state.next,
		outputStack: topAppend(outputStack, []walk.Atom{char}),
		store: store,
	}}
}
func (state SubexCopyAnyState) accepting(store Store, outputStack OutputStack) []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
type SubexRangeState struct {
	parts map[walk.Atom]walk.Atom
	next SubexState
}
func (state SubexRangeState) eat(store Store, outputStack OutputStack, 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(store Store, outputStack OutputStack) []OutputStack {
	return nil
}


type SubexArithmeticEndState struct {
	next SubexState
	calculate func([]walk.Atom) ([]walk.Atom, error)
}
func (state SubexArithmeticEndState) eat(store Store, outputStack OutputStack, char walk.Atom) []SubexBranch {
	toCompute, newStack := outputStack.pop()
	result, err := state.calculate(toCompute)
	if err != nil {
		return nil
	}
	return state.next.eat(store, topAppend(newStack, result), char)
}
func (state SubexArithmeticEndState) accepting(store Store, outputStack OutputStack) []OutputStack {
	toCompute, newStack := outputStack.pop()
	result, err := state.calculate(toCompute)
	if err != nil {
		return nil
	}
	return state.next.accepting(store, topAppend(newStack, result))
}