package simstatus

import (
	"context"
	"errors"
	"testing"
	"time"

	"git.5iot.com/iotlcm-public/iotlcm-worker-svr/internal/model"
	queue "git.5iot.com/iotlcm-public/iotlcm-worker-svr/internal/queue/zset"
	"git.5iot.com/iotlcm-public/iotlcm-worker-svr/internal/testutil"
)

type cardScanner struct{ cards []Card }

func (s cardScanner) SnapshotMaxID(context.Context) (int64, error) { return int64(len(s.cards)), nil }
func (s cardScanner) Scan(_ context.Context, last, max int64, limit int) ([]Card, error) {
	end := last + int64(limit)
	if end > max {
		end = max
	}
	return s.cards[last:end], nil
}

func TestProducerUsesRunQueueForFullAndSingleCard(t *testing.T) {
	redis := testutil.Redis(t)
	ctx := context.Background()
	store, err := queue.New(redis, "sim-status:")
	if err != nil {
		t.Fatal(err)
	}
	scanner := cardScanner{cards: []Card{
		{ID: 1, ICCID: "a", ChanKey: "ch", TempKey: "sim_yd_v5"},
		{ID: 2, ICCID: "b", ChanKey: "ch", TempKey: "sim_yd_v5", SyncEnabled: true},
		{ID: 3, ICCID: "c", ChanKey: "ch"},
		{ID: 4, ICCID: "d", ChanKey: "ch", TempKey: "sim_yd_v5"},
	}}
	producer, err := New(scanner, store, Config{PageSize: 1})
	if err != nil {
		t.Fatal(err)
	}
	for i := 0; i < 2; i++ {
		if err = producer.Produce(ctx, model.SimStatusQueueStartMessage{RunID: "full"}); err != nil {
			t.Fatal(err)
		}
	}
	meta, err := store.GetRunMeta(ctx, "full")
	if err != nil || !meta.ProducerDone || meta.ActiveCount != 2 || meta.Status != "running" {
		t.Fatalf("full metadata=%+v err=%v", meta, err)
	}
	claims, err := store.ClaimRun(ctx, "full", "ch", time.Now(), time.Now().Add(time.Minute), 10)
	if err != nil || len(claims) != 2 {
		t.Fatalf("full claims=%+v err=%v", claims, err)
	}
	if n, err := store.Size(ctx, "ch"); err != nil || n != 0 {
		t.Fatalf("legacy queue populated: %d %v", n, err)
	}
	message := model.SimStatusQueueTaskMessage{RunID: "single", CardID: 42, ICCID: "single", ChanKey: "ch", TempKey: "sim_yd_v5"}
	for i := 0; i < 2; i++ {
		if err = producer.EnqueueCard(ctx, message); err != nil {
			t.Fatal(err)
		}
	}
	meta, err = store.GetRunMeta(ctx, "single")
	if err != nil || !meta.ProducerDone || meta.ActiveCount != 1 {
		t.Fatalf("single metadata=%+v err=%v", meta, err)
	}
	claims, err = store.ClaimRun(ctx, "single", "ch", time.Now(), time.Now().Add(time.Minute), 10)
	if err != nil || len(claims) != 1 {
		t.Fatalf("single claims=%+v err=%v", claims, err)
	}
	if n, err := store.FinalizeRunTasks(ctx, claims, []queue.TaskOutcome{{Success: true}}, 1); err != nil || n != 1 {
		t.Fatalf("single finalize: %d %v", n, err)
	}
	if ok, err := store.CompleteRunIfIdle(ctx, "single"); err != nil || !ok {
		t.Fatalf("single complete: %v %v", ok, err)
	}
	if err = producer.EnqueueCard(ctx, message); err != nil {
		t.Fatal(err)
	}
	meta, err = store.GetRunMeta(ctx, "single")
	if err != nil || meta.Status != "completed" || meta.SuccessCount != 1 || meta.ActiveCount != 0 {
		t.Fatalf("replayed single=%+v err=%v", meta, err)
	}
}

func TestProducerBackpressureIncludesLeasedRunTasks(t *testing.T) {
	redis := testutil.Redis(t)
	store, _ := queue.New(redis, "sim-status:")
	ctx := context.Background()
	producer, err := New(cardScanner{}, store, Config{GlobalHighWaterMark: 1, PollInterval: time.Millisecond})
	if err != nil {
		t.Fatal(err)
	}
	if err = store.CreateRun(ctx, queue.RunMeta{RunID: "busy"}); err != nil {
		t.Fatal(err)
	}
	tasks := []queue.Task{{RunID: "busy", TaskID: "1", ChanKey: "ch"}, {RunID: "busy", TaskID: "2", ChanKey: "ch"}}
	if _, err = store.EnqueueRunBatch(ctx, "busy", "ch", tasks, time.Now()); err != nil {
		t.Fatal(err)
	}
	claims, err := store.ClaimRun(ctx, "busy", "ch", time.Now(), time.Now().Add(time.Minute), 2)
	if err != nil || len(claims) != 2 {
		t.Fatalf("claim=%v err=%v", claims, err)
	}
	waitCtx, cancel := context.WithTimeout(ctx, 30*time.Millisecond)
	defer cancel()
	if err = producer.waitForCapacity(waitCtx); !errors.Is(err, context.DeadlineExceeded) {
		t.Fatalf("did not wait on run backlog: %v", err)
	}
	if _, err = store.FinalizeRunTasks(ctx, claims[:1], []queue.TaskOutcome{{Success: true}}); err != nil {
		t.Fatal(err)
	}
	// One remaining lease meets the watermark: InflightCount must not be added again.
	waitCtx2, cancel2 := context.WithTimeout(ctx, time.Second)
	defer cancel2()
	if err = producer.waitForCapacity(waitCtx2); err != nil {
		t.Fatalf("double-counted lease: %v", err)
	}
}