package modules

import (
	"context"
	"database/sql"
	"encoding/json"
	"fmt"
	"math"
	"math/rand"
	"time"

	"github.com/heroiclabs/nakama-common/runtime"

	"github.com/honghuang-game/server/config"
	"github.com/honghuang-game/server/internal/db"
	"github.com/honghuang-game/server/internal/domain"
)

var realmSvc *RealmService

// RegisterRealm 注册修炼/境界相关 RPC。
func RegisterRealm(initializer runtime.Initializer) error {
	realmSvc = NewRealmService(db.NewPgxRealmStore(), config.Global)

	if err := initializer.RegisterRpc("RealmService/GetRealmProgress", getRealmProgress); err != nil {
		return err
	}
	if err := initializer.RegisterRpc("RealmService/Cultivate", cultivate); err != nil {
		return err
	}
	if err := initializer.RegisterRpc("RealmService/AttemptBreakthrough", attemptBreakthrough); err != nil {
		return err
	}
	if err := initializer.RegisterRpc("RealmService/StartTribulation", startTribulation); err != nil {
		return err
	}
	if err := initializer.RegisterRpc("RealmService/GetTribulationResult", getTribulationResult); err != nil {
		return err
	}
	if err := initializer.RegisterRpc("RealmService/WorldBreak", worldBreak); err != nil {
		return err
	}
	return nil
}

// RealmService 实现境界/渡劫/破界业务逻辑，便于单元测试 mock 存储层。
type RealmService struct {
	store     db.RealmStore
	cfg       *config.Config
	randFloat func() float64
}

// NewRealmService 创建境界服务实例。
func NewRealmService(store db.RealmStore, cfg *config.Config) *RealmService {
	return &RealmService{
		store:     store,
		cfg:       cfg,
		randFloat: rand.Float64,
	}
}

// ---------------------------------------------------------------------------
// 请求/响应结构
// ---------------------------------------------------------------------------

type realmReq struct {
	CharacterID string `json:"character_id"`
}

type cultivateReq struct {
	CharacterID    string            `json:"character_id"`
	StaminaAmount  int32             `json:"stamina_amount"`
	Consumables    []materialCostReq `json:"consumables"`
}

type breakthroughReq struct {
	CharacterID      string            `json:"character_id"`
	TargetMinorRealm int32             `json:"target_minor_realm"`
	Consumables      []materialCostReq `json:"consumables"`
	HelperIDs        []string          `json:"helper_ids"`
	IdempotencyKey   string            `json:"idempotency_key"`
}

type tribulationReq struct {
	CharacterID      string            `json:"character_id"`
	TargetRealmTier  int32             `json:"target_realm_tier"`
	TribulationType  string            `json:"tribulation_type"`
	Consumables      []materialCostReq `json:"consumables"`
	HelperIDs        []string          `json:"helper_ids"`
}

type worldBreakReq struct {
	CharacterID       string `json:"character_id"`
	TargetWorldTier   int32  `json:"target_world_tier"`
	KeyItemInstanceID string `json:"key_item_instance_id"`
	Confirm           bool   `json:"confirm"`
}

type materialCostReq struct {
	InventoryID string `json:"inventory_id"`
	Quantity    int32  `json:"quantity"`
}

type realmPointData struct {
	RealmTier  int32 `json:"realm_tier"`
	MinorRealm int32 `json:"minor_realm"`
}

type realmProgressData struct {
	RealmTier            int32  `json:"realm_tier"`
	MinorRealm           int32  `json:"minor_realm"`
	RealmName            string `json:"realm_name"`
	Exp                  int64  `json:"exp"`
	ExpToNext            int64  `json:"exp_to_next"`
	MaxUnlockedWorldTier int32  `json:"max_unlocked_world_tier"`
	RealmStatus          string `json:"realm_status"`
	BreakthroughReady    bool   `json:"breakthrough_ready"`
	TribulationPending   bool   `json:"tribulation_pending"`
	StaminaCurrent       int32  `json:"stamina_current,omitempty"`
	StaminaMax           int32  `json:"stamina_max,omitempty"`
}

type cultivateData struct {
	RealmPointData      realmPointData `json:"realm_point"`
	ExpGained           int64          `json:"exp_gained"`
	ExpToNext           int64          `json:"exp_to_next"`
	BreakthroughReady   bool           `json:"breakthrough_ready"`
	StaminaRemaining    int32          `json:"stamina_remaining"`
	EventTriggered      string         `json:"event_triggered"`
	EventBonusExp       int64          `json:"event_bonus_exp"`
}

type breakthroughData struct {
	Success      bool           `json:"success"`
	From         realmPointData `json:"from"`
	To           realmPointData `json:"to"`
	ExpConsumed  int64          `json:"exp_consumed"`
	RecordID     string         `json:"record_id"`
	SpecialEvent string         `json:"special_event"`
}

type tribulationData struct {
	TribulationID       string      `json:"tribulation_id"`
	Status              string      `json:"status"`
	BaseSuccessRate     float64     `json:"base_success_rate"`
	ModifiedSuccessRate float64     `json:"modified_success_rate"`
	EstimatedTicks      int32       `json:"estimated_ticks"`
	StartAt             string      `json:"start_at"`
	Result              string      `json:"result"`
	FromRealmTier       int32       `json:"from_realm_tier"`
	ToRealmTier         int32       `json:"to_realm_tier"`
	Penalties           interface{} `json:"penalties"`
	Drops               interface{} `json:"drops"`
}

