package fsm

import (
	"context"
	"fmt"
	"log"
	"testing"
	"time"

	"git.zhangshuocauc.cn/redhat/timewheel"
)

func state1(ctx context.Context, e *Event) error {
	switch e.Event {
	case EventEntry:
		log.Println("state1", *e)
	case EventExit:
		log.Println("state1", *e)
	default:
		log.Println("state1", *e)
		return EventNoProc
	}

	return EventOK
}

func state2(ctx context.Context, e *Event) error {
	switch e.Event {
	case EventEntry:
		log.Println("state2", *e)
	case EventExit:
		log.Println("state2", *e)
	default:
		log.Println("state2", *e)
		return EventNoProc
	}

	return EventOK
}

func state3(ctx context.Context, e *Event) error {
	switch e.Event {
	case EventEntry:
		log.Println("state3", *e)
	case EventExit:
		log.Println("state3", *e)
	case "assign":
		log.Println("state3", *e)
	default:
		log.Println("state3", *e)
		return EventNoProc
	}

	return EventOK
}

var events = Events{
	"assign",
	"accept",
}

func Test_fsm(t *testing.T) {
	fsm, err := NewFsm("MyFsm", "state1", events, []*StateRule{
		{Name: "state1", Parent: "", InitState: "state2", Processor: state1, Dst: []string{}},
		{Name: "state2", Parent: "state1", InitState: "", Processor: state2, Dst: []string{}},
		{Name: "state3", Parent: "state1", InitState: "", Processor: state3, Dst: []string{}},
		{},
	})

	if err != nil {
		fmt.Println(err)
	}

	defer fsm.StopTimer()

	ctx := context.Background()

	fmt.Println(fsm)

	fsm.ExecuteEvent(ctx, EventName("assign"), nil)

	fmt.Println(fsm.StateChange(ctx, "state3", nil))

	fsm.ExecuteEvent(ctx, EventName("accept"), nil)

	fsm.ExecuteEvent(ctx, EventName("accept1"), nil)

	fsm.StartEventTimer(ctx, timewheel.TimeTypeLoop, time.Millisecond*100, nil)

	<-time.After(time.Millisecond*100)

	fmt.Println(fsm.StateChange(ctx, "state2", nil))

	<-time.After(3 * time.Second)
}