package trafficcutoff

import (
	"context"
	"testing"

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

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

const (
	testTenantID = "000000"
	testDeptID   = int64(100)
)

func newTestRepository(t *testing.T) *Repository {
	t.Helper()
	ctx := context.Background()
	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 (
            source_channel TEXT NOT NULL DEFAULT 'legacy',
            execution_mode INTEGER NOT NULL DEFAULT 0,
			id INTEGER PRIMARY KEY AUTOINCREMENT,
			batch_no TEXT NOT NULL,
			batch_type INTEGER NOT NULL,
			batch_async_status INTEGER NOT NULL,
			run_result INTEGER NOT NULL DEFAULT 0,
			total_count INTEGER NOT NULL DEFAULT 0,
			valid_count INTEGER NOT NULL DEFAULT 0,
			success_count INTEGER NOT NULL DEFAULT 0,
			fail_count INTEGER NOT NULL DEFAULT 0,
			fail_reason TEXT,
			start_time DATETIME,
			end_time DATETIME,
			dept_id INTEGER NOT NULL DEFAULT 0,
			created_by INTEGER NOT NULL DEFAULT 0,
			created_dept INTEGER NOT NULL DEFAULT 0,
			tenant_id TEXT NOT NULL DEFAULT '',
			batch_info TEXT
		)`,
		`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,
			snapshot TEXT,
			item_id TEXT,
			row_no INTEGER NOT NULL DEFAULT 0,
			updated_by INTEGER NOT NULL DEFAULT 0
		)`,
		`CREATE TABLE t_sim_card_info (
			id INTEGER PRIMARY KEY AUTOINCREMENT,
			iccid TEXT NOT NULL,
			msisdn TEXT,
			imsi TEXT,
			boss_card_status INTEGER NOT NULL DEFAULT 0,
			traffic_cutoff_status INTEGER NOT NULL DEFAULT 0,
			traffic_cutoff_threshold REAL NOT NULL DEFAULT 0,
			tenant_id TEXT NOT NULL DEFAULT '',
			updated_by INTEGER NOT NULL DEFAULT 0
		)`,
		`CREATE TABLE sys_oss (
			oss_id INTEGER PRIMARY KEY AUTOINCREMENT,
			tenant_id TEXT,
			file_name TEXT,
			original_name TEXT,
			file_suffix TEXT,
			path TEXT,
			url TEXT,
			created_dept INTEGER,
			created_by INTEGER,
			updated_by INTEGER,
			service TEXT,
			md5 TEXT,
			file_size INTEGER
		)`,
		`CREATE TABLE t_resource_batch_download (
			id INTEGER PRIMARY KEY AUTOINCREMENT,
			batch_no TEXT,
			task_name TEXT,
			resource_type INTEGER,
			export_scene INTEGER,
			total_count INTEGER,
			success_count INTEGER,
			fail_count INTEGER,
			download_status INTEGER,
			oss_id INTEGER,
			file_name TEXT,
			file_ext TEXT,
			file_url TEXT,
			file_path TEXT,
			file_size INTEGER,
			file_md5 TEXT,
			download_count INTEGER,
			max_download_count INTEGER,
			dept_id INTEGER,
			start_time DATETIME,
			finish_time DATETIME,
			tenant_id TEXT,
			created_dept INTEGER,
			created_by INTEGER,
			updated_by INTEGER
		)`,
	}
	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, lockEnabled: false}
}

func seedProcessingBatch(t *testing.T, ctx context.Context, db gdb.DB, batchNo string, threshold float64) {
	t.Helper()
	info := gjson.New(map[string]any{
		"operation":              "dataCut",
		"trafficCutoffStatus":    1,
		"trafficCutoffThreshold": threshold,
		"thresholdUnit":          "MB",
		"resultFile":             map[string]any{"status": "pending"},
	})
	if _, err := db.Model(dao.BatchMain.Table()).Ctx(ctx).Data(do.BatchMain{
		BatchNo:          batchNo,
		BatchType:        consts.BatchTypeTrafficCutoff,
		BatchAsyncStatus: consts.BatchAsyncStatusProcessing,
		RunResult:        batchdomain.RunResultRunning,
		DeptId:           testDeptID,
		CreatedBy:        7,
		CreatedDept:      testDeptID,
		TenantId:         testTenantID,
		BatchInfo:        info,
	}).Insert(); err != nil {
		t.Fatalf("insert batch main: %v", err)
	}
}

func seedRunningDetail(t *testing.T, ctx context.Context, db gdb.DB, batchNo string, rowNo int, iccid, msisdn, imsi string, authorized bool) {
	t.Helper()
	snapshot := gjson.New(map[string]any{
		"ICCID":      iccid,
		"MSISDN":     msisdn,
		"IMSI":       imsi,
		"authorized": authorized,
	})
	if _, err := db.Model(dao.BatchDetail.Table()).Ctx(ctx).Data(do.BatchDetail{
		BatchNo:      batchNo,
		BatchType:    consts.BatchTypeTrafficCutoff,
		DetailStatus: consts.BatchDetailStatusRunning,
		RowNo:        rowNo,
		ItemId:       iccid,
		Snapshot:     snapshot,
	}).Insert(); err != nil {
		t.Fatalf("insert batch detail: %v", err)
	}
}

func seedCard(t *testing.T, ctx context.Context, db gdb.DB, iccid, msisdn, imsi string, status int) {
	t.Helper()
	if _, err := db.Model(dao.TSimCardInfo.Table()).Ctx(ctx).Data(do.TSimCardInfo{
		Iccid:                  iccid,
		Msisdn:                 msisdn,
		Imsi:                   imsi,
		BossCardStatus:         status,
		TrafficCutoffStatus:    0,
		TrafficCutoffThreshold: 0,
		TenantId:               testTenantID,
	}).Insert(); err != nil {
		t.Fatalf("insert sim card: %v", err)
	}
}

func TestReadTrafficCutoffStatusRequiresNewField(t *testing.T) {
	tests := []struct {
		name    string
		info    *gjson.Json
		want    int
		wantErr bool
	}{
		{name: "new field", info: gjson.New(map[string]any{"trafficCutoffStatus": 2}), want: 2},
		{name: "old field only", info: gjson.New(map[string]any{"trafficCutoffEnabled": 1}), wantErr: true},
		{name: "missing batch info", wantErr: true},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := readTrafficCutoffStatus(tt.info)
			if (err != nil) != tt.wantErr {
				t.Fatalf("readTrafficCutoffStatus() error = %v, wantErr %v", err, tt.wantErr)
			}
			if got != tt.want {
				t.Fatalf("readTrafficCutoffStatus() = %d, want %d", got, tt.want)
			}
		})
	}
}

func TestCommitBusinessHappyPathUpdatesAllCards(t *testing.T) {
	ctx := context.Background()
	repo := newTestRepository(t)
	batchNo := "DCT-1"
	seedProcessingBatch(t, ctx, repo.db, batchNo, 2048.125)
	seedRunningDetail(t, ctx, repo.db, batchNo, 1, "898600000000001", "13800000001", "460001000000001", true)
	seedRunningDetail(t, ctx, repo.db, batchNo, 2, "898600000000002", "13800000002", "460001000000002", true)
	seedCard(t, ctx, repo.db, "898600000000001", "13800000001", "460001000000001", 4)
	seedCard(t, ctx, repo.db, "898600000000002", "13800000002", "460001000000002", 4)

	task, err := repo.Load(ctx, batchNo)
	if err != nil {
		t.Fatalf("Load() error = %v", err)
	}
	if err = repo.CommitBusiness(ctx, task); err != nil {
		t.Fatalf("CommitBusiness() error = %v", err)
	}

	assertBatchMainStatus(t, ctx, repo.db, batchNo, consts.BatchAsyncStatusSuccess, consts.BatchRunResultSuccess)
	assertDetailStatusCount(t, ctx, repo.db, batchNo, consts.BatchDetailStatusSuccess, 2)
	assertTrafficCutoff(t, ctx, repo.db, "898600000000001", 1, 2048.125)
	assertTrafficCutoff(t, ctx, repo.db, "898600000000002", 1, 2048.125)
}

func TestCommitBusinessFailsWholeBatchOnMixedStatusWithoutCardUpdate(t *testing.T) {
	ctx := context.Background()
	repo := newTestRepository(t)
	batchNo := "DCT-2"
	seedProcessingBatch(t, ctx, repo.db, batchNo, 1024)
	seedRunningDetail(t, ctx, repo.db, batchNo, 1, "898600000000001", "13800000001", "460001000000001", true)
	seedRunningDetail(t, ctx, repo.db, batchNo, 2, "898600000000002", "13800000002", "460001000000002", true)
	seedCard(t, ctx, repo.db, "898600000000001", "13800000001", "460001000000001", 4)
	seedCard(t, ctx, repo.db, "898600000000002", "13800000002", "460001000000002", 5)

	task, err := repo.Load(ctx, batchNo)
	if err != nil {
		t.Fatalf("Load() error = %v", err)
	}
	if err = repo.CommitBusiness(ctx, task); err != nil {
		t.Fatalf("CommitBusiness() error = %v", err)
	}

	assertBatchMainStatus(t, ctx, repo.db, batchNo, consts.BatchAsyncStatusFailed, consts.BatchRunResultFailed)
	assertDetailStatusCount(t, ctx, repo.db, batchNo, consts.BatchDetailStatusFailed, 2)
	assertTrafficCutoff(t, ctx, repo.db, "898600000000001", 0, 0)
	assertTrafficCutoff(t, ctx, repo.db, "898600000000002", 0, 0)
}

func TestCommitBusinessFailsWholeBatchOnCanceledCardWithoutCardUpdate(t *testing.T) {
	ctx := context.Background()
	repo := newTestRepository(t)
	batchNo := "DCT-3"
	seedProcessingBatch(t, ctx, repo.db, batchNo, 512)
	seedRunningDetail(t, ctx, repo.db, batchNo, 1, "898600000000001", "13800000001", "460001000000001", true)
	seedCard(t, ctx, repo.db, "898600000000001", "13800000001", "460001000000001", 9)

	task, err := repo.Load(ctx, batchNo)
	if err != nil {
		t.Fatalf("Load() error = %v", err)
	}
	if err = repo.CommitBusiness(ctx, task); err != nil {
		t.Fatalf("CommitBusiness() error = %v", err)
	}

	assertBatchMainStatus(t, ctx, repo.db, batchNo, consts.BatchAsyncStatusFailed, consts.BatchRunResultFailed)
	assertTrafficCutoff(t, ctx, repo.db, "898600000000001", 0, 0)
}

func TestUpdateResultFileFailureOnlyMarksBatchInfo(t *testing.T) {
	ctx := context.Background()
	repo := newTestRepository(t)
	batchNo := "DCT-4"
	seedProcessingBatch(t, ctx, repo.db, batchNo, 512)
	seedRunningDetail(t, ctx, repo.db, batchNo, 1, "898600000000001", "13800000001", "460001000000001", true)

	task, err := repo.Load(ctx, batchNo)
	if err != nil {
		t.Fatalf("Load() error = %v", err)
	}
	if err = repo.updateResultFileStatus(ctx, task, "failed", 0, 0, "disk full"); err != nil {
		t.Fatalf("updateResultFileStatus() error = %v", err)
	}

	var row struct {
		Info string `orm:"batch_info"`
	}
	if err = repo.db.Model(dao.BatchMain.Table()).Ctx(ctx).
		Where(dao.BatchMain.Columns().BatchNo, batchNo).
		Fields(dao.BatchMain.Columns().BatchInfo).
		Scan(&row); err != nil {
		t.Fatalf("query batch main: %v", err)
	}
	info := gjson.New([]byte(row.Info))
	if info.Get("resultFile.status").String() != "failed" {
		t.Fatalf("resultFile.status = %s, want failed", info.Get("resultFile.status").String())
	}
	if info.Get("resultFile.error").String() != "disk full" {
		t.Fatalf("resultFile.error = %s, want disk full", info.Get("resultFile.error").String())
	}
	assertBatchMainStatus(t, ctx, repo.db, batchNo, consts.BatchAsyncStatusProcessing, batchdomain.RunResultRunning)
}

func assertBatchMainStatus(t *testing.T, ctx context.Context, db gdb.DB, batchNo string, wantAsync, wantRun int) {
	t.Helper()
	var row struct {
		Async int `orm:"batch_async_status"`
		Run   int `orm:"run_result"`
	}
	if err := db.Model(dao.BatchMain.Table()).Ctx(ctx).
		Where(dao.BatchMain.Columns().BatchNo, batchNo).
		Fields(dao.BatchMain.Columns().BatchAsyncStatus, dao.BatchMain.Columns().RunResult).
		Scan(&row); err != nil {
		t.Fatalf("query batch main: %v", err)
	}
	if row.Async != wantAsync || row.Run != wantRun {
		t.Fatalf("batch status = (async=%d, run=%d), want (async=%d, run=%d)", row.Async, row.Run, wantAsync, wantRun)
	}
}

func assertDetailStatusCount(t *testing.T, ctx context.Context, db gdb.DB, batchNo string, status, want int) {
	t.Helper()
	count, err := db.Model(dao.BatchDetail.Table()).Ctx(ctx).
		Where(dao.BatchDetail.Columns().BatchNo, batchNo).
		Where(dao.BatchDetail.Columns().DetailStatus, status).
		Count()
	if err != nil {
		t.Fatalf("count details: %v", err)
	}
	if count != want {
		t.Fatalf("detail status %d count = %d, want %d", status, count, want)
	}
}

func assertTrafficCutoff(t *testing.T, ctx context.Context, db gdb.DB, iccid string, enabled int, threshold float64) {
	t.Helper()
	var row struct {
		Enabled   int     `orm:"traffic_cutoff_status"`
		Threshold float64 `orm:"traffic_cutoff_threshold"`
	}
	if err := db.Model(dao.TSimCardInfo.Table()).Ctx(ctx).
		Where(dao.TSimCardInfo.Columns().Iccid, iccid).
		Fields(dao.TSimCardInfo.Columns().TrafficCutoffStatus, dao.TSimCardInfo.Columns().TrafficCutoffThreshold).
		Scan(&row); err != nil {
		t.Fatalf("query traffic cutoff fields: %v", err)
	}
	if row.Enabled != enabled || row.Threshold != threshold {
		t.Fatalf("%s cutoff = (%d, %v), want (%d, %v)", iccid, row.Enabled, row.Threshold, enabled, threshold)
	}
}