package gameserver

import (
	"log"

	"ananta-ps/pkg/protocol"
)

// Chinese Chess Board (9x10 Xiangqi)
type ChineseChessGame struct {
	Board [10][9]int8
}

func NewChineseChessGame() *ChineseChessGame {
	g := &ChineseChessGame{}
	g.Reset()
	return g
}

func (g *ChineseChessGame) Reset() {
	// Standard Xiangqi starting pieces:
	// Red: 1-King, 2-Advisor, 3-Elephant, 4-Horse, 5-Chariot, 6-Cannon, 7-Soldier
	// Black: -1 to -7
	g.Board = [10][9]int8{
		{-5, -4, -3, -2, -1, -2, -3, -4, -5},
		{0, 0, 0, 0, 0, 0, 0, 0, 0},
		{0, -6, 0, 0, 0, 0, 0, -6, 0},
		{-7, 0, -7, 0, -7, 0, -7, 0, -7},
		{0, 0, 0, 0, 0, 0, 0, 0, 0},
		{0, 0, 0, 0, 0, 0, 0, 0, 0},
		{7, 0, 7, 0, 7, 0, 7, 0, 7},
		{0, 6, 0, 0, 0, 0, 0, 6, 0},
		{0, 0, 0, 0, 0, 0, 0, 0, 0},
		{5, 4, 3, 2, 1, 2, 3, 4, 5},
	}
}

func (s *Server) handleAskChineseChessMove(sess *Session, pkt *protocol.RpcPacket) error {
	r := protocol.NewUxReader(pkt.Body)
	fromX, _ := r.U8()
	fromY, _ := r.U8()
	toX, _ := r.U8()
	toY, _ := r.U8()

	log.Printf("[CHESS] ChineseChess move from (%d,%d) to (%d,%d)", fromX, fromY, toX, toY)
	if err := sess.ReturnEmptyOk(pkt.InvokeID, pkt.MethodID); err != nil {
		return err
	}

	w := protocol.NewUxWriter()
	w.U8(fromX).U8(fromY).U8(toX).U8(toY)
	return sess.NotifyData(protocol.MethodGetMethodIDDefault("SyncChineseChessMove", 68582880), w.Bytes())
}

// Mahjong Solo
func (s *Server) handleAskMahjongAction(sess *Session, pkt *protocol.RpcPacket) error {
	r := protocol.NewUxReader(pkt.Body)
	actionType, _ := r.U32()
	tileId, _ := r.U32()

	log.Printf("[MAHJONG] Mahjong action=%d tile=%d", actionType, tileId)
	if err := sess.ReturnEmptyOk(pkt.InvokeID, pkt.MethodID); err != nil {
		return err
	}

	w := protocol.NewUxWriter()
	w.U32(actionType).U32(tileId)
	return sess.NotifyData(protocol.MethodGetMethodIDDefault("SyncMahjongAction", 68582881), w.Bytes())
}

// Balloon Shooting Game
func (s *Server) handleEnterBalloonZone(sess *Session, pkt *protocol.RpcPacket) error {
	log.Printf("[BALLOON] Player entered balloon shooting zone")
	if err := sess.ReturnEmptyOk(pkt.InvokeID, pkt.MethodID); err != nil {
		return err
	}

	// SyncGameGroundZoneInfo for Balloon game
	wZone := protocol.NewUxWriter()
	wZone.U32(3).U64(0x9000000000000001).Bool(true)
	return sess.NotifyData(protocol.MethodGetMethodIDDefault("SyncGameGroundZoneInfo", 68004609), wZone.Bytes())
}

func (s *Server) handleLeaveBalloon(sess *Session, pkt *protocol.RpcPacket) error {
	log.Printf("[BALLOON] Player left balloon zone")
	return sess.ReturnEmptyOk(pkt.InvokeID, pkt.MethodID)
}

func (s *Server) handleAskBreakDestructibleObject(sess *Session, pkt *protocol.RpcPacket) error {
	r := protocol.NewUxReader(pkt.Body)
	objId, _ := r.U64()

	sess.balloonScore += 10
	log.Printf("[BALLOON] BreakDestructibleObject id=%d totalScore=%d", objId, sess.balloonScore)

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

	wScore := protocol.NewUxWriter()
	wScore.U64(objId).U32(sess.balloonScore)
	return sess.NotifyData(protocol.MethodGetMethodIDDefault("SyncBalloonScore", 68582882), wScore.Bytes())
}

// Bowling Alley
func (s *Server) handleEnterBowlingZone(sess *Session, pkt *protocol.RpcPacket) error {
	log.Printf("[BOWLING] Player entered bowling zone")
	if err := sess.ReturnEmptyOk(pkt.InvokeID, pkt.MethodID); err != nil {
		return err
	}

	wZone := protocol.NewUxWriter()
	wZone.U32(1).U64(0x9000000000000002).Bool(true)
	return sess.NotifyData(protocol.MethodGetMethodIDDefault("SyncGameGroundZoneInfo", 68004609), wZone.Bytes())
}

// Claw Machine
func (s *Server) handleAskClawBuyTicket(sess *Session, pkt *protocol.RpcPacket) error {
	log.Printf("[CLAW] Bought claw machine ticket")
	return sess.ReturnEmptyOk(pkt.InvokeID, pkt.MethodID)
}

func (s *Server) handleAskClawSettlement(sess *Session, pkt *protocol.RpcPacket) error {
	r := protocol.NewUxReader(pkt.Body)
	isSuccess, _ := r.Bool()
	log.Printf("[CLAW] Claw settlement success=%v", isSuccess)
	return sess.ReturnEmptyOk(pkt.InvokeID, pkt.MethodID)
}

func (s *Server) handleAskBuyMiniGameTicket(sess *Session, pkt *protocol.RpcPacket) error {
	r := protocol.NewUxReader(pkt.Body)
	ticketType, _ := r.U32()
	log.Printf("[MINIGAME] BuyMiniGameTicket type=%d", ticketType)
	return sess.ReturnEmptyOk(pkt.InvokeID, pkt.MethodID)
}