package batch

import (
	"context"
	"strings"
	"testing"

	_ "github.com/gogf/gf/contrib/drivers/sqlite/v2"
	"github.com/gogf/gf/v2/database/gdb"

	batchdomain "git.5iot.com/iotlcm-public/iotlcm-worker-svr/internal/batch"
	"git.5iot.com/iotlcm-public/iotlcm-worker-svr/internal/dao"
	"git.5iot.com/iotlcm-public/iotlcm-worker-svr/internal/library/batchfields"
	"git.5iot.com/iotlcm-public/iotlcm-worker-svr/internal/model/do"
	"git.5iot.com/iotlcm-public/iotlcm-worker-svr/internal/model/entity"
)

func TestMarkProcessingClaimsMainAndPendingDetails(t *testing.T) {
	ctx := context.Background()
	repository := newTestRepository(t, ctx)
	insertBatch(t, ctx, repository.db, "B-103", batchdomain.Type103)
	main, err := repository.FindMain(ctx, "B-103")
	if err != nil || main == nil || main.BatchType != batchdomain.Type103 {
		t.Fatalf("FindMain() = (%+v, %v), want batch type %d", main, err, batchdomain.Type103)
	}
	missing, err := repository.FindMain(ctx, "missing")
	if err != nil || missing != nil {
		t.Fatalf("FindMain(missing) = (%+v, %v), want nil, nil", missing, err)
	}

	claimed, err := repository.MarkProcessing(ctx, "B-103", batchdomain.Type103)
	if err != nil {
		t.Fatalf("MarkProcessing() error = %v", err)
	}
	if !claimed {
		t.Fatal("MarkProcessing() claimed = false, want true")
	}
	assertStatus(t, ctx, repository.db, dao.BatchMain.Table(), dao.BatchMain.Columns().BatchAsyncStatus, batchdomain.AsyncStatusProcessing)
	assertStatus(t, ctx, repository.db, dao.BatchMain.Table(), dao.BatchMain.Columns().RunResult, batchdomain.RunResultRunning)
	main, err = repository.FindMain(ctx, "B-103")
	if err != nil || main.StartTime == nil || main.StartTime.IsZero() {
		t.Fatalf("processing batch start time = %v, error = %v; want current time", main.StartTime, err)
	}

	var details []entity.BatchDetail
	if err = repository.db.Model(dao.BatchDetail.Table()).Ctx(ctx).
		Order(dao.BatchDetail.Columns().Id).
		Scan(&details); err != nil {
		t.Fatalf("query detail statuses: %v", err)
	}
	if len(details) != 2 || details[0].DetailStatus != batchdomain.DetailStatusRunning || details[1].DetailStatus != 2 {
		t.Fatalf("details = %+v, want statuses [1 2]", details)
	}

	claimed, err = repository.MarkProcessing(ctx, "B-103", batchdomain.Type103)
	if err != nil {
		t.Fatalf("second MarkProcessing() error = %v", err)
	}
	if claimed {
		t.Fatal("second MarkProcessing() claimed = true, want false")
	}
}

func TestMarkProcessingRollsBackMainWhenDetailUpdateFails(t *testing.T) {
	ctx := context.Background()
	repository := newTestRepository(t, ctx)
	insertBatch(t, ctx, repository.db, "B-104", batchdomain.Type104)
	if _, err := repository.db.Exec(ctx, "DROP TABLE batch_detail"); err != nil {
		t.Fatalf("drop detail table: %v", err)
	}

	if claimed, err := repository.MarkProcessing(ctx, "B-104", batchdomain.Type104); err == nil || claimed {
		t.Fatalf("MarkProcessing() = (%t, %v), want false and error", claimed, err)
	}
	assertStatus(t, ctx, repository.db, dao.BatchMain.Table(), dao.BatchMain.Columns().BatchAsyncStatus, batchdomain.AsyncStatusPending)
	assertStatus(t, ctx, repository.db, dao.BatchMain.Table(), dao.BatchMain.Columns().RunResult, 0)
	main, err := repository.FindMain(ctx, "B-104")
	if err != nil || main.StartTime != nil {
		t.Fatalf("rolled back batch start time = %v, error = %v; want nil", main.StartTime, err)
	}
}

