package rentergrowth

import (
	"encoding/json"
	"testing"

	"hfb_sys/backend/internal/database"
	"hfb_sys/backend/internal/model"
)

func TestDefaultConfigIncludesDepositFreeQuota(t *testing.T) {
	cfg := DefaultConfig()
	wants := map[string]int64{
		DefaultLevelCode: 0,
		"platinum":       DefaultPlatinumQuotaCent,
		"diamond":        DefaultDiamondQuotaCent,
		"peak":           DefaultPeakQuotaCent,
	}
	for _, level := range cfg.Levels {
		if level.DepositFreeQuotaCent != wants[level.Code] {
			t.Fatalf("等级 %s 免押额度 = %d, want %d", level.Code, level.DepositFreeQuotaCent, wants[level.Code])
		}
	}
}

func TestLegacyConfigBackfillsQuotaButKeepsExplicitZero(t *testing.T) {
	legacy := `{"enabled":true,"points_per_yuan":1,"levels":[{"code":"normal","name":"普通","min_points":0,"discount_bps":10000},{"code":"platinum","name":"铂金","min_points":300,"discount_bps":9900},{"code":"diamond","name":"钻石","min_points":1000,"discount_bps":9800},{"code":"peak","name":"巅峰","min_points":5000,"discount_bps":9500}]}`
	cfg, err := ParseConfigValue(legacy)
	if err != nil {
		t.Fatalf("解析旧配置失败：%v", err)
	}
	if LevelForPoints(cfg, 300).DepositFreeQuotaCent != DefaultPlatinumQuotaCent {
		t.Fatalf("旧配置未补齐铂金免押额度")
	}

	var raw map[string]any
	if err := json.Unmarshal([]byte(legacy), &raw); err != nil {
		t.Fatalf("解析测试 JSON 失败：%v", err)
	}
	levels := raw["levels"].([]any)
	levels[1].(map[string]any)["deposit_free_quota_cent"] = float64(0)
	explicitZero, err := json.Marshal(raw)
	if err != nil {
		t.Fatalf("生成测试配置失败：%v", err)
	}
	cfg, err = ParseConfigValue(string(explicitZero))
	if err != nil {
		t.Fatalf("解析显式零额度配置失败：%v", err)
	}
	if LevelForPoints(cfg, 300).DepositFreeQuotaCent != 0 {
		t.Fatalf("显式配置的零额度被默认值覆盖")
	}
}

func TestSnapshotCombinesLevelAndManualDepositQuota(t *testing.T) {
	db := database.NewTestDB()
	if err := db.AutoMigrate(&model.User{}, &model.SystemConfig{}); err != nil {
		t.Fatalf("migrate failed: %v", err)
	}
	user := model.User{Phone: "13800009999", RenterGrowthPoints: 1000, DepositFreeQuotaCent: 30_000}
	if err := db.Create(&user).Error; err != nil {
		t.Fatalf("create user failed: %v", err)
	}
	snapshot, err := SnapshotForUser(db, user.ID)
	if err != nil {
		t.Fatalf("SnapshotForUser() error = %v", err)
	}
	if snapshot.LevelDepositFreeQuotaCent != DefaultDiamondQuotaCent || snapshot.ManualDepositFreeQuotaCent != 30_000 || snapshot.EffectiveDepositFreeQuotaCent != 130_000 {
		t.Fatalf("免押额度快照不正确：%+v", snapshot)
	}
}

func TestSyncAllUserLevelsUsesUpdatedThresholds(t *testing.T) {
	db := database.NewTestDB()
	if err := db.AutoMigrate(&model.User{}); err != nil {
		t.Fatalf("migrate failed: %v", err)
	}
	users := []model.User{
		{Phone: "13800009001", RenterGrowthPoints: 2000, RenterGrowthLevel: DefaultLevelCode},
		{Phone: "13800009002", RenterGrowthPoints: 6000, RenterGrowthLevel: DefaultLevelCode},
	}
	if err := db.Create(&users).Error; err != nil {
		t.Fatalf("create users failed: %v", err)
	}
	if err := SyncAllUserLevels(db, DefaultConfig()); err != nil {
		t.Fatalf("SyncAllUserLevels() error = %v", err)
	}
	var saved []model.User
	if err := db.Order("id ASC").Find(&saved).Error; err != nil {
		t.Fatalf("find users failed: %v", err)
	}
	if saved[0].RenterGrowthLevel != "diamond" || saved[1].RenterGrowthLevel != "peak" {
		t.Fatalf("同步后等级不正确：%s/%s", saved[0].RenterGrowthLevel, saved[1].RenterGrowthLevel)
	}
}

