package game

import (
	"fmt"
	"math"
	"server/GoUtil"
	baseCfg "server/conf/base"
	playroomCfg "server/conf/playroom"
	userCfg "server/conf/user"
	"server/game/mod/card"
	"server/game/mod/item"
	"server/game/mod/limitedTimeEvent"
	MsgMod "server/game/mod/msg" // Ensure this package exists and is correctly referenced
	"server/game/mod/playroom"
	"server/msg"
	"time"
)

// 限时事件触发器
func LimitedTimeEventTrigger(p *Player, AddEventId int) {
	Lv := p.GetPlayerBaseMod().GetLevel()
	EndTime, TimeoutEvent, AddEvent := p.PlayMod.getLimitedTimeEventMod().Trigger(Lv)
	remainingTime := GoUtil.NextHourRemain()
	EndTime = GoUtil.IfTrue(EndTime > 0, min(EndTime, int(remainingTime)), int(remainingTime)).(int)
	if AddEventId != 0 {
		AddEvent = append(AddEvent, AddEventId)
	}
	if EndTime > 0 {
		p.CallEvent(time.Duration(EndTime)*time.Second, func() {
			p.lock.Lock()
			defer p.lock.Unlock()
			LimitedTimeEventTrigger(p, 0)
			p.SendClientRes()
		}, "LimitedTimeEvent")
	}

	for _, v := range TimeoutEvent { // 事件到期处理
		p.PushClientRes(&msg.LimitEventNotify{
			Id:   int32(v),
			Type: limitedTimeEvent.EVENT_NOTIFY_TYPE_DEL,
		})
		switch v {
		case limitedTimeEvent.EVENT_TYPE_HIGH_ROLLER:
			BaseMod := p.PlayMod.getBaseMod()
			EnergyMul := BaseMod.GetEnergyMul()
			MaxEnergyMul := baseCfg.GetMaxEnergyMul(BaseMod.GetLevel(), BaseMod.GetEnergy())
			p.PlayMod.getBaseMod().ResetEnergyMul(MaxEnergyMul)
			NewEnergyMul := p.PlayMod.getBaseMod().GetEnergyMul()
			OrderMod := p.PlayMod.getOrderMod()
			Lv := p.GetPlayerBaseMod().GetLevel()
			Emit := p.PlayMod.getChessMod().GetOrderEmit()
			ChessList := p.PlayMod.getChessMod().GetUnlockChessList()
			OrderMod.ChangeEnergyMul(Lv, Emit, NewEnergyMul, ChessList)
			p.PushClientRes(OrderMod.BackData())
			p.TeLog("mutil_merge_change", map[string]interface{}{
				"change_from": math.Pow(2, float64(EnergyMul)),
				"change_to":   math.Pow(2, float64(NewEnergyMul)),
				"is_auto":     true,
			})
			p.PushClientRes(p.PlayMod.getBaseMod().BackData())
		case limitedTimeEvent.EVENT_TYPE_SUPER_ORDER:
			p.PlayMod.getOrderMod().RemoveSuperOrder()
			p.PushClientRes(p.PlayMod.getOrderMod().BackData())
		case limitedTimeEvent.EVENT_TYPE_CARD_FESTIVAL:
			p.PlayMod.getCardMod().ResetCardFestival()
		case limitedTimeEvent.EVENT_TYPE_GOLDCARD_EX:
			p.PlayMod.getFriendMod().ResetGoldCardEx()
			LimitedTimeCardTrigger(p)
		}
	}

	for _, v := range AddEvent { // 增加事件处理
		switch v {
		case limitedTimeEvent.EVENT_TYPE_SUPER_ORDER:
			Emit := p.PlayMod.getChessMod().GetOrderEmit()
			Lv := p.GetPlayerBaseMod().GetLevel()
			EnergyMul := p.PlayMod.getBaseMod().GetEnergyMul()
			p.PlayMod.getOrderMod().CreateSuperOrder(Lv, Emit, EnergyMul)
			p.PushClientRes(p.PlayMod.getOrderMod().BackData())
		case limitedTimeEvent.EVENT_TYPE_CARD_FESTIVAL:
			p.PlayMod.getCardMod().CreateCardFestival()
		}
	}
	p.PushClientRes(p.PlayMod.getLimitedTimeEventMod().BackData())
	p.PlayMod.save()
}

// 限时猪猪存钱罐触发器
func LimitedTimePiggyBankTrigger(p *Player) {
	Remain := p.PlayMod.getPiggyBankMod().TimeOut()
	if Remain > 0 {
		p.CallEvent(time.Duration(Remain)*time.Second, func() {
			p.lock.Lock()
			defer p.lock.Unlock()
			LimitedTimePiggyBankTrigger(p)
			p.SendClientRes()
		}, "PiggyBank")
	}
	p.PushClientRes(p.PlayMod.getPiggyBankMod().BackData())
}