func TestMarkFailedFinalizesProcessingBatchAndDetails(t *testing.T) {
	ctx := context.Background()
	repository := newTestRepository(t, ctx)
	insertBatch(t, ctx, repository.db, "B-105", batchdomain.Type103)
	if claimed, err := repository.MarkProcessing(ctx, "B-105", batchdomain.Type103); err != nil || !claimed {
		t.Fatalf("MarkProcessing() = (%t, %v), want true, nil", claimed, err)
	}

	marked, err := repository.MarkFailed(ctx, "B-105", batchdomain.Type103, "source file is unavailable")
	if err != nil || !marked {
		t.Fatalf("MarkFailed() = (%t, %v), want true, nil", marked, err)
	}
	assertStatus(t, ctx, repository.db, dao.BatchMain.Table(), dao.BatchMain.Columns().BatchAsyncStatus, batchdomain.AsyncStatusFailed)
	assertStatus(t, ctx, repository.db, dao.BatchMain.Table(), dao.BatchMain.Columns().RunResult, batchdomain.RunResultFailed)

	var main entity.BatchMain
	if err = repository.db.Model(dao.BatchMain.Table()).Ctx(ctx).Where(dao.BatchMain.Columns().BatchNo, "B-105").Scan(&main); err != nil {
		t.Fatalf("query failed batch main: %v", err)
	}
	if main.FailReason != "source file is unavailable" || main.EndTime == nil || main.EndTime.IsZero() {
		t.Fatalf("failed batch main = %+v, want failure reason and end time", main)
	}

	var details []entity.BatchDetail
	if err = repository.db.Model(dao.BatchDetail.Table()).Ctx(ctx).Order(dao.BatchDetail.Columns().Id).Scan(&details); err != nil {
		t.Fatalf("query failed batch details: %v", err)
	}
	if len(details) != 2 || details[0].DetailStatus != batchdomain.DetailStatusFailed || details[0].ErrorReason != "source file is unavailable" || details[1].DetailStatus != 2 {
		t.Fatalf("failed details = %+v, want statuses [3 2]", details)
	}

	marked, err = repository.MarkFailed(ctx, "B-105", batchdomain.Type103, "ignored")
	if err != nil || marked {
		t.Fatalf("second MarkFailed() = (%t, %v), want false, nil", marked, err)
	}
}

func TestMarkFailedTruncatesDetailReason(t *testing.T) {
	ctx := context.Background()
	repository := newTestRepository(t, ctx)
	insertBatch(t, ctx, repository.db, "B-106", batchdomain.Type103)
	if claimed, err := repository.MarkProcessing(ctx, "B-106", batchdomain.Type103); err != nil || !claimed {
		t.Fatalf("MarkProcessing() = (%t, %v), want true, nil", claimed, err)
	}

	reason := strings.Repeat("x", batchDetailErrorReasonLimit+20)
	marked, err := repository.MarkFailed(ctx, "B-106", batchdomain.Type103, reason)
	if err != nil || !marked {
		t.Fatalf("MarkFailed() = (%t, %v), want true, nil", marked, err)
	}

	var main entity.BatchMain
	if err = repository.db.Model(dao.BatchMain.Table()).Ctx(ctx).Where(dao.BatchMain.Columns().BatchNo, "B-106").Scan(&main); err != nil {
		t.Fatalf("query failed batch main: %v", err)
	}
	if main.FailReason != reason {
		t.Fatalf("main failure reason length = %d, want full length %d", len([]rune(main.FailReason)), len([]rune(reason)))
	}

	var details []entity.BatchDetail
	if err = repository.db.Model(dao.BatchDetail.Table()).Ctx(ctx).
		Where(dao.BatchDetail.Columns().BatchNo, "B-106").
		Order(dao.BatchDetail.Columns().Id).
		Scan(&details); err != nil {
		t.Fatalf("query failed batch details: %v", err)
	}
	if len(details) != 2 || len([]rune(details[0].ErrorReason)) != batchDetailErrorReasonLimit || details[1].ErrorReason != "" {
		t.Fatalf("detail failure reasons = %+v, want first truncated to %d and second unchanged", details, batchDetailErrorReasonLimit)
	}
}

func TestMarkFailedKeepsMainReasonWithinTextColumn(t *testing.T) {
	ctx := context.Background()
	repository := newTestRepository(t, ctx)
	insertBatch(t, ctx, repository.db, "B-LONG", batchdomain.Type103)
	if claimed, err := repository.MarkProcessing(ctx, "B-LONG", batchdomain.Type103); err != nil || !claimed {
		t.Fatalf("claim batch = (%t, %v)", claimed, err)
	}
	reason := "database error: INSERT INTO batch_detail VALUES (" + strings.Repeat("错", 30000) + ")"
	if marked, err := repository.MarkFailed(ctx, "B-LONG", batchdomain.Type103, reason); err != nil || !marked {
		t.Fatalf("mark failed = (%t, %v)", marked, err)
	}
	var main entity.BatchMain
	if err := repository.db.Model(dao.BatchMain.Table()).Ctx(ctx).Where(dao.BatchMain.Columns().BatchNo, "B-LONG").Scan(&main); err != nil {
		t.Fatal(err)
	}
	if len(main.FailReason) > batchfields.FailureReasonByteLimit || strings.Contains(main.FailReason, "VALUES") {
		t.Fatalf("unsafe failure reason: %q", main.FailReason)
	}
}