type worldBreakData struct {
	Success              bool   `json:"success"`
	FromWorldTier        int32  `json:"from_world_tier"`
	ToWorldTier          int32  `json:"to_world_tier"`
	FromRealmTier        int32  `json:"from_realm_tier"`
	ToRealmTier          int32  `json:"to_realm_tier"`
	BreakthroughRecordID string `json:"breakthrough_record_id"`
	WorldEvent           string `json:"world_event"`
	RuinGenerated        bool   `json:"ruin_generated"`
}

// ---------------------------------------------------------------------------
// RPC Handlers
// ---------------------------------------------------------------------------

func getRealmProgress(ctx context.Context, logger runtime.Logger, _db *sql.DB, nk runtime.NakamaModule, payload string) (string, error) {
	traceID := newTraceID()
	var req realmReq
	if err := json.Unmarshal([]byte(payload), &req); err != nil || req.CharacterID == "" {
		return errResp(3001, "invalid payload", traceID)
	}
	resp, code, msg := realmSvc.GetRealmProgress(ctx, req.CharacterID)
	if code != 0 {
		return errResp(code, msg, traceID)
	}
	logger.Info("RealmService/GetRealmProgress: character_id=%s", req.CharacterID)
	return okResp(resp, traceID)
}

func cultivate(ctx context.Context, logger runtime.Logger, _db *sql.DB, nk runtime.NakamaModule, payload string) (string, error) {
	traceID := newTraceID()
	var req cultivateReq
	if err := json.Unmarshal([]byte(payload), &req); err != nil || req.CharacterID == "" {
		return errResp(3001, "invalid payload", traceID)
	}
	resp, code, msg := realmSvc.Cultivate(ctx, req)
	if code != 0 {
		return errResp(code, msg, traceID)
	}
	logger.Info("RealmService/Cultivate: character_id=%s stamina=%d", req.CharacterID, req.StaminaAmount)
	return okResp(resp, traceID)
}

func attemptBreakthrough(ctx context.Context, logger runtime.Logger, _db *sql.DB, nk runtime.NakamaModule, payload string) (string, error) {
	traceID := newTraceID()
	var req breakthroughReq
	if err := json.Unmarshal([]byte(payload), &req); err != nil || req.CharacterID == "" {
		return errResp(3001, "invalid payload", traceID)
	}
	resp, code, msg := realmSvc.AttemptBreakthrough(ctx, req)
	if code != 0 {
		return errResp(code, msg, traceID)
	}
	logger.Info("RealmService/AttemptBreakthrough: character_id=%s success=%v", req.CharacterID, resp.Success)
	return okResp(resp, traceID)
}

func startTribulation(ctx context.Context, logger runtime.Logger, _db *sql.DB, nk runtime.NakamaModule, payload string) (string, error) {
	traceID := newTraceID()
	var req tribulationReq
	if err := json.Unmarshal([]byte(payload), &req); err != nil || req.CharacterID == "" {
		return errResp(3007, "invalid payload", traceID)
	}
	resp, code, msg := realmSvc.StartTribulation(ctx, req)
	if code != 0 {
		return errResp(code, msg, traceID)
	}
	logger.Info("RealmService/StartTribulation: character_id=%s result=%s", req.CharacterID, resp.Result)
	return okResp(resp, traceID)
}

func getTribulationResult(ctx context.Context, logger runtime.Logger, _db *sql.DB, nk runtime.NakamaModule, payload string) (string, error) {
	traceID := newTraceID()
	var req tribulationReq
	if err := json.Unmarshal([]byte(payload), &req); err != nil || req.CharacterID == "" {
		return errResp(3007, "invalid payload", traceID)
	}
	resp, code, msg := realmSvc.GetTribulationResult(ctx, req.CharacterID)
	if code != 0 {
		return errResp(code, msg, traceID)
	}
	logger.Info("RealmService/GetTribulationResult: character_id=%s", req.CharacterID)
	return okResp(resp, traceID)
}

func worldBreak(ctx context.Context, logger runtime.Logger, _db *sql.DB, nk runtime.NakamaModule, payload string) (string, error) {
	traceID := newTraceID()
	var req worldBreakReq
	if err := json.Unmarshal([]byte(payload), &req); err != nil || req.CharacterID == "" {
		return errResp(3011, "invalid payload", traceID)
	}
	if !req.Confirm {
		return errResp(3011, "confirmation required", traceID)
	}
	resp, code, msg := realmSvc.WorldBreak(ctx, req)
	if code != 0 {
		return errResp(code, msg, traceID)
	}
	logger.Info("RealmService/WorldBreak: character_id=%s to_world=%d", req.CharacterID, req.TargetWorldTier)
	return okResp(resp, traceID)
}

// ---------------------------------------------------------------------------
// 业务逻辑
// ---------------------------------------------------------------------------

func (s *RealmService) getConfigFloat(key string, def float64) float64 {
	if s.cfg == nil {
		return def
	}
	return s.cfg.GetFloat64(key, def)
}

