package fsm

import (

    "log"

)

type EvtIf interface {

    GetEvtType() string

}

type Action interface {

    //doAction(evt EvtIf, srcState *State, dstState *State)

    doAction(evt EvtIf)

}

type Transition struct {

    dstState *State

    action   Action

}

type State struct {

    name          string

    isEnd         bool

    transitionTbl map[string]Transition

}

type fsm struct {

    InstId        uint64

    version       uint32

    startPoint    *State

    current       *State

    transitionLog []Transition

    stateTbl      map[string]*State

}

//func StartStateMachine(transtionLog []Transition) *fsm {

//}

//func ReplyStateMachine(transtionLog []Transition) *fsm {

//}

//func Save() *fsm {

//}

//func Load() *fms {

//}

func NewState(name string, end bool) *State {

    return &State{name, end, map[string]Transition{}}

}

func (this *State) GetName() string {

    return this.name

}

func (this *State) InterestInEvt(evt EvtIf) bool {

    if evt == nil {

        return false

    }

    _, exists := this.transitionTbl[evt.GetEvtType()]

    return exists

}

func (this *State) AddTransition(evt EvtIf, dst *State, action Action) {

    if evt == nil || dst == nil || action == nil {

        log.Fatal("AddTransition error, parameter invalid!")

    }

    _, exists := this.transitionTbl[evt.GetEvtType()]

    if exists {

        log.Fatal("AddTransition error,EvtIf exist")

    }

    this.transitionTbl[evt.GetEvtType()] = NewTransition(dst, action)

}

func (this *State) GetTransition(evt EvtIf) *Transition {

    if evt == nil {

        return nil

    }

    tran, exists := this.transitionTbl[evt.GetEvtType()]

    if exists == false {

        log.Fatal("GetTransition error,EvtIf doesn't exist")

    }

    return &tran

}

func NewTransition(dstState *State, action Action) Transition {

    return Transition{dstState, action}

}

func (this *fsm) RegisterState(state *State) {

    if state == nil {

        log.Fatal("RegisterState error, parameter invalid!")

    }

    _, exists := this.stateTbl[state.GetName()]

    if exists {

        return

        log.Fatal("RegisterState error,State exist")

    }

    this.stateTbl[state.GetName()] = state

}

func (this *fsm) AddTransition(srcState *State, evt EvtIf, dstState *State, action Action) {

    if srcState == nil || dstState == nil || evt == nil || action == nil {

        log.Fatal("AddTransition error, parameter invalid!")

    }

    this.RegisterState(srcState)

    this.RegisterState(dstState)

    srcState.AddTransition(evt, dstState, action)

}

func (this *fsm) AddInternalTransition(srcState *State, evt EvtIf, action Action) {

    this.AddTransition(srcState, evt, srcState, action)

}

func (this *fsm) HandleEvt(evt EvtIf) {

    if evt == nil {

        return

    }

    srcState := this.current

    if srcState.InterestInEvt(evt) {

        transition := srcState.GetTransition(evt)

        log.Printf("Handle Event, srcState:%s, dstState:%s, evt:%s", srcState.GetName(), transition.dstState.GetName(), evt.GetEvtType())

        //transition.action.doAction(evt, srcState, transition.dstState)

        transition.action.doAction(evt)

        this.current = transition.dstState

    } else {

        log.Printf("parameter invalid, srcState:%s, evt:%s", srcState.GetName(), evt.GetEvtType())

    }

}

func NewFsm(initialState *State) *fsm {

    if initialState == nil {

        log.Fatal("NewFsm error, parameter invalid!")

    }

    return &fsm{initialState, map[string]*State{}}

}