switch cmd {
  case "submit":
  fmt.Println("用户提交了订单，当前等待用户支付")
  fmt.Println("通知仓储系统，冻结部分库存")
  case "pay":
  fmt.Println("用户支付了订单，等待仓储系统发货")
  fmt.Println("通知仓储系统，扣减部分库存")
  fmt.Println("通知统计系统，进行订单统计")
  case "refund":
  fmt.Println("用户申请了退款")
  fmt.Println("通知仓储系统，回滚部分库存")
  fmt.Println("通知统计系统，回滚订单统计")
}

package fsm_order_demo

import (
	"fmt"
	"sync"

	"github.com/jormin/fsm-order-demo/helper"
)

// State 状态
type State uint8

// Event 事件
type Event string

// Action 动作
type Action func(from State, event Event, to State) error

// Transition 转换器
type Transition struct {
	From      State          `desc:"旧状态"`
	Event     Event          `desc:"事件"`
	To        State          `desc:"新状态"`
	Action    Action         `desc:"动作"`
	Processor EventProcessor `desc:"处理器"`
}

// StateGraph 状态机图表
type StateGraph struct {
	name        string                         `desc:"图表名称"`
	start       State                          `desc:"起始状态"`
	end         State                          `desc:"结束状态"`
	states      map[State]string               `desc:"状态集合"`
	transitions map[State]map[Event]Transition `desc:"转变器集合"`
}

// EventProcessor 事件处理器
type EventProcessor interface {
	// ExitOldState 离开旧状态
	ExitOldState(state State, event Event) error
	// EnterNewState 进入新状态
	EnterNewState(state State, event Event) error
}

// StateMachine 状态机
type StateMachine struct {
	locker    sync.Mutex     `desc:"排它锁"`
	Processor EventProcessor `desc:"事件处理器"`
	Graph     *StateGraph    `desc:"状态图表"`
}

// SetName 设置状态图表名称
func (s *StateMachine) SetName(name string) {
	s.Graph.name = name
}

// SetStart 设置状态图表起始状态
func (s *StateMachine) SetStart(start State) {
	s.Graph.start = start
}

// SetEnd 设置状态图表最终状态
func (s *StateMachine) SetEnd(end State) {
	s.Graph.end = end
}

// SetStates 设置状态图表状态列表
func (s *StateMachine) SetStates(states map[State]string) {
	s.Graph.states = states
}

// SetTransitions 设置状态图表转变器列表
func (s *StateMachine) SetTransitions(transitions map[State]map[Event]Transition) {
	s.Graph.transitions = transitions
}

// GetStateDesc 获取状态描述
func (s *StateMachine) GetStateDesc(state State) string {
	return fmt.Sprintf("%s(%d)", s.Graph.states[state], state)
}

// Run 执行
func (s *StateMachine) Run(from State, event Event) (State, error) {
	helper.Log("开始执行，旧状态为 %d，事件为 %s", from, event)
	// 检测状态是否存在
	if _, ok := s.Graph.states[from]; !ok {
		return 0, helper.ErrOldStateNotExists
	}
	// 检测到状态是否已到最终状态
	if from == s.Graph.end {
		return 0, helper.ErrOldStateIsEndState
	}
	// 检测状态和事件是否匹配
	transition, ok := s.Graph.transitions[from][event]
	if !ok {
		return 0, helper.ErrOldStateDontHaveTheEventTransition
	}
	// 新状态
	to := transition.To
	// 加锁
	s.locker.Lock()
	// 执行完毕时解锁
	defer s.locker.Unlock()
	// 执行状态机处理器的退出旧状态方法
	_ = s.Processor.ExitOldState(from, event)
	// 如果当前转变期设置了处理器，则执行该处理器的退出旧状态方法
	if transition.Processor != nil {
		_ = transition.Processor.ExitOldState(from, event)
	}
	// 执行转变期的动作
	_ = transition.Action(from, event, transition.To)
	// 执行状态机处理器的进入新状态方法
	_ = s.Processor.EnterNewState(to, event)
	// 如果当前转变期设置了处理器，则执行该处理器的进入新状态方法
	if transition.Processor != nil {
		_ = transition.Processor.EnterNewState(to, event)
	}
	return to, nil
}