func (s *RealmService) getConfigInt(key string, def int) int {
	if s.cfg == nil {
		return def
	}
	return s.cfg.GetInt(key, def)
}

func (s *RealmService) expToNext(tier, minor int32) int64 {
	key := domain.ExpConfigKey(tier, minor)
	if s.cfg != nil {
		if v := s.cfg.GetInt(key, 0); v > 0 {
			return int64(v)
		}
	}
	return domain.DefaultExpToNext(tier, minor)
}

func (s *RealmService) dailyStaminaMax(realmTier int32) int32 {
	// 按 GDD-21 境界体力锚点
	switch realmTier {
	case 1:
		return 120
	case 2:
		return 150
	case 3:
		return 180
	case 4:
		return 210
	case 5:
		return 240
	case 6:
		return 300
	}
	return 120
}

func (s *RealmService) expPerStamina(realmTier int32) int64 {
	// 默认 1 体力 = 100 修为；可按 Nacos 热更
	return int64(s.getConfigInt("realm.exp_per_stamina", 100))
}

func (s *RealmService) getStamina(baseStats map[string]interface{}) (current, max int32) {
	max = 120
	if v, ok := baseStats["stamina_max"]; ok {
		max = int32(toFloat64(v))
	}
	if v, ok := baseStats["stamina_current"]; ok {
		current = int32(toFloat64(v))
	} else {
		current = max
	}
	return
}

func (s *RealmService) setStamina(baseStats map[string]interface{}, current, max int32) {
	baseStats["stamina_max"] = max
	baseStats["stamina_current"] = current
}

func toFloat64(v interface{}) float64 {
	switch n := v.(type) {
	case float64:
		return n
	case float32:
		return float64(n)
	case int:
		return float64(n)
	case int32:
		return float64(n)
	case int64:
		return float64(n)
	}
	return 0
}

// GetRealmProgress 查询角色当前境界、小境界、修为与状态。
func (s *RealmService) GetRealmProgress(ctx context.Context, characterID string) (realmProgressData, int, string) {
	c, err := s.store.GetCharacter(ctx, characterID)
	if err != nil {
		return realmProgressData{}, 3001, "character not found"
	}
	cr, err := s.store.EnsureCharacterRealm(ctx, characterID, c.RealmTier, c.MinorRealm)
	if err != nil {
		return realmProgressData{}, 3001, "realm data missing"
	}
	expToNext := s.expToNext(c.RealmTier, c.MinorRealm)
	staminaCurrent, staminaMax := s.getStamina(c.BaseStats)
	return realmProgressData{
		RealmTier:            c.RealmTier,
		MinorRealm:           c.MinorRealm,
		RealmName:            domain.RealmFullName(c.RealmTier, c.MinorRealm),
		Exp:                  cr.ExpInTier,
		ExpToNext:            expToNext,
		MaxUnlockedWorldTier: c.WorldTier,
		RealmStatus:          c.RealmStatus,
		BreakthroughReady:    cr.ExpInTier >= expToNext && c.RealmStatus == domain.RealmStatusNormal,
		TribulationPending:   c.RealmStatus == domain.RealmStatusTribulationPending,
		StaminaCurrent:       staminaCurrent,
		StaminaMax:           staminaMax,
	}, 0, ""
}

// Cultivate 消耗体力/资源增加修为，并概率触发修炼事件。
func (s *RealmService) Cultivate(ctx context.Context, req cultivateReq) (cultivateData, int, string) {
	c, err := s.store.GetCharacter(ctx, req.CharacterID)
	if err != nil {
		return cultivateData{}, 3001, "character not found"
	}
	if c.Status != "active" {
		return cultivateData{}, 3004, "character not active"
	}
	if c.RealmStatus == domain.RealmStatusTribulationPending {
		return cultivateData{}, 3004, "tribulation pending"
	}

	staminaCurrent, staminaMax := s.getStamina(c.BaseStats)
	if req.StaminaAmount <= 0 {
		req.StaminaAmount = 1
	}
	if staminaCurrent < req.StaminaAmount {
		return cultivateData{}, 3002, "insufficient stamina"
	}

	// 消耗道具（如有）
	for _, m := range req.Consumables {
		itemID, qty, err := s.store.GetInventoryItem(ctx, req.CharacterID, m.InventoryID)
		if err != nil || qty < m.Quantity {
			return cultivateData{}, 3002, fmt.Sprintf("consumable insufficient: %s", m.InventoryID)
		}
		if err := s.store.ConsumeInventoryItem(ctx, req.CharacterID, m.InventoryID, m.Quantity); err != nil {
			return cultivateData{}, 3002, "failed to consume material"
		}
		_ = itemID
	}

	// 消耗体力
	staminaCurrent -= req.StaminaAmount
	s.setStamina(c.BaseStats, staminaCurrent, staminaMax)
	if err := s.store.UpdateCharacterBaseStats(ctx, req.CharacterID, c.BaseStats); err != nil {
		return cultivateData{}, 9002, "failed to update stamina"
	}

	cr, err := s.store.EnsureCharacterRealm(ctx, req.CharacterID, c.RealmTier, c.MinorRealm)
	if err != nil {
		return cultivateData{}, 3001, "realm data missing"
	}

	expToNext := s.expToNext(c.RealmTier, c.MinorRealm)
	baseGain := int64(req.StaminaAmount) * s.expPerStamina(c.RealmTier)
	bonusExp, event := s.applyCultivationEvent(baseGain, expToNext)
	newExp := cr.ExpInTier + baseGain + bonusExp
	if newExp > expToNext*2 {
		newExp = expToNext * 2 // 防止极端溢出
	}

	realmStatus := c.RealmStatus
	if newExp >= expToNext && realmStatus == domain.RealmStatusNormal {
		realmStatus = domain.RealmStatusBreakthroughReady
	}
	if err := s.store.UpdateCharacterRealm(ctx, req.CharacterID, c.RealmTier, c.MinorRealm, newExp, realmStatus); err != nil {
		return cultivateData{}, 9002, "failed to update realm"
	}

	return cultivateData{
		RealmPointData:    realmPointData{RealmTier: c.RealmTier, MinorRealm: c.MinorRealm},
		ExpGained:         baseGain + bonusExp,
		ExpToNext:         expToNext,
		BreakthroughReady: realmStatus == domain.RealmStatusBreakthroughReady,
		StaminaRemaining:  staminaCurrent,
		EventTriggered:    event,
		EventBonusExp:     bonusExp,
	}, 0, ""
}