func newTestRepository(t *testing.T, ctx context.Context) *Repository {
	t.Helper()
	db, err := gdb.New(gdb.ConfigNode{
		Type: "sqlite",
		Link: "sqlite::@file(:memory:)",
	})
	if err != nil {
		t.Fatalf("create sqlite database: %v", err)
	}
	statements := []string{
		"CREATE TABLE batch_main (batch_no TEXT PRIMARY KEY, batch_type INTEGER NOT NULL, batch_async_status INTEGER NOT NULL, run_result INTEGER NOT NULL DEFAULT 0, fail_reason TEXT, start_time DATETIME, end_time DATETIME, source_channel TEXT NOT NULL DEFAULT 'legacy', execution_mode INTEGER NOT NULL DEFAULT 0)",
		"CREATE TABLE batch_detail (id INTEGER PRIMARY KEY AUTOINCREMENT, batch_no TEXT NOT NULL, batch_type INTEGER NOT NULL, detail_status INTEGER NOT NULL, error_reason TEXT)",
	}
	for _, statement := range statements {
		if _, err = db.Exec(ctx, statement); err != nil {
			t.Fatalf("create test schema: %v", err)
		}
	}
	t.Cleanup(func() { _ = db.Close(ctx) })
	return &Repository{db: db}
}

func insertBatch(t *testing.T, ctx context.Context, db gdb.DB, batchNo string, batchType int) {
	t.Helper()
	if _, err := db.Model(dao.BatchMain.Table()).Ctx(ctx).Data(do.BatchMain{
		BatchNo:          batchNo,
		BatchType:        batchType,
		BatchAsyncStatus: batchdomain.AsyncStatusPending,
	}).Insert(); err != nil {
		t.Fatalf("insert batch main: %v", err)
	}
	for _, status := range []int{batchdomain.DetailStatusPending, 2} {
		if _, err := db.Model(dao.BatchDetail.Table()).Ctx(ctx).Data(do.BatchDetail{
			BatchNo:      batchNo,
			BatchType:    batchType,
			DetailStatus: status,
		}).Insert(); err != nil {
			t.Fatalf("insert batch detail: %v", err)
		}
	}
}

func TestMarkProcessingAPNMarkerIsAtomic(t *testing.T) {
	for _, batchType := range []int{107, 109, 110} {
		t.Run(string(rune('A'+batchType-107)), func(t *testing.T) {
			ctx := context.Background()
			repo := newTestRepository(t, ctx)
			insertBatch(t, ctx, repo.db, "APN", batchType)
			claimed, err := repo.MarkProcessing(ctx, "APN", batchType)
			if err == nil || claimed {
				t.Fatalf("缺少迁移必须安全失败: claimed=%t err=%v", claimed, err)
			}
			assertStatus(t, ctx, repo.db, "batch_main", "batch_async_status", batchdomain.AsyncStatusPending)
			main, err := repo.FindMain(ctx, "APN")
			if err != nil || main.StartTime != nil {
				t.Fatalf("失败未回滚首发时间: %+v %v", main, err)
			}
			pending, err := repo.db.Model("batch_detail").Ctx(ctx).Where("detail_status", batchdomain.DetailStatusPending).Count()
			if err != nil || pending != 1 {
				t.Fatalf("明细没有安全回滚: %d %v", pending, err)
			}
			if _, err := repo.db.Exec(ctx, "CREATE TABLE data_operation_parent(batch_no TEXT PRIMARY KEY,ready INTEGER DEFAULT 0)"); err != nil {
				t.Fatal(err)
			}
			if claimed, err := repo.MarkProcessing(ctx, "APN", batchType); err != nil || !claimed {
				t.Fatalf("新批领取: %t %v", claimed, err)
			}
			n, err := repo.db.Model("data_operation_parent").Ctx(ctx).Where("batch_no", "APN").Where("ready", 0).Count()
			if err != nil || n != 1 {
				t.Fatalf("新批缺少原子凭据: %d %v", n, err)
			}
			if claimed, err := repo.MarkProcessing(ctx, "APN", batchType); err != nil || claimed {
				t.Fatalf("重投不应重复创建凭据: %t %v", claimed, err)
			}
		})
	}
}

func assertStatus(t *testing.T, ctx context.Context, db gdb.DB, table, column string, expected int) {
	t.Helper()
	actual, err := db.Model(table).Ctx(ctx).Value(column)
	if err != nil {
		t.Fatalf("query %s status: %v", table, err)
	}
	if actual.Int() != expected {
		t.Fatalf("%s status = %d, want %d", table, actual.Int(), expected)
	}
}