package gameserver

import (
	"log"

	"ananta-ps/pkg/protocol"
)

type EnemyUnit struct {
	ID         uint64  `json:"id"`
	TemplateID uint32  `json:"templateId"`
	PosX       float32 `json:"posX"`
	PosY       float32 `json:"posY"`
	PosZ       float32 `json:"posZ"`
	Facing     float32 `json:"facing"`
	HP         float32 `json:"hp"`
	MaxHP      float32 `json:"maxHp"`
}

func (s *Server) handleGmWorldRefreshEnemyGroup(sess *Session, pkt *protocol.RpcPacket) error {
	r := protocol.NewUxReader(pkt.Body)
	groupId, _ := r.U32()
	if groupId == 0 {
		groupId = 2001
	}

	log.Printf("[COMBAT] GmWorldRefreshEnemyGroup groupId=%d near player pos (%.1f,%.1f,%.1f)",
		groupId, sess.posX, sess.posY, sess.posZ)

	if err := sess.ReturnEmptyOk(pkt.InvokeID, pkt.MethodID); err != nil {
		return err
	}

	// Spawn 3 combat enemies near the player
	enemyTemplates := []uint32{200101, 200102, 200103}
	for i, tId := range enemyTemplates {
		enemyUnitId := uint64(0x3000000000000000) | uint64(i+1)
		ex := sess.posX + float32(i*4) - 4.0
		ey := sess.posY
		ez := sess.posZ + 6.0

		// SyncRaidBattleUnitSpirit
		proj := protocol.EncodeRaidBattleUnitSpirit(enemyUnitId, tId, ex, ey, ez, 180.0, 0)
		_ = sess.NotifyData(protocol.MethodSyncRaidBattleUnitSpirit, proj)

		// SyncUnitHp
		wHp := protocol.NewUxWriter()
		wHp.U64(enemyUnitId).F32(10000.0).F32(10000.0) // currentHp, maxHp
		_ = sess.NotifyData(protocol.MethodGetMethodIDDefault("SyncUnitHp", 68582870), wHp.Bytes())
	}
	return nil
}

func (s *Server) handleReportUnitHitFly(sess *Session, pkt *protocol.RpcPacket) error {
	r := protocol.NewUxReader(pkt.Body)
	targetUnitId, _ := r.U64()
	stiffId, _ := r.U32()
	speed, _ := r.F32()

	log.Printf("[COMBAT] ReportUnitHitFly target=%d stiffId=%d speed=%.2f", targetUnitId, stiffId, speed)
	return sess.ReturnEmptyOk(pkt.InvokeID, pkt.MethodID)
}

func (s *Server) handleReportUnitHitFlyEnd(sess *Session, pkt *protocol.RpcPacket) error {
	r := protocol.NewUxReader(pkt.Body)
	targetUnitId, _ := r.U64()
	log.Printf("[COMBAT] ReportUnitHitFlyEnd target=%d", targetUnitId)
	return sess.ReturnEmptyOk(pkt.InvokeID, pkt.MethodID)
}

func (s *Server) handleReportUnitFallGround(sess *Session, pkt *protocol.RpcPacket) error {
	r := protocol.NewUxReader(pkt.Body)
	targetUnitId, _ := r.U64()
	log.Printf("[COMBAT] ReportUnitFallGround target=%d", targetUnitId)
	return sess.ReturnEmptyOk(pkt.InvokeID, pkt.MethodID)
}

func (s *Server) handleReportUnitFallGroundEnd(sess *Session, pkt *protocol.RpcPacket) error {
	r := protocol.NewUxReader(pkt.Body)
	targetUnitId, _ := r.U64()
	log.Printf("[COMBAT] ReportUnitFallGroundEnd target=%d", targetUnitId)
	return sess.ReturnEmptyOk(pkt.InvokeID, pkt.MethodID)
}

func (s *Server) handleAskControlPowerHoldEnemyUp(sess *Session, pkt *protocol.RpcPacket) error {
	r := protocol.NewUxReader(pkt.Body)
	enemyId, _ := r.U64()
	log.Printf("[COMBAT] Telekinesis Grab enemy=%d", enemyId)
	return sess.ReturnEmptyOk(pkt.InvokeID, pkt.MethodID)
}

func (s *Server) handleAskControlPowerHoldEnemyFallGrou(sess *Session, pkt *protocol.RpcPacket) error {
	r := protocol.NewUxReader(pkt.Body)
	enemyId, _ := r.U64()
	log.Printf("[COMBAT] Telekinesis Slam enemy=%d", enemyId)
	return sess.ReturnEmptyOk(pkt.InvokeID, pkt.MethodID)
}

func (s *Server) handleAskPlayerAttack(sess *Session, pkt *protocol.RpcPacket) error {
	r := protocol.NewUxReader(pkt.Body)
	comboIdx, _ := r.U32()
	targetId, _ := r.U64()

	log.Printf("[COMBAT] PlayerAttack combo=%d target=%d", comboIdx, targetId)
	return sess.ReturnEmptyOk(pkt.InvokeID, pkt.MethodID)
}

func (s *Server) handleAskPlayerCastSkill(sess *Session, pkt *protocol.RpcPacket) error {
	r := protocol.NewUxReader(pkt.Body)
	skillId, _ := r.U32()
	log.Printf("[COMBAT] PlayerCastSkill skill=%d", skillId)
	return sess.ReturnEmptyOk(pkt.InvokeID, pkt.MethodID)
}