func (s *RealmService) applyCultivationEvent(baseGain, expToNext int64) (int64, string) {
	if expToNext <= 0 {
		return 0, ""
	}
	chancePer10Pct := s.getConfigFloat("event.cultivation.trigger_chance_per_10pct", 0.05)
	progressRatio := float64(baseGain) / float64(expToNext)
	tens := int(math.Floor(progressRatio * 10))
	if tens < 1 {
		tens = 1
	}
	for i := 0; i < tens; i++ {
		if s.randFloat() < chancePer10Pct {
			eventRoll := s.randFloat()
			switch {
			case eventRoll < 0.4:
				return int64(float64(expToNext) * 0.3), "小顿悟·功法进度+30%"
			case eventRoll < 0.7:
				return int64(float64(expToNext) * 0.5), "灵气异动·修为暴涨"
			case eventRoll < 0.9:
				return 0, "心魔来袭·SAN动荡"
			default:
				return 0, "奇遇NPC·待后续领取"
			}
		}
	}
	return 0, ""
}

// AttemptBreakthrough 小境界突破（层内初期→中期→圆满）。
func (s *RealmService) AttemptBreakthrough(ctx context.Context, req breakthroughReq) (breakthroughData, int, string) {
	c, err := s.store.GetCharacter(ctx, req.CharacterID)
	if err != nil {
		return breakthroughData{}, 3001, "character not found"
	}
	if c.Status != "active" {
		return breakthroughData{}, 3004, "character not active"
	}
	if c.RealmStatus == domain.RealmStatusTribulationPending {
		return breakthroughData{}, 3004, "tribulation pending"
	}
	if req.TargetMinorRealm != c.MinorRealm+1 {
		return breakthroughData{}, 3003, "invalid target minor realm"
	}
	if req.TargetMinorRealm > 3 {
		return breakthroughData{}, 3003, "already at tier peak"
	}

	cr, err := s.store.EnsureCharacterRealm(ctx, req.CharacterID, c.RealmTier, c.MinorRealm)
	if err != nil {
		return breakthroughData{}, 3001, "realm data missing"
	}
	expToNext := s.expToNext(c.RealmTier, c.MinorRealm)
	if cr.ExpInTier < expToNext {
		return breakthroughData{}, 3002, "exp insufficient"
	}

	// 消耗材料
	if err := s.consumeMaterials(ctx, req.CharacterID, req.Consumables); err != nil {
		return breakthroughData{}, 3002, err.Error()
	}

	// 护法者基础校验
	helpers := req.HelperIDs
	if len(helpers) > 0 {
		count, err := s.store.CountCharacters(ctx, helpers)
		if err != nil || count != len(helpers) {
			return breakthroughData{}, 3005, "helper condition not met"
		}
	}

	successRate := s.calcBreakthroughRate(c, c.RealmTier, false, helpers)
	rolled := s.randFloat()
	success := rolled < successRate

	from := realmPointData{RealmTier: c.RealmTier, MinorRealm: c.MinorRealm}
	to := from
	specialEvent := ""
	if success {
		to.MinorRealm = req.TargetMinorRealm
		if err := s.store.UpdateCharacterRealm(ctx, req.CharacterID, to.RealmTier, to.MinorRealm, 0, domain.RealmStatusNormal); err != nil {
			return breakthroughData{}, 9002, "failed to update realm"
		}
		specialEvent = "突破成功"
	} else {
		// 小境界突破失败不跨层掉落，但损失部分修为
		penaltyExp := cr.ExpInTier / 10
		newExp := cr.ExpInTier - penaltyExp
		if newExp < 0 {
			newExp = 0
		}
		if err := s.store.UpdateCharacterRealm(ctx, req.CharacterID, c.RealmTier, c.MinorRealm, newExp, domain.RealmStatusNormal); err != nil {
			return breakthroughData{}, 9002, "failed to update realm"
		}
		specialEvent = "突破失败·修为受损"
	}

	rec := &db.BreakthroughRecord{
		CharacterID:         req.CharacterID,
		FromRealmTier:       from.RealmTier,
		ToRealmTier:         to.RealmTier,
		FromMinorRealm:      from.MinorRealm,
		ToMinorRealm:        to.MinorRealm,
		IsSuccess:           success,
		IsBreakWorldBarrier: false,
		SourceWorldTier:     c.WorldTier,
		TargetWorldTier:     c.WorldTier,
	}
	if err := s.store.InsertBreakthroughRecord(ctx, rec); err != nil {
		return breakthroughData{}, 9002, "failed to record breakthrough"
	}

	return breakthroughData{
		Success:      success,
		From:         from,
		To:           to,
		ExpConsumed:  expToNext,
		RecordID:     "", // record id not returned by current schema insert; left empty intentionally
		SpecialEvent: specialEvent,
	}, 0, ""
}

