module fsm

pub type EventHandlerFn = fn (receiver voidptr, from string, to string)

pub type ConditionFn = fn (receiver voidptr, from string, to string) bool

fn dummy_event_handler_fn(_ voidptr, _ string, _ string) {
}

fn dummy_condition_fn(_ voidptr, _ string, _ string) bool {
    return true
}

struct State {
mut:
    entry_handler EventHandlerFn = dummy_event_handler_fn
    run_handler   EventHandlerFn = dummy_event_handler_fn
    exit_handler  EventHandlerFn = dummy_event_handler_fn
}

struct Transition {
mut:
    to                string
    condition_handler ConditionFn = dummy_condition_fn
}

pub struct StateMachine {
mut:
    states        map[string]State
    transitions   map[string][]Transition
    current_state string
}

// StateMachine static method returns a new StateMachine instance.
pub fn new() StateMachine {
    return StateMachine{}
}

// set_state sets the current state of the state machine to the given state by `name`.
pub fn (mut s StateMachine) set_state(name string) ! {
    if name in s.states {
        s.current_state = name
    } else {
        return error('unknown state: ${name}')
    }
}

// get_state returns the current state of the state machine.
pub fn (mut s StateMachine) get_state() string {
    return s.current_state
}

// add_state adds a new state to the state machine.
// It takes the `name` of the state, and three event handlers: `entry`, `run`, and `exit`.
pub fn (mut s StateMachine) add_state(name string, entry EventHandlerFn, run EventHandlerFn, exit EventHandlerFn) {
    s.states[name] = State{
        entry_handler: entry
        run_handler:   run
        exit_handler:  exit
    }
    if s.states.len == 1 {
        s.current_state = name
    }
}

// add_transition adds a new transition to the state machine.
// It takes the `from` and `to` states, and a condition handler.
pub fn (mut s StateMachine) add_transition(from string, to string, condition_handler ConditionFn) {
    t := Transition{
        to:                to
        condition_handler: condition_handler
    }
    if from in s.transitions {
        s.transitions[from] << t
        return
    }
    s.transitions[from] = [t]
}

// run runs the state machine. It takes a `receiver` argument that is passed to the event handlers.
pub fn (mut s StateMachine) run(receiver voidptr) ! {
    from_state := s.current_state
    mut to_state := s.current_state
    if transitions := s.transitions[s.current_state] {
        for transition in transitions {
            if transition.condition_handler(receiver, from_state, transition.to) {
                s.change_state(receiver, transition.to)
                to_state = transition.to
                break
            }
        }
    } else {
        s.states[s.current_state].run_handler(receiver, from_state, to_state)
        return error('no more transitions')
    }
    s.states[s.current_state].run_handler(receiver, from_state, to_state)
}

fn (mut s StateMachine) change_state(receiver voidptr, newstate string) {
    s.states[s.current_state].exit_handler(receiver, s.current_state, newstate)
    s.states[newstate].entry_handler(receiver, s.current_state, newstate)
    s.current_state = newstate
}