parser

func Parse(tag string) (*Config, error)

{
	cfg := &Config{
		Transitions: make(map[string][]string),
		Timeouts:    make(map[string]TimeoutRule),
	}

	parsed := tagParser.Parse(tag)

	if initial, ok := parsed["initial"]; ok && len(initial) > 0 {
		cfg.InitialState = initial[0]
	}

	for key := range parsed {
		if key == "initial" {
			continue
		}

		part := key
		var timeoutDuration time.Duration

		if startBracket := strings.Index(part, "["); startBracket != -1 {
			endBracket := strings.Index(part, "]")
			if endBracket > startBracket {
				durStr := part[startBracket+1 : endBracket]
				var err error
				timeoutDuration, err = time.ParseDuration(durStr)
				if err != nil {
					return nil, fmt.Errorf("invalid timeout duration: %s", durStr)
				}
				part = strings.TrimSpace(part[:startBracket])
			}
		}

		before, after, ok := strings.Cut(part, "->")
		if !ok {
			continue
		}

		src := strings.TrimSpace(before)
		dst := strings.TrimSpace(after)

		if src == "*" {
			cfg.Wildcards = append(cfg.Wildcards, dst)
		} else {
			cfg.Transitions[src] = append(cfg.Transitions[src], dst)
		}

		if timeoutDuration > 0 {
			cfg.Timeouts[src] = TimeoutRule{
				FromState: src,
				ToState:   dst,
				Duration:  timeoutDuration,
			}
		}
	}

	return cfg, nil
}

func TestParse_BasicTransition(t *testing.T)

{
	cfg, err := Parse("initial:draft; draft->paid; paid->shipped")
	if err != nil {
		t.Fatalf("Parse failed: %v", err)
	}
	if cfg.InitialState != "draft" {
		t.Errorf("initial = %q, want %q", cfg.InitialState, "draft")
	}
	if len(cfg.Transitions) != 2 {
		t.Fatalf("expected 2 transitions, got %d", len(cfg.Transitions))
	}
	if !contains(cfg.Transitions["draft"], "paid") {
		t.Error("expected draft->paid")
	}
	if !contains(cfg.Transitions["paid"], "shipped") {
		t.Error("expected paid->shipped")
	}
}

func TestParse_Timeout(t *testing.T)

{
	cfg, err := Parse("initial:pending; pending->expired [500ms]")
	if err != nil {
		t.Fatalf("Parse failed: %v", err)
	}
	rule, ok := cfg.Timeouts["pending"]
	if !ok {
		t.Fatal("expected timeout for 'pending'")
	}
	if rule.ToState != "expired" {
		t.Errorf("toState = %q, want %q", rule.ToState, "expired")
	}
	if rule.Duration != 500*time.Millisecond {
		t.Errorf("duration = %v, want %v", rule.Duration, 500*time.Millisecond)
	}
}

func TestParse_TimeoutCustomDuration(t *testing.T)

{
	cfg, err := Parse("a->b [2s]")
	if err != nil {
		t.Fatalf("Parse failed: %v", err)
	}
	rule, ok := cfg.Timeouts["a"]
	if !ok {
		t.Fatal("expected timeout for 'a'")
	}
	if rule.Duration != 2*time.Second {
		t.Errorf("duration = %v, want %v", rule.Duration, 2*time.Second)
	}
}

func TestParse_TrimsWhitespace(t *testing.T)

{
	cfg, err := Parse("  initial:  draft  ;  draft  ->  paid  ")
	if err != nil {
		t.Fatalf("Parse failed: %v", err)
	}
	if cfg.InitialState != "draft" {
		t.Errorf("initial = %q, want %q", cfg.InitialState, "draft")
	}
	if !contains(cfg.Transitions["draft"], "paid") {
		t.Error("expected draft->paid")
	}
}

func Parse(tag string) *Policy

{
	p := &Policy{
		Permissions: make(map[string][]string),
	}

	parsed := tagParser.Parse(tag)

	for key, values := range parsed {
		if key == "role" {
			if len(values) == 1 && values[0] == "*" {
				p.UseValueAsRole = true
			} else {
				p.Roles = append(p.Roles, values...)
			}
			continue
		}

		p.Permissions[key] = values
	}

	return p
}