func (s *RealmService) consumeMaterials(ctx context.Context, characterID string, materials []materialCostReq) error {
	for _, m := range materials {
		if m.InventoryID == "" || m.Quantity <= 0 {
			continue
		}
		itemID, qty, err := s.store.GetInventoryItem(ctx, characterID, m.InventoryID)
		if err != nil || qty < m.Quantity {
			return fmt.Errorf("material insufficient: %s", m.InventoryID)
		}
		has, err := s.store.HasInventoryItem(ctx, characterID, m.InventoryID, itemID, m.Quantity)
		if err != nil || !has {
			return fmt.Errorf("material insufficient: %s", m.InventoryID)
		}
		if err := s.store.ConsumeInventoryItem(ctx, characterID, m.InventoryID, m.Quantity); err != nil {
			return fmt.Errorf("failed to consume material: %s", m.InventoryID)
		}
	}
	return nil
}

func (s *RealmService) calcBreakthroughRate(c *db.Character, tier int32, isBig bool, helpers []string) float64 {
	base := domain.DefaultTribulationBaseRate(tier, isBig)
	base = s.getConfigFloat(domain.TribulationBaseRateKey(tier, isBig), base)
	rate := base

	// 中期→圆满加成
	if !isBig && c.MinorRealm == 2 {
		rate += s.getConfigFloat("tribulation.mid_to_full_bonus", 0.02)
	}
	// 圆满→下境初期惩罚（仅大境界渡劫）
	if isBig {
		rate += s.getConfigFloat("tribulation.full_to_next_penalty", -0.03)
	}
	// 罪孽惩罚
	sinPenalty := math.Min(0.4, float64(c.CrimeScore)/5000.0*0.4)
	rate -= sinPenalty
	// 天道值减免
	heavenMitigation := math.Min(0.05, float64(c.HeavenlyValue)/50.0*0.01)
	rate += heavenMitigation
	// 护法者（每位+2%，上限10%）
	helperBonus := float64(len(helpers)) * 0.02
	if helperBonus > 0.10 {
		helperBonus = 0.10
	}
	rate += helperBonus

	cap := s.getConfigFloat("tribulation.success_cap", 0.95)
	floor := s.getConfigFloat("tribulation.success_floor", 0.05)
	if rate > cap {
		rate = cap
	}
	if rate < floor {
		rate = floor
	}
	return rate
}