const (
	// StateWaitPay 待支付
	StateWaitPay = iota
	// StateCancel 已取消
	StateCancel
	// StateWaitConfirm 待确认
	StateWaitConfirm
	// StatePayied 已支付
	StatePayied
)

const (
	// EventPay 支付
	EventPay = "pay"
	// EventPayConfirm 支付确认
	EventPayConfirm = "pay_confirm"
	// EventCancel 取消
	EventCancel = "cancel"
)

// transitions 转变器
var transitions = map[fsmorderdemo.State]map[fsmorderdemo.Event]fsmorderdemo.Transition{
	StateWaitPay: {
		// 取消：待支付 ---> 已取消
		EventCancel: fsmorderdemo.Transition{
			From: StateWaitPay, Event: EventCancel, To: StateCancel, Action: action.Cancel, Processor: nil,
		},
		// 支付：待支付 ---> 待确认
		EventPay: fsmorderdemo.Transition{
			From: StateWaitPay, Event: EventPay, To: StateWaitConfirm, Action: action.Pay,
			Processor: &processor.PayEventProcessor{},
		},
		// 支付确认：待支付 ---> 已支付
		EventPayConfirm: fsmorderdemo.Transition{
			From: StateWaitPay, Event: EventPayConfirm, To: StatePayied, Action: action.PayConfirm, Processor: nil,
		},
	},
	StateWaitConfirm: {
		// 支付确认：待确认 ---> 已支付
		EventPayConfirm: fsmorderdemo.Transition{
			From: StateWaitConfirm, Event: EventPayConfirm, To: StatePayied, Action: action.PayConfirm, Processor: nil,
		},
	},
}

// 取消：待支付 ---> 已取消
// 支付：待支付 ---> 待确认
// 支付确认：待支付 ---> 已支付
// 支付确认：待确认 ---> 已支付

const (
	// StateWaitPay 待支付
	StateWaitPay = iota
	// StateCancel 已取消
	StateCancel
	// StateWaitConfirm 待确认
	StateWaitConfirm
	// StateWaitDelive 待发货
	StateWaitDelive
	// StateRefund 售后中-退款
	StateRefund
	// StateWaitReceive 待收货
	StateWaitReceive
	// StateSigned 已签收
	StateSigned
	// StateGoodsRefund 售后中-退货退款
	StateGoodsRefund
	// StateCompleted 已完成
	StateCompleted
)

const (
	// EventPay 支付
	EventPay = "pay"
	// EventCancel 取消
	EventCancel = "cancel"
	// EventPayConfirm 支付确认
	EventPayConfirm = "pay_confirm"
	// EventDelive 发货
	EventDelive = "delive"
	// EventApplyRefund 申请退款
	EventApplyRefund = "apply_refund"
	// EventCancelRefund 取消售后
	EventCancelRefund = "cancel_refund"
	// EventRefundCompleted 退款完成
	EventRefundCompleted = "refund_completed"
	// EventSigned 签收
	EventSigned = "signed"
	// EventApplyGoodsRefund 申请退货退款
	EventApplyGoodsRefund = "apply_goods_refund"
	// EventCompleted 订单完成
	EventCompleted = "completed"
)

