package domain_test

import (
	"errors"
	"testing"

	"cmbuyer/admin/internal/domain"
)

func TestTaskTransitions(t *testing.T) {
	tests := []struct {
		name    string
		current domain.TaskStatus
		next    domain.TaskStatus
		allowed bool
	}{
		{"start trial", domain.TaskStatusDraft, domain.TaskStatusPending, true},
		{"claim trial", domain.TaskStatusPending, domain.TaskStatusClaimed, true},
		{"claim retrial", domain.TaskStatusPendingRetrial, domain.TaskStatusClaimed, true},
		{"start trial execution", domain.TaskStatusClaimed, domain.TaskStatusRunning, true},
		{"release unstarted claim", domain.TaskStatusClaimed, domain.TaskStatusPending, true},
		{"trial completes", domain.TaskStatusRunning, domain.TaskStatusWaitingConfirmation, true},
		{"trial needs manual review", domain.TaskStatusRunning, domain.TaskStatusNeedsManual, true},
		{"authorize confirmed trial", domain.TaskStatusWaitingConfirmation, domain.TaskStatusAuthorized, true},
		{"reject confirmed trial", domain.TaskStatusWaitingConfirmation, domain.TaskStatusCanceled, true},
		{"start authorized order leg", domain.TaskStatusAuthorized, domain.TaskStatusOrdering, true},
		{"order reaches payment", domain.TaskStatusOrdering, domain.TaskStatusWaitingPayment, true},
		{"order needs manual review before fence", domain.TaskStatusOrdering, domain.TaskStatusNeedsManual, true},
		{"order needs reconciliation", domain.TaskStatusOrdering, domain.TaskStatusReconciliationRequired, true},
		{"payment verified", domain.TaskStatusWaitingPayment, domain.TaskStatusSucceeded, true},
		{"cannot skip trial", domain.TaskStatusDraft, domain.TaskStatusAuthorized, false},
		{"trial cannot enter order leg", domain.TaskStatusRunning, domain.TaskStatusOrdering, false},
		{"terminal task cannot restart", domain.TaskStatusSucceeded, domain.TaskStatusPending, false},
		{"unknown status is rejected", domain.TaskStatus("UNKNOWN"), domain.TaskStatusPending, false},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			if got := test.current.CanTransitionTo(test.next); got != test.allowed {
				t.Fatalf("CanTransitionTo(%s, %s) = %t, want %t", test.current, test.next, got, test.allowed)
			}

			result, err := domain.TransitionTask(test.current, test.next)
			if test.allowed {
				if err != nil {
					t.Fatalf("TransitionTask(%s, %s): %v", test.current, test.next, err)
				}
				if result != test.next {
					t.Fatalf("TransitionTask(%s, %s) = %s, want %s", test.current, test.next, result, test.next)
				}
				return
			}

			if !errors.Is(err, domain.ErrInvalidTaskTransition) {
				t.Fatalf("TransitionTask(%s, %s) error = %v, want ErrInvalidTaskTransition", test.current, test.next, err)
			}
			if result != test.current {
				t.Fatalf("TransitionTask(%s, %s) result = %s, want unchanged status", test.current, test.next, result)
			}
		})
	}
}