// StartTribulation 大境界渡劫。当前版本同步结算并返回 completed 状态。
func (s *RealmService) StartTribulation(ctx context.Context, req tribulationReq) (tribulationData, int, string) {
	c, err := s.store.GetCharacter(ctx, req.CharacterID)
	if err != nil {
		return tribulationData{}, 3007, "character not found"
	}
	if c.Status != "active" {
		return tribulationData{}, 3007, "character not active"
	}
	if c.RealmStatus == domain.RealmStatusTribulationPending {
		return tribulationData{}, 3009, "already in tribulation"
	}
	if c.MinorRealm != 3 {
		return tribulationData{}, 3007, "not at minor realm peak"
	}
	if req.TargetRealmTier != c.RealmTier+1 {
		return tribulationData{}, 3008, "invalid target realm tier"
	}
	minSAN := int32(s.getConfigInt("tribulation.min_san", 30))
	if c.SanCurrent < minSAN {
		return tribulationData{}, 3010, "SAN too low"
	}

	// 消耗材料
	if err := s.consumeMaterials(ctx, req.CharacterID, req.Consumables); err != nil {
		return tribulationData{}, 3007, err.Error()
	}

	helpers := req.HelperIDs
	if len(helpers) > 0 {
		count, err := s.store.CountCharacters(ctx, helpers)
		if err != nil || count != len(helpers) {
			return tribulationData{}, 3005, "helper condition not met"
		}
	}

	tribType := req.TribulationType
	if tribType == "" {
		tribType = s.determineTribulationType(c)
	}

	successRate := s.calcBreakthroughRate(c, c.RealmTier, true, helpers)
	recordID, err := s.store.InsertTribulationRecord(ctx, &db.TribulationRecord{
		CharacterID:         req.CharacterID,
		RealmTier:           req.TargetRealmTier,
		MinorRealm:          1,
		TribulationType:     tribType,
		BaseSuccessRate:     domain.DefaultTribulationBaseRate(c.RealmTier, true),
		ModifiedSuccessRate: successRate,
		HelperIDs:           helpers,
		Result:              domain.TribulationResultPending,
		Penalties:           map[string]interface{}{},
		DropsOnSuccess:      []map[string]interface{}{},
		SanSnapshot:         c.SanCurrent,
	})
	if err != nil {
		return tribulationData{}, 9002, "failed to create tribulation record"
	}

	// 进入渡劫状态
	if err := s.store.UpdateCharacterRealm(ctx, req.CharacterID, c.RealmTier, c.MinorRealm, 0, domain.RealmStatusTribulationPending); err != nil {
		return tribulationData{}, 9002, "failed to set tribulation status"
	}

	// 同步结算（MVP 简化；生产环境可改为异步任务）
	result, penalties, drops := s.resolveTribulation(c, req.TargetRealmTier, tribType)
	if err := s.store.UpdateTribulationRecord(ctx, recordID, result, penalties, drops); err != nil {
		return tribulationData{}, 9002, "failed to update tribulation record"
	}

	fromRealm := c.RealmTier
	toRealm := c.RealmTier
	toMinor := c.MinorRealm
	realmStatus := domain.RealmStatusNormal

	switch result {
	case domain.TribulationResultSuccess:
		toRealm = req.TargetRealmTier
		toMinor = 1
		if err := s.store.UpdateCharacterWorldAndRealm(ctx, req.CharacterID, c.WorldTier, toRealm, toMinor, realmStatus); err != nil {
			return tribulationData{}, 9002, "failed to advance realm"
		}
	case domain.TribulationResultFail:
		// 层内回退：圆满→中期
		toMinor = 2
		if err := s.store.UpdateCharacterRealm(ctx, req.CharacterID, fromRealm, toMinor, 0, realmStatus); err != nil {
			return tribulationData{}, 9002, "failed to setback realm"
		}
	case domain.TribulationResultBacklash:
		// 跨层回退或严重受挫
		if pType, ok := penalties["type"].(string); ok && pType == "drop_cross_tier" && fromRealm > 1 {
			toRealm = fromRealm - 1
			toMinor = 1
			if err := s.store.UpdateCharacterWorldAndRealm(ctx, req.CharacterID, c.WorldTier, toRealm, toMinor, realmStatus); err != nil {
				return tribulationData{}, 9002, "failed to setback realm"
			}
		} else {
			toMinor = 2
			if err := s.store.UpdateCharacterRealm(ctx, req.CharacterID, fromRealm, toMinor, 0, realmStatus); err != nil {
				return tribulationData{}, 9002, "failed to setback realm"
			}
		}
	case domain.TribulationResultDeath:
		// 角色进入死亡状态
		if err := s.store.UpdateCharacterStatus(ctx, req.CharacterID, "dead"); err != nil {
			return tribulationData{}, 9002, "failed to set dead status"
		}
	}

	estimatedTicks := int32(120)
	if s.cfg != nil {
		estimatedTicks = int32(s.cfg.GetInt("tribulation.estimated_ticks", 120))
	}

	return tribulationData{
		TribulationID:       recordID,
		Status:              "completed",
		BaseSuccessRate:     domain.DefaultTribulationBaseRate(fromRealm, true),
		ModifiedSuccessRate: successRate,
		EstimatedTicks:      estimatedTicks,
		StartAt:             time.Now().UTC().Format(time.RFC3339),
		Result:              result,
		FromRealmTier:       fromRealm,
		ToRealmTier:         toRealm,
		Penalties:           penalties,
		Drops:               drops,
	}, 0, ""
}

func (s *RealmService) determineTribulationType(c *db.Character) string {
	if c.SanCurrent < 30 {
		return domain.TribulationTypeHeartDevil
	}
	if c.CrimeScore > 500 {
		return domain.TribulationTypeQiDeviation
	}
	if c.RealmTier >= 6 {
		return domain.TribulationTypeHeti
	}
	return domain.TribulationTypeNormal
}

func (s *RealmService) resolveTribulation(c *db.Character, targetTier int32, tribType string) (string, map[string]interface{}, []map[string]interface{}) {
	successRate := s.calcBreakthroughRate(c, c.RealmTier, true, nil)
	if s.randFloat() < successRate {
		drops := s.generateTribulationDrops(targetTier)
		return domain.TribulationResultSuccess, map[string]interface{}{"type": "none"}, drops
	}

	// 失败惩罚
	result, penalties := s.resolveTribulationFailure(c, c.RealmTier)
	return result, penalties, nil
}