// transitions 转变器
var transitions = map[fsmorderdemo.State]map[fsmorderdemo.Event]fsmorderdemo.Transition{
	StateWaitPay: {
		// 取消：待支付 ---> 已取消
		EventCancel: fsmorderdemo.Transition{
			From: StateWaitPay, Event: EventCancel, To: StateCancel, Action: action.Cancel, Processor: nil,
		},
		// 支付：待支付 ---> 待确认
		EventPay: fsmorderdemo.Transition{
			From: StateWaitPay, Event: EventPay, To: StateWaitConfirm, Action: action.Pay,
			Processor: &processor.PayEventProcessor{},
		},
		// 支付确认：待支付 ---> 待发货
		EventPayConfirm: fsmorderdemo.Transition{
			From: StateWaitPay, Event: EventPayConfirm, To: StateWaitDelive, Action: action.PayConfirm, Processor: nil,
		},
	},
	StateWaitConfirm: {
		// 支付确认：待确认 ---> 待发货
		EventPayConfirm: fsmorderdemo.Transition{
			From: StateWaitConfirm, Event: EventPayConfirm, To: StateWaitDelive, Action: action.PayConfirm,
			Processor: nil,
		},
	},
	StateWaitDelive: {
		// 发货：待发货 ---> 待收货
		EventDelive: fsmorderdemo.Transition{
			From: StateWaitDelive, Event: EventDelive, To: StateWaitReceive, Action: action.Delive, Processor: nil,
		},
		// 申请退款：待发货 ---> 售后中-退款
		EventApplyRefund: fsmorderdemo.Transition{
			From: StateWaitDelive, Event: EventApplyRefund, To: StateRefund, Action: action.ApplyRefund, Processor: nil,
		},
	},
	StateRefund: {
		// 取消售后：售后中-退款 ---> 待发货
		EventCancelRefund: fsmorderdemo.Transition{
			From: StateRefund, Event: EventCancelRefund, To: StateWaitDelive, Action: action.CancelRefund,
			Processor: nil,
		},
		// 退款完成：售后中-退款 ---> 已完成
		EventRefundCompleted: fsmorderdemo.Transition{
			From: StateRefund, Event: EventRefundCompleted, To: StateCompleted, Action: action.RefundCompleted,
			Processor: nil,
		},
	},
	StateWaitReceive: {
		// 签收：待收货 ---> 已签收
		EventSigned: fsmorderdemo.Transition{
			From: StateWaitReceive, Event: EventSigned, To: StateSigned, Action: action.Signed, Processor: nil,
		},
	},
	StateSigned: {
		// 申请退货退款：已签收 ---> 售后中-退货退款
		EventApplyGoodsRefund: fsmorderdemo.Transition{
			From: StateSigned, Event: EventApplyGoodsRefund, To: StateGoodsRefund, Action: action.ApplyGoodsRefund,
			Processor: nil,
		},
		// 订单完成：已签收 ---> 已完成
		EventCompleted: fsmorderdemo.Transition{
			From: StateSigned, Event: EventCompleted, To: StateCompleted, Action: action.Completed, Processor: nil,
		},
	},
	StateGoodsRefund: {
		// 取消售后：售后中-退货退款 ---> 已签收
		EventCancelRefund: fsmorderdemo.Transition{
			From: StateGoodsRefund, Event: EventCancelRefund, To: StateSigned, Action: action.CancelRefund,
			Processor: nil,
		},
		// 退款完成：售后中-退货退款 ---> 已完成
		EventRefundCompleted: fsmorderdemo.Transition{
			From: StateGoodsRefund, Event: EventRefundCompleted, To: StateCompleted, Action: action.RefundCompleted,
			Processor: nil,
		},
	},
}

// 取消：待支付 ---> 已取消
// 支付：待支付 ---> 待确认
// 支付确认：待支付 ---> 待发货
// 支付确认：待确认 ---> 待发货
// 发货：待发货 ---> 待收货
// 申请退款：待发货 ---> 售后中-退款
// 取消售后：售后中-退款 ---> 待发货
// 退款完成：售后中-退款 ---> 已完成
// 签收：待收货 ---> 已签收
// 申请退货退款：已签收 ---> 售后中-退货退款
// 订单完成：已签收 ---> 已完成
// 取消售后：售后中-退货退款 ---> 已签收
// 退款完成：售后中-退货退款 ---> 已完成

const (
	// StateWaitApprove 待审批
	StateWaitApprove = iota
	// StateCancel 已取消
	StateCancel
	// StateRefused 已驳回
	StateRefused
	// StateAgreed 已通过
	StateAgreed
	// StateWaitDelive 退货中
	StateWaitDelive
	// StateWaitReceive 待收货
	StateWaitReceive
	// StateWaitRefund 退款中
	StateWaitRefund
	// StateCompleted 已完成
	StateCompleted
)