func TestLevelForPointsStartsFromNormal(t *testing.T) {
	cfg := DefaultConfig()
	cases := []struct {
		points int64
		want   string
	}{
		{points: 0, want: DefaultLevelCode},
		{points: 299, want: DefaultLevelCode},
		{points: 300, want: "platinum"},
		{points: 1000, want: "diamond"},
		{points: 5000, want: "peak"},
	}
	for _, tc := range cases {
		got := LevelForPoints(cfg, tc.points)
		if got.Code != tc.want {
			t.Fatalf("LevelForPoints(%d) = %q, want %q", tc.points, got.Code, tc.want)
		}
	}
}

func TestCalculateDiscountCentCapsAtPlatformFee(t *testing.T) {
	if got := CalculateDiscountCent(10000, 60, 9900); got != 60 {
		t.Fatalf("discount = %d, want capped platform fee 60", got)
	}
	if got := CalculateDiscountCent(10000, 1000, 9900); got != 100 {
		t.Fatalf("discount = %d, want 100", got)
	}
	if got := CalculateDiscountCent(10000, 1000, DefaultDiscountBps); got != 0 {
		t.Fatalf("normal discount = %d, want 0", got)
	}
}

func TestAwardOrderCompletedUpdatesUserAndIsIdempotent(t *testing.T) {
	db := database.NewTestDB()
	if err := db.AutoMigrate(
		&model.User{},
		&model.RentalOrder{},
		&model.SystemConfig{},
		&model.RenterGrowthLedger{},
	); err != nil {
		t.Fatalf("migrate failed: %v", err)
	}
	user := model.User{
		Phone:              "13800008888",
		RenterGrowthPoints: 290,
		RenterGrowthLevel:  DefaultLevelCode,
	}
	if err := db.Create(&user).Error; err != nil {
		t.Fatalf("create user failed: %v", err)
	}
	order := model.RentalOrder{
		OrderNo:        "RG202607260001",
		RenterID:       user.ID,
		RentAmountCent: 2000,
	}
	if err := db.Create(&order).Error; err != nil {
		t.Fatalf("create order failed: %v", err)
	}

	if err := AwardOrderCompleted(db, &order, 2000, SourceOrderCompleted); err != nil {
		t.Fatalf("AwardOrderCompleted() error = %v", err)
	}
	if order.GrowthPointsAwarded != 20 || order.GrowthPointsAwardedAt == nil {
		t.Fatalf("order awarded = %d at %v, want 20 with time", order.GrowthPointsAwarded, order.GrowthPointsAwardedAt)
	}
	if order.GrowthPointsBasisCent != 2000 || order.GrowthPointsPerYuan != 1 {
		t.Fatalf("order points basis = %d x %d, want 2000 x 1", order.GrowthPointsBasisCent, order.GrowthPointsPerYuan)
	}
	var savedUser model.User
	if err := db.First(&savedUser, user.ID).Error; err != nil {
		t.Fatalf("find user failed: %v", err)
	}
	if savedUser.RenterGrowthPoints != 310 || savedUser.RenterGrowthLevel != "platinum" {
		t.Fatalf("user growth = %d/%s, want 310/platinum", savedUser.RenterGrowthPoints, savedUser.RenterGrowthLevel)
	}

	freshOrder := order
	freshOrder.GrowthPointsAwarded = 0
	freshOrder.GrowthPointsAwardedAt = nil
	if err := AwardOrderCompleted(db, &freshOrder, 2000, SourceOrderCompleted); err != nil {
		t.Fatalf("second AwardOrderCompleted() error = %v", err)
	}
	if err := db.First(&savedUser, user.ID).Error; err != nil {
		t.Fatalf("find user after second award failed: %v", err)
	}
	if savedUser.RenterGrowthPoints != 310 {
		t.Fatalf("user points after second award = %d, want unchanged 310", savedUser.RenterGrowthPoints)
	}
	var ledgerCount int64
	if err := db.Model(&model.RenterGrowthLedger{}).Where("order_id = ?", order.ID).Count(&ledgerCount).Error; err != nil {
		t.Fatalf("count ledger failed: %v", err)
	}
	if ledgerCount != 1 {
		t.Fatalf("ledger count = %d, want 1", ledgerCount)
	}

	if err := RevokeOrderCompleted(db, &order); err != nil {
		t.Fatalf("RevokeOrderCompleted() error = %v", err)
	}
	if err := RevokeOrderCompleted(db, &order); err != nil {
		t.Fatalf("second RevokeOrderCompleted() error = %v", err)
	}
	if err := db.First(&savedUser, user.ID).Error; err != nil {
		t.Fatalf("find user after revoke failed: %v", err)
	}
	if savedUser.RenterGrowthPoints != 290 || savedUser.RenterGrowthLevel != DefaultLevelCode {
		t.Fatalf("user growth after revoke = %d/%s, want 290/%s", savedUser.RenterGrowthPoints, savedUser.RenterGrowthLevel, DefaultLevelCode)
	}
	if err := db.Model(&model.RenterGrowthLedger{}).Where("order_id = ?", order.ID).Count(&ledgerCount).Error; err != nil {
		t.Fatalf("count ledger after revoke failed: %v", err)
	}
	if ledgerCount != 2 {
		t.Fatalf("ledger count after revoke = %d, want 2", ledgerCount)
	}
}

func TestRevokeOrderCompletedRecordsIdempotencyWhenUserHasNoPoints(t *testing.T) {
	db := database.NewTestDB()
	if err := db.AutoMigrate(
		&model.User{},
		&model.RentalOrder{},
		&model.SystemConfig{},
		&model.RenterGrowthLedger{},
	); err != nil {
		t.Fatalf("migrate failed: %v", err)
	}
	user := model.User{Phone: "13800008889", RenterGrowthLevel: DefaultLevelCode}
	if err := db.Create(&user).Error; err != nil {
		t.Fatalf("create user failed: %v", err)
	}
	order := model.RentalOrder{
		OrderNo:               "RG202607260002",
		RenterID:              user.ID,
		GrowthPointsAwarded:   20,
		GrowthPointsBasisCent: 2000,
		GrowthPointsPerYuan:   1,
	}
	if err := db.Create(&order).Error; err != nil {
		t.Fatalf("create order failed: %v", err)
	}
	if err := RevokeOrderCompleted(db, &order); err != nil {
		t.Fatalf("RevokeOrderCompleted() error = %v", err)
	}
	if err := db.Model(&model.User{}).Where("id = ?", user.ID).Update("renter_growth_points", 100).Error; err != nil {
		t.Fatalf("add later points failed: %v", err)
	}
	if err := RevokeOrderCompleted(db, &order); err != nil {
		t.Fatalf("repeat RevokeOrderCompleted() error = %v", err)
	}
	var saved model.User
	if err := db.First(&saved, user.ID).Error; err != nil {
		t.Fatalf("find user failed: %v", err)
	}
	if saved.RenterGrowthPoints != 100 {
		t.Fatalf("later points after repeated callback = %d, want 100", saved.RenterGrowthPoints)
	}
	var ledger model.RenterGrowthLedger
	if err := db.Where("order_id = ? AND source = ?", order.ID, SourceOrderRefunded).First(&ledger).Error; err != nil {
		t.Fatalf("find revoke ledger failed: %v", err)
	}
	if ledger.Points != 0 {
		t.Fatalf("revoke ledger points = %d, want 0", ledger.Points)
	}
}