func (s *RealmService) resolveTribulationFailure(c *db.Character, tier int32) (string, map[string]interface{}) {
	dropWithin := s.getConfigFloat("tribulation.drop.l2_within", 0.70)
	dropCross := s.getConfigFloat("tribulation.drop.l2_cross", 0.20)
	frustration := s.getConfigFloat("tribulation.drop.frustration", 0.12)

	if tier >= 4 {
		dropCross = s.getConfigFloat("tribulation.drop.l4_cross_major", 0.30)
		remaining := 1.0 - dropCross - frustration
		if remaining < 0 {
			remaining = 0
		}
		dropWithin = remaining
	}

	roll := s.randFloat()
	thunderDamage := s.calcTribulationDamage(tier, "thunder")
	fireDamage := s.calcTribulationDamage(tier, "fire")

	if roll < dropWithin {
		return domain.TribulationResultFail, map[string]interface{}{
			"type":             "drop_within_tier",
			"minor_realm_loss": 1,
			"exp_loss_pct":     0.5,
			"thunder_damage":   thunderDamage,
			"fire_damage":      fireDamage,
		}
	}
	if roll < dropWithin+dropCross {
		return domain.TribulationResultBacklash, map[string]interface{}{
			"type":               "drop_cross_tier",
			"realm_tier_loss":    1,
			"minor_realm_set":    1,
			"exp_loss_pct":       0.8,
			"thunder_damage":     thunderDamage,
			"fire_damage":        fireDamage,
			"san_loss":           15,
		}
	}
	return domain.TribulationResultBacklash, map[string]interface{}{
		"type":           "frustration",
		"san_loss":       10,
		"exp_loss_pct":   0.3,
		"thunder_damage": thunderDamage,
		"fire_damage":    fireDamage,
	}
}

func (s *RealmService) calcTribulationDamage(tier int32, dmgType string) float64 {
	if dmgType == "thunder" {
		base := s.getConfigFloat("tribulation.thunder.base_pct", 0.115)
		return base * domain.ThunderLayerCoef(tier)
	}
	base := s.getConfigFloat("tribulation.fire.base_pct", 0.045)
	return base * domain.FireLayerCoef(tier)
}

func (s *RealmService) generateTribulationDrops(targetTier int32) []map[string]interface{} {
	// 按目标境界生成天材地宝/心法感悟
	drops := []map[string]interface{}{
		{"item_id": fmt.Sprintf("heavenly_dew_t%d", targetTier), "quantity": 1},
	}
	if s.randFloat() < 0.3 {
		drops = append(drops, map[string]interface{}{"item_id": "insight_fragment", "quantity": 1})
	}
	return drops
}

// GetTribulationResult 查询最近一次渡劫记录。
func (s *RealmService) GetTribulationResult(ctx context.Context, characterID string) (tribulationData, int, string) {
	rec, err := s.store.GetLatestTribulation(ctx, characterID)
	if err != nil {
		return tribulationData{}, 3007, "no tribulation record"
	}
	status := "completed"
	if rec.Result == domain.TribulationResultPending {
		status = "in_progress"
	}
	return tribulationData{
		TribulationID:       rec.ID,
		Status:              status,
		BaseSuccessRate:     rec.BaseSuccessRate,
		ModifiedSuccessRate: rec.ModifiedSuccessRate,
		EstimatedTicks:      0,
		StartAt:             rec.CreatedAt.Format(time.RFC3339),
		Result:              rec.Result,
		FromRealmTier:       rec.RealmTier - 1,
		ToRealmTier:         rec.RealmTier,
		Penalties:           rec.Penalties,
		Drops:               rec.DropsOnSuccess,
	}, 0, ""
}

// WorldBreak 破界/晋级到下一世界层级。
func (s *RealmService) WorldBreak(ctx context.Context, req worldBreakReq) (worldBreakData, int, string) {
	c, err := s.store.GetCharacter(ctx, req.CharacterID)
	if err != nil {
		return worldBreakData{}, 3011, "character not found"
	}
	if c.Status != "active" {
		return worldBreakData{}, 3014, "character not active"
	}
	if c.RealmStatus == domain.RealmStatusTribulationPending {
		return worldBreakData{}, 3014, "tribulation pending"
	}
	if req.TargetWorldTier != c.WorldTier+1 {
		return worldBreakData{}, 3011, "target world tier not unlocked"
	}
	// 破界要求：境界达到目标层级圆满，或已超越
	if !(c.RealmTier >= req.TargetWorldTier && (c.MinorRealm == 3 || c.RealmTier > req.TargetWorldTier)) {
		return worldBreakData{}, 3013, "realm not perfected"
	}

	// 首次 1→2 可不填；后续需要破界钥
	if req.TargetWorldTier > 2 {
		keyItemID := s.getConfigString("realm.world_break_key_item_id", "world_break_key")
		if req.KeyItemInstanceID == "" {
			return worldBreakData{}, 3012, "missing world break key"
		}
		has, err := s.store.HasInventoryItem(ctx, req.CharacterID, req.KeyItemInstanceID, keyItemID, 1)
		if err != nil || !has {
			return worldBreakData{}, 3012, "missing world break key"
		}
		if err := s.store.ConsumeInventoryItem(ctx, req.CharacterID, req.KeyItemInstanceID, 1); err != nil {
			return worldBreakData{}, 3012, "failed to consume key"
		}
	}

	// 跨层携带限制
	if err := s.checkCarryLimit(ctx, c, req.TargetWorldTier); err != nil {
		return worldBreakData{}, 3015, err.Error()
	}

	// 应用携带限制：低阶货币超cap部分被系统回收（写审计）
	if err := s.applyCarryLimit(ctx, c, req.TargetWorldTier); err != nil {
		return worldBreakData{}, 3015, err.Error()
	}

	// 更新世界层级
	toRealmTier := c.RealmTier
	toMinorRealm := c.MinorRealm
	if err := s.store.UpdateCharacterWorldAndRealm(ctx, req.CharacterID, req.TargetWorldTier, toRealmTier, toMinorRealm, domain.RealmStatusNormal); err != nil {
		return worldBreakData{}, 9002, "failed to break world"
	}

	// 是否生成破界遗迹
	ruinGenerated := s.randFloat() < s.ruinSpawnRate(req.TargetWorldTier)

	rec := &db.BreakthroughRecord{
		CharacterID:         req.CharacterID,
		FromRealmTier:       c.RealmTier,
		ToRealmTier:         toRealmTier,
		FromMinorRealm:      c.MinorRealm,
		ToMinorRealm:        toMinorRealm,
		IsSuccess:           true,
		IsBreakWorldBarrier: true,
		SourceWorldTier:     c.WorldTier,
		TargetWorldTier:     req.TargetWorldTier,
	}
	if err := s.store.InsertBreakthroughRecord(ctx, rec); err != nil {
		return worldBreakData{}, 9002, "failed to record world break"
	}

	worldEvent := fmt.Sprintf("破界·%s已解锁", s.worldLayerName(req.TargetWorldTier))
	if ruinGenerated {
		worldEvent += "·遗迹显化"
	}

	return worldBreakData{
		Success:              true,
		FromWorldTier:        c.WorldTier,
		ToWorldTier:          req.TargetWorldTier,
		FromRealmTier:        c.RealmTier,
		ToRealmTier:          toRealmTier,
		BreakthroughRecordID: "",
		WorldEvent:           worldEvent,
		RuinGenerated:        ruinGenerated,
	}, 0, ""
}