// 限时卡牌触发器
func LimitedTimeCardTrigger(p *Player) {
	FriendMod := p.PlayMod.getFriendMod()
	CardMod := p.PlayMod.getCardMod()
	Now := GoUtil.Now()
	EndTime := int64(0)
	for k, v := range FriendMod.Card {
		if v.EndTime > 0 && v.EndTime <= Now {
			if v.Status == card.STATUS_CARD_EX_1 {
				delete(FriendMod.Card, k)
				FriendMgrSend(&MsgMod.Msg{
					From: v.BUid,
					To:   v.AUid,
					Type: MsgMod.HANDLE_TYPE_EX_CARD_SELECT_TIMEOUT,
				})
			}
			if v.Status == card.STATUS_CARD_EX_2 {
				delete(FriendMod.Card, k)
				FriendMgrSend(&MsgMod.Msg{
					From: v.AUid,
					To:   v.BUid,
					Type: MsgMod.HANDLE_TYPE_EX_CARD_TIMEOUT,
				})
				CardMod.AddCard(v.CardId)
				CardMod.DelExCard(v)
				p.PushClientRes(CardMod.NotifyTimes())
				p.PushClientRes(CardMod.NotifyCard())
			}
		}
		EndTime = min(EndTime, v.EndTime)
	}
	if EndTime > 0 {
		p.CallEvent(time.Duration(EndTime-Now)*time.Second, func() {
			p.lock.Lock()
			defer p.lock.Unlock()
			LimitedTimeCardTrigger(p)
			p.SendClientRes()
		}, "LimitedTimeCard")
	}
}
func LimitedTimePlayroomTrigger(p *Player) {
	PlayroomMod := p.PlayMod.getPlayroomMod()
	for k, v := range PlayroomMod.Physiology {
		if v.Time > 0 {
			LimitedTimePlayroomTrigger_(p, k)
		}
	}
	p.PushClientRes(PlayroomMod.NotifyMood())
}
func LimitedTimePlayroomTrigger_(p *Player, Id int) {
	PlayroomMod := p.PlayMod.getPlayroomMod()
	Now := GoUtil.Now()
	Physiology := PlayroomMod.GetPhysiology(Id)
	if Physiology == nil {
		return
	}
	NewTime, Num := PlayroomTrigger(Physiology.Id, Physiology.Time, Physiology.Num)
	Physiology.Time = NewTime
	DiffValue := Physiology.Num - Num
	MType, MEffect := playroomCfg.GetMoodEffect(Physiology.Id)
	CleanMood := PlayroomMod.GetMoodInfo(playroom.MOOD_TYPE_CLEAN)
	// 上厕所数值为0 且清洁度大于50时，清洁度降至50
	if Id == playroom.PHYSIOLOGY_TYPE_TOLIET && Num == 0 && CleanMood.Num > 50 {
		CleanMood.Num = 50
	} else {
		PlayroomMod.AddMood(MType, -MEffect*DiffValue)
	}
	Physiology.Num = Num
	p.PlayMod.save()
	PlayroomBackData(p)
	NextSecond := NewTime - Now
	if NextSecond > 0 {
		p.CallEvent(time.Duration(NextSecond)*time.Second, func() {
			p.lock.Lock()
			defer p.lock.Unlock()
			LimitedTimePlayroomTrigger_(p, Id)
			p.SendClientRes()
		}, fmt.Sprintf("Playroom_%d", Id))
	}
}

func PlayroomTrigger(Id int, Time int64, Num int) (int64, int) {
	if Num == 0 {
		return 0, 0
	}
	Now := GoUtil.Now()
	if Time > Now {
		return Time, Num
	}
	if Time == Now {
		NeedDuration := playroomCfg.GetPhysiologyDuration(Id, Num)
		return Time + int64(NeedDuration), Num
	}
	n := 0
	for {
		if n > 100 {
			return 0, 0
		}
		Num--
		NeedDuration := playroomCfg.GetPhysiologyDuration(Id, Num)
		Time += int64(NeedDuration)
		if Time > Now {
			return Time, Num
		}
		if Num == 0 {
			return 0, 0
		}
		n++
	}
}

func LimitedTimePlayroomWorkTrigger(p *Player) {
	PlayroomMod := p.PlayMod.getPlayroomMod()
	EndTime := PlayroomMod.Endtime
	Now := GoUtil.Now()
	if EndTime > 0 && EndTime <= Now {
		PlayroomMod.ResetWork()
		p.PlayMod.save()
		PlayroomBackData(p)
		p.SendClientRes()
		return
	}
	NextSecond := EndTime - GoUtil.Now()
	if NextSecond > 0 {
		p.CallEvent(time.Duration(NextSecond)*time.Second, func() {
			p.lock.Lock()
			defer p.lock.Unlock()
			LimitedTimePlayroomWorkTrigger(p)
			p.SendClientRes()
		}, "PlayroomWork")
	}
}

func LimitedTimeEnergyAdd(p *Player) {
	curtime := time.Now().Unix()
	PlayerBaseMod := p.GetPlayerBaseMod()
	BaseMod := p.PlayMod.getBaseMod()
	delta := curtime - BaseMod.GetRecoverTime()
	Recover := userCfg.GetRecover(BaseMod.GetLevel())
	Addsta := int(delta) / Recover
	if Addsta <= 0 {
		return
	}
	Energy := BaseMod.GetEnergy()
	MaxEnergy := PlayerBaseMod.GetMaxEnergy()
	if MaxEnergy > Energy {
		E := MaxEnergy - Energy
		Energy += Addsta
		if Energy > MaxEnergy {
			Energy = MaxEnergy
		}
		p.TeLog("asset_change", map[string]interface{}{
			"item_id":      item.ITEM_ENERGY_ID,
			"change_type":  "gain",
			"change_num":   min(Addsta, E),
			"change_after": Energy,
		})
		p.CallEvent(time.Duration(Recover)*time.Second, func() {
			p.lock.Lock()
			defer p.lock.Unlock()
			LimitedTimeEnergyAdd(p)
		}, "AddEnergy")
	}
	BaseMod.SetEnergy(Energy)
	BaseMod.SetRecoverTime(curtime)
	p.SendErrClienRes(PlayerBaseMod.BackAsset())
}