package dnfbridge

import (
	"testing"

	dnfrepo "longheng.io/server/internal/modules/dnf/repository"
	"longheng.io/server/internal/modules/dnf/worldmap"
)

func characterRecordWithLevel(level int) dnfrepo.CharacterRecord {
	return dnfrepo.CharacterRecord{CharacterID: "1", AccountID: "dnf:test", Level: level}
}

// [mob level charac level replace flag] 1：怪物等级必须改用入场角色等级，
// 而不是 [basis level] 或怪物行的绝对等级。
func TestCurrentDungeonMonsterLevelReplacesWithCharacterLevel(t *testing.T) {
	dungeon := func(flag int64) worldmap.Dungeon {
		return worldmap.Dungeon{
			ID: 4906,
			Metadata: worldmap.DungeonMetadata{
				BasisLevel: worldmap.OptionalInt{Value: 50, Set: true},
				IntegerValues: map[string]int64{
					"mob level charac level replace flag": flag,
				},
			},
		}
	}

	// flag=1：忽略 basis 与怪物行，直接用入场角色等级。
	runtime := &runtimeDungeonState{
		Dungeon:     dungeon(1),
		Character:   characterRecordWithLevel(90),
		entryCharacterLevel: 90,
	}
	got, err := currentDungeonMonsterLevel(worldmap.MonsterSpawn{AutoLevel: 12}, runtime)
	if err != nil {
		t.Fatal(err)
	}
	if got != 90 {
		t.Fatalf("replace flag=1: level=%d want=90 (character level)", got)
	}

	// flag=1 且相对行：仍然用角色等级，不叠加 basis。
	got, err = currentDungeonMonsterLevel(worldmap.MonsterSpawn{Level: 1, AutoLevel: 12}, runtime)
	if err != nil {
		t.Fatal(err)
	}
	if got != 90 {
		t.Fatalf("replace flag=1 relative row: level=%d want=90", got)
	}

	// flag=0：保持原行为（绝对等级）。
	plain := &runtimeDungeonState{
		Dungeon:   dungeon(0),
		Character: characterRecordWithLevel(90),
	}
	got, err = currentDungeonMonsterLevel(worldmap.MonsterSpawn{AutoLevel: 12}, plain)
	if err != nil {
		t.Fatal(err)
	}
	if got != 12 {
		t.Fatalf("replace flag=0 absolute row: level=%d want=12", got)
	}

	// flag=0 且相对行：basis 仍生效。
	got, err = currentDungeonMonsterLevel(worldmap.MonsterSpawn{Level: 1, AutoLevel: 12}, plain)
	if err != nil {
		t.Fatal(err)
	}
	if got != 62 {
		t.Fatalf("replace flag=0 relative row: level=%d want=62 (12+50)", got)
	}

	// flag=1 但角色快照缺失：回落到 entryCharacterLevel。
	fallback := &runtimeDungeonState{
		Dungeon:             dungeon(1),
		entryCharacterLevel: 77,
	}
	got, err = currentDungeonMonsterLevel(worldmap.MonsterSpawn{AutoLevel: 12}, fallback)
	if err != nil {
		t.Fatal(err)
	}
	if got != 77 {
		t.Fatalf("replace flag=1 without character: level=%d want=77 (entry snapshot)", got)
	}

	// 未声明该段（nil map）时按 0 处理，保持原行为。
	undeclared := &runtimeDungeonState{
		Dungeon: worldmap.Dungeon{Metadata: worldmap.DungeonMetadata{
			BasisLevel: worldmap.OptionalInt{Value: 50, Set: true},
		}},
		Character: characterRecordWithLevel(90),
	}
	got, err = currentDungeonMonsterLevel(worldmap.MonsterSpawn{AutoLevel: 12}, undeclared)
	if err != nil {
		t.Fatal(err)
	}
	if got != 12 {
		t.Fatalf("undeclared replace flag: level=%d want=12", got)
	}
}

// [gold card use]：只有**显式声明 0** 才让付费侧整条关闭；
// **未声明该段**的老副本必须保持付费翻牌可用。
func TestDungeonCardPaidSideDisabledWhenGoldCardUseZero(t *testing.T) {
	// 显式声明 0（周常五图的写法）：判定为禁用。
	explicitZero := worldmap.Dungeon{ID: 4906, Metadata: worldmap.DungeonMetadata{
		IntegerValues: map[string]int64{"gold card use": 0},
	}}
	if got, declared := currentDungeonGoldCardUse(explicitZero); got != 0 || !declared {
		t.Fatalf("显式 0: gold card use=%d declared=%v want=0,true", got, declared)
	}

	// 未声明该段（Act1 等老副本）：必须回报 declared=false，不能被当成 0 关掉付费侧。
	undeclared := worldmap.Dungeon{ID: 1000, Metadata: worldmap.DungeonMetadata{}}
	if got, declared := currentDungeonGoldCardUse(undeclared); got != 0 || declared {
		t.Fatalf("未声明: gold card use=%d declared=%v want=0,false", got, declared)
	}
	// nil 映射同样是"未声明"。
	undeclaredNilMap := worldmap.Dungeon{ID: 1000, Metadata: worldmap.DungeonMetadata{IntegerValues: nil}}
	if _, declared := currentDungeonGoldCardUse(undeclaredNilMap); declared {
		t.Fatal("nil 映射必须回报 declared=false")
	}

	nonzero := worldmap.Dungeon{ID: 1, Metadata: worldmap.DungeonMetadata{
		IntegerValues: map[string]int64{"gold card use": 1},
	}}
	if got, declared := currentDungeonGoldCardUse(nonzero); got != 1 || !declared {
		t.Fatalf("gold card use=%d declared=%v want=1,true", got, declared)
	}

	// 禁用标记下，付费侧的选择必须被拒绝。
	state, err := newDungeonCardState(dungeonCardRewardPlan{
		ID: "plan", CharacterID: "1", Source: "test", PaidCardDisabled: true,
	})
	if err != nil {
		t.Fatal(err)
	}
	if _, _, err := state.reserveSelection(dungeonCardSidePaid, 0); err == nil {
		t.Fatal("paid side selection must be rejected when PaidCardDisabled")
	}
	// 免费侧仍可正常选择。
	if _, _, err := state.reserveSelection(dungeonCardSideFree, 0); err != nil {
		t.Fatalf("free side must stay selectable: %v", err)
	}

	// 未声明（未禁用）时，付费侧必须能被选中并拿到一份可发放的奖励。
	enabled, err := newDungeonCardState(dungeonCardRewardPlan{
		ID: "plan", CharacterID: "1", Source: "test",
		Sides: [dungeonCardSideCount]dungeonCardRewardBundle{
			dungeonCardSidePaid: {Gold: 255},
		},
	})
	if err != nil {
		t.Fatal(err)
	}
	reservation, _, err := enabled.reserveSelection(dungeonCardSidePaid, 0)
	if err != nil {
		t.Fatalf("未声明 gold card use 时付费侧必须可选: %v", err)
	}
	if !reservation.grant {
		t.Fatal("未声明 gold card use 时付费侧必须发放奖励")
	}
}