func (s *RealmService) getConfigString(key, def string) string {
	if s.cfg == nil {
		return def
	}
	return s.cfg.GetString(key, def)
}

func (s *RealmService) worldLayerName(tier int32) string {
	switch tier {
	case 1:
		return "种族出生地"
	case 2:
		return "洪荒主陆"
	case 3:
		return "洪荒腹地"
	case 4:
		return "太古秘境"
	case 5:
		return "混沌之渊·化神域"
	case 6:
		return "混沌之渊·合体域"
	}
	return "未知世界"
}

func (s *RealmService) ruinSpawnRate(tier int32) float64 {
	key := fmt.Sprintf("world.ruin.spawn_rate_l%d", tier)
	defaults := map[int32]float64{
		2: 0.01,
		3: 0.065,
		4: 0.10,
		5: 0.15,
		6: 0.215,
	}
	return s.getConfigFloat(key, defaults[tier])
}

// checkCarryLimit 校验跨层携带是否违反硬上限。
func (s *RealmService) checkCarryLimit(ctx context.Context, c *db.Character, targetTier int32) error {
	balances, err := s.store.GetCurrencyBalances(ctx, c.ID)
	if err != nil {
		return err
	}
	for currencyCode, amount := range balances {
		if amount <= 0 {
			continue
		}
		worldTier, err := s.store.GetCurrencyWorldTier(ctx, currencyCode)
		if err != nil {
			continue
		}
		// 货币层级低于目标-1 时进入硬上限判断
		if worldTier < targetTier-1 {
			cap := s.carryCap(currencyCode, targetTier)
			if amount > cap {
				return fmt.Errorf("carry limit exceeded for %s (max %.4f)", currencyCode, cap)
			}
		}
	}
	return nil
}

// applyCarryLimit 对超 cap 的低阶货币执行系统回收，并记录审计。
func (s *RealmService) applyCarryLimit(ctx context.Context, c *db.Character, targetTier int32) error {
	balances, err := s.store.GetCurrencyBalances(ctx, c.ID)
	if err != nil {
		return err
	}
	for currencyCode, amount := range balances {
		if amount <= 0 {
			continue
		}
		worldTier, err := s.store.GetCurrencyWorldTier(ctx, currencyCode)
		if err != nil {
			continue
		}
		if worldTier < targetTier-1 {
			cap := s.carryCap(currencyCode, targetTier)
			if amount > cap {
				removed := amount - cap
				if err := s.store.SetCurrencyBalance(ctx, c.ID, currencyCode, cap); err != nil {
					return err
				}
				if err := s.store.AuditCurrencyFlow(ctx, c.ID, "character", c.ID, currencyCode, "sink", "world_break_carry_tax",
					-removed, cap, c.WorldTier, ""); err != nil {
					return err
				}
			}
		}
	}
	return nil
}

func (s *RealmService) carryCap(currencyCode string, targetTier int32) float64 {
	// 目标 L2 时低阶货币保留较多；L3+ 仅允许保留少量低阶货币
	switch targetTier {
	case 2:
		return 50000
	case 3:
		if currencyCode == "copper" || currencyCode == "silver" {
			return 0 // 铜钱/银两不可带入灵石世界
		}
		return 100
	case 4, 5, 6:
		if currencyCode == "copper" || currencyCode == "silver" {
			return 0
		}
		return 10
	}
	return math.MaxFloat64
}