machine

func TestTransition_Chained(t *testing.T)

{
	o := &orderFSM{}
	m, _ := New(o)
	states := []string{"confirmed", "paid", "shipped"}
	for _, s := range states {
		if err := m.Transition(s); err != nil {
			t.Fatalf("Transition to %s failed: %v", s, err)
		}
	}
	if m.CurrentState() != "shipped" {
		t.Errorf("state = %q, want %q", m.CurrentState(), "shipped")
	}
}

func TestTransition_HookOrder(t *testing.T)

{
	h := &hookFSM{}
	m, _ := New(h)
	m.Transition("active")
	if !h.onExitIdle {
		t.Error("OnExitIdle not called")
	}
	if !h.onEnterActive {
		t.Error("OnEnterActive not called")
	}

	m.Transition("done")
	if !h.onExitActive {
		t.Error("OnExitActive not called")
	}
	if !h.onEnterDone {
		t.Error("OnEnterDone not called")
	}
}

func TestCurrentState_Concurrent(t *testing.T)

{
	o := &orderFSM{}
	m, _ := New(o)
	var wg sync.WaitGroup
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			m.CurrentState()
		}()
	}
	wg.Wait()
}

func TestSubscribe_ListenerCalled(t *testing.T)

{
	o := &orderFSM{}
	m, _ := New(o)
	var events []EventType
	var mu sync.Mutex

	m.Subscribe(func(e Event) {
		mu.Lock()
		events = append(events, e.Type)
		mu.Unlock()
	})

	m.Transition("confirmed")

	mu.Lock()
	if len(events) != 4 {
		t.Fatalf("expected 4 events, got %d", len(events))
	}
	if events[0] != BeforeTransition {
		t.Errorf("event[0] = %v, want BeforeTransition", events[0])
	}
	if events[3] != AfterTransition {
		t.Errorf("event[3] = %v, want AfterTransition", events[3])
	}
	mu.Unlock()
}

func TestHistory_RecordsTransitions(t *testing.T)

{
	o := &orderFSM{}
	m, _ := New(o)
	m.Transition("confirmed")
	m.Transition("paid")

	history := m.History()
	if len(history) != 2 {
		t.Fatalf("expected 2 history records, got %d", len(history))
	}
	if history[0].From != "draft" || history[0].To != "confirmed" {
		t.Errorf("record[0] = %+v, want {draft -> confirmed}", history[0])
	}
	if history[1].From != "confirmed" || history[1].To != "paid" {
		t.Errorf("record[1] = %+v, want {confirmed -> paid}", history[1])
	}
}

func TestCheckTimeouts_Expired(t *testing.T)

{
	tm := &timeoutFSM{}
	m, _ := New(tm)
	time.Sleep(60 * time.Millisecond)
	if err := m.CheckTimeouts(); err != nil {
		t.Fatalf("CheckTimeouts failed: %v", err)
	}
	if m.CurrentState() != "expired" {
		t.Errorf("state = %q, want %q", m.CurrentState(), "expired")
	}
}

func TestGetStructure(t *testing.T)

{
	o := &orderFSM{}
	m, _ := New(o)
	initial, transitions, wildcards := m.GetStructure()
	if initial != "draft" {
		t.Errorf("initial = %q, want %q", initial, "draft")
	}
	if _, ok := transitions["draft"]; !ok {
		t.Error("expected transitions from draft")
	}
	if len(wildcards) == 0 {
		t.Error("expected wildcards")
	}
}

func TestConcurrentTransitions(t *testing.T)

{
	o := &orderFSM{}
	m, _ := New(o)

	var wg sync.WaitGroup
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			m.CurrentState()
		}()
	}

	wg.Add(1)
	go func() {
		defer wg.Done()
		m.Transition("confirmed")
	}()

	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			m.History()
		}()
	}

	wg.Wait()
}

func TestSubscribe_Concurrent(t *testing.T)

{
	o := &orderFSM{}
	m, _ := New(o)

	var wg sync.WaitGroup
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			m.Subscribe(func(e Event) {})
		}()
	}
	wg.Wait()
}

func TestDoubleWildcard(t *testing.T)

{
	type doubleWild struct {
		State string `fsm:"*->cancelled; *->archived"`
	}
	d := &doubleWild{}
	m, err := New(d)
	if err != nil {
		t.Fatalf("New failed: %v", err)
	}
	if err := m.Transition("cancelled"); err != nil {
		t.Fatalf("Transition to cancelled failed: %v", err)
	}
}

func New(obj any) (*Machine, error)

{
	val := reflect.ValueOf(obj)
	if val.Kind() != reflect.Ptr || val.Elem().Kind() != reflect.Struct {
		return nil, errors.New("obj must be a pointer to a struct")
	}

	elem := val.Elem()

	fields := tags.NewParser("fsm").ParseStruct(obj)

	for _, meta := range fields {
		if meta.Type.Kind() != reflect.String {
			return nil, fmt.Errorf("field '%s' must be a string", meta.Name)
		}

		cfg, err := parser.Parse(meta.RawTag)
		if err != nil {
			return nil, err
		}

		m := &Machine{
			obj:           obj,
			val:          elem,
			stateField:   elem.Field(meta.Index),
			stateType:    elem.Type().Field(meta.Index),
			transitions:  cfg.Transitions,
			wildcards:    cfg.Wildcards,
			initialState: cfg.InitialState,
			timeouts:     cfg.Timeouts,
			hooks:        make(map[string]stateHooks),
			history:      make([]TransitionRecord, 0),
			listeners:    make([]Listener, 0),
		}
		m.transitionSet = make(map[string]map[string]bool, len(cfg.Transitions))
		for src, dsts := range cfg.Transitions {
			s := make(map[string]bool, len(dsts))
			for _, d := range dsts {
				s[d] = true
			}
			m.transitionSet[src] = s
		}
		m.wildcardSet = make(map[string]bool, len(cfg.Wildcards))
		for _, w := range cfg.Wildcards {
			m.wildcardSet[w] = true
		}

		m.initHooks()

		current := m.stateField.String()
		if current == "" && m.initialState != "" {
			m.stateField.SetString(m.initialState)
			current = m.initialState
		}
		m.lastStateTime = time.Now()

		return m, nil
	}

	return nil, errors.New("no field with 'fsm' tag found")
}

func normalizeStateName(s string) string

{
	parts := strings.Split(s, "_")
	for i, p := range parts {
		r := []rune(p)
		if len(r) > 0 {
			r[0] = unicode.ToUpper(r[0])
		}
		parts[i] = string(r)
	}
	return strings.Join(parts, "")
}