package warningconfig

import (
	"context"
	"testing"
	"time"

	"github.com/gogf/gf/v2/encoding/gjson"
	"github.com/gogf/gf/v2/os/gtime"

	"git.5iot.com/iotlcm-public/iotlcm-worker-svr/internal/consts"
	"git.5iot.com/iotlcm-public/iotlcm-worker-svr/internal/model/entity"
)

func TestCanExecuteProcessingAllowsStaleWarningConfigBatch(t *testing.T) {
	executor := &executor{}
	main := &entity.BatchMain{
		BatchType:        consts.BatchTypeSimWarningConfig,
		BatchAsyncStatus: consts.BatchAsyncStatusProcessing,
		StartTime:        gtime.Now().Add(-warningConfigProcessingRetryAfter - time.Second),
	}

	canExecute, err := executor.CanExecuteProcessing(context.Background(), main)
	if err != nil || !canExecute {
		t.Fatalf("CanExecuteProcessing() = %t, %v; want true, nil", canExecute, err)
	}
}

func TestConfigFromDetailSnapshotUsesRowValues(t *testing.T) {
	fallback := Config{
		ItemType:    warnItemTypeCard,
		WarnUnit:    warnUnitMb,
		WarnMethods: warnDefaultMethod,
		IsEnabled:   1,
	}
	snapshot := gjson.New(map[string]any{
		"configSet":      true,
		"configItemType": warnItemTypeCard,
		"warnUnit":       warnUnitMb,
		"firstWarn":      100,
		"secondWarn":     500,
		"thirdWarn":      900,
		"warnMethods":    "3,1,0",
		"warnPhones":     "13800008000",
		"warnEmails":     "xxx@example.com",
		"autoAction":     warnAutoActionSuspend,
		"isEnabled":      1,
		"remark":         "row config",
	})

	got := configFromDetailSnapshot(snapshot, fallback)
	if got.FirstWarn != 100 || got.SecondWarn != 500 || got.ThirdWarn != 900 {
		t.Fatalf("unexpected thresholds: %#v", got)
	}
	if got.WarnMethods != "3,1,0" || got.AutoAction != warnAutoActionSuspend {
		t.Fatalf("unexpected row notification config: %#v", got)
	}
}

func TestCanExecuteProcessingSkipsFreshOrDifferentBatch(t *testing.T) {
	executor := &executor{}
	tests := []struct {
		name string
		main *entity.BatchMain
	}{
		{
			name: "fresh processing batch",
			main: &entity.BatchMain{
				BatchType:        consts.BatchTypeSimWarningConfig,
				BatchAsyncStatus: consts.BatchAsyncStatusProcessing,
				StartTime:        gtime.Now(),
			},
		},
		{
			name: "different batch type",
			main: &entity.BatchMain{
				BatchType:        consts.BatchTypeSimCardStart,
				BatchAsyncStatus: consts.BatchAsyncStatusProcessing,
				StartTime:        gtime.Now().Add(-warningConfigProcessingRetryAfter - time.Second),
			},
		},
		{
			name: "pending warning config batch",
			main: &entity.BatchMain{
				BatchType:        consts.BatchTypeSimWarningConfig,
				BatchAsyncStatus: 1,
				StartTime:        gtime.Now().Add(-warningConfigProcessingRetryAfter - time.Second),
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			canExecute, err := executor.CanExecuteProcessing(context.Background(), tt.main)
			if err != nil || canExecute {
				t.Fatalf("CanExecuteProcessing() = %t, %v; want false, nil", canExecute, err)
			}
		})
	}
}

func TestValidateTaskMarksWholeBatchFailed(t *testing.T) {
	task := &Task{
		Details: []*Detail{
			{ICCID: "8986000000000000001"},
			{ICCID: "8986000000000000002", Reason: "卡不存在"},
		},
	}

	validateTask(task)

	for _, detail := range task.Details {
		if detail.Success() {
			t.Fatalf("detail %s remained successful after atomic failure", detail.ICCID)
		}
	}
	if task.FailureReason == "" {
		t.Fatal("expected batch failure reason")
	}
	status, result := batchResult(countResult(task))
	if status != consts.BatchAsyncStatusFailed || result != consts.BatchRunResultFailed {
		t.Fatalf("batchResult() = %d, %d; want failed, failed", status, result)
	}
}