const (
	// EventCancel 取消
	EventCancel = "cancel"
	// EventRefuse 驳回
	EventRefuse = "refuse"
	// EventAgree 通过
	EventAgree = "agree"
	// EventRefund 提交退款申请(未发货订单)
	EventRefund = "refund"
	// EventGoodsRefund 等待用户寄回(已发货订单)
	EventGoodsRefund = "goods_refund"
	// EventDelive 发货
	EventDelive = "delive"
	// EventSigned 签收
	EventSigned = "signed"
	// EventRefundCompleted 退款完成
	EventRefundCompleted = "refund_completed"
)

var transitions = map[fsmorderdemo.State]map[fsmorderdemo.Event]fsmorderdemo.Transition{
	StateWaitApprove: {
		// 取消：待审批 ---> 已取消
		EventCancel: fsmorderdemo.Transition{
			From: StateWaitApprove, Event: EventCancel, To: StateCancel, Action: action.Cancel, Processor: nil,
		},
		// 驳回：待审批 ---> 已驳回
		EventRefuse: fsmorderdemo.Transition{
			From: StateWaitApprove, Event: EventRefuse, To: StateRefused, Action: action.Refuse, Processor: nil,
		},
		// 通过：待审批 ---> 已通过
		EventAgree: fsmorderdemo.Transition{
			From: StateWaitApprove, Event: EventAgree, To: StateAgreed, Action: action.Agree, Processor: nil,
		},
	},
	StateAgreed: {
		// 提交退款申请(未发货订单)：已通过 ---> 退款中
		EventRefund: fsmorderdemo.Transition{
			From: StateAgreed, Event: EventRefund, To: StateWaitRefund, Action: action.Refund, Processor: nil,
		},
		// 等待用户寄回(已发货订单)：已通过 ---> 退货中
		EventGoodsRefund: fsmorderdemo.Transition{
			From: StateAgreed, Event: EventGoodsRefund, To: StateWaitDelive, Action: action.GoodsRefund, Processor: nil,
		},
		// 取消：已通过 ---> 已取消
		EventCancel: fsmorderdemo.Transition{
			From: StateAgreed, Event: EventCancel, To: StateCancel, Action: action.Cancel, Processor: nil,
		},
	},
	StateWaitDelive: {
		// 发货：退货中 ---> 待收货
		EventDelive: fsmorderdemo.Transition{
			From: StateWaitDelive, Event: EventDelive, To: StateWaitReceive, Action: action.Delive,
			Processor: &processor.DeliveEventProcessor{},
		},
		// 取消：退货中 ---> 已取消
		EventCancel: fsmorderdemo.Transition{
			From: StateWaitDelive, Event: EventCancel, To: StateCancel, Action: action.Cancel, Processor: nil,
		},
	},
	StateWaitReceive: {
		// 签收：待收货 ---> 退款中
		EventSigned: fsmorderdemo.Transition{
			From: StateWaitReceive, Event: EventSigned, To: StateWaitRefund, Action: action.Signed, Processor: nil,
		},
	},
	StateWaitRefund: {
		// 退款完成：退款中 ---> 已完成
		EventRefundCompleted: fsmorderdemo.Transition{
			From: StateWaitRefund, Event: EventRefundCompleted, To: StateCompleted, Action: action.RefundCompleted,
			Processor: nil,
		},
	},
}

// 取消：待审批 ---> 已取消
// 驳回：待审批 ---> 已驳回
// 通过：待审批 ---> 已通过
// 提交退款申请(未发货订单)：已通过 ---> 退款中
// 等待用户寄回(已发货订单)：已通过 ---> 退货中
// 取消：已通过 ---> 已取消
// 发货：退货中 ---> 待收货
// 取消：退货中 ---> 已取消
// 签收：待收货 ---> 退款中
// 退款完成：退款中 ---> 已完成