package action

import (
	"bytes"
	"fmt"
	"net"
	"time"

	"mongo.games.com/goserver/core/basic"
	"mongo.games.com/goserver/core/logger"
	"mongo.games.com/goserver/core/netlib"
	"mongo.games.com/goserver/core/task"
	"mongo.games.com/goserver/core/timer"

	"mongo.games.com/game/machine/machinedoll"
	"mongo.games.com/game/protocol/machine"
)

type DoneFunc func(c net.Conn)

func Process(conn *machinedoll.Conn, sec time.Duration, f1, f2 []DoneFunc, isSync bool) {
	var ch chan struct{}
	if isSync {
		ch = make(chan struct{}, 1)
	}
	task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
		for _, v := range f1 {
			v(conn)
		}
		if len(f2) > 0 {
			timer.AfterTimer(func(h timer.TimerHandle, ud interface{}) bool {
				Process(conn, 0, f2, nil, isSync)
				if isSync {
					ch <- struct{}{}
				}
				return true
			}, nil, sec)
		} else {
			if isSync {
				ch <- struct{}{}
			}
		}
		return nil
	}), nil).StartByFixExecutor(fmt.Sprintf("Machine%v", conn.Addr))
	if isSync {
		<-ch
	}
}

// 移动
func SMDollMachinePerateHandler(session *netlib.Session, packetId int, data interface{}) error {
	logger.Logger.Tracef("SMDollMachinePerateHandler %v", data)
	msg, ok := data.(*machine.SMDollMachineoPerate)
	if !ok {
		return nil
	}

	conn, ok := machinedoll.MachineMgr.ConnMap[int(msg.GetId())]
	if !ok || conn == nil {
		return nil
	}

	switch msg.Perate {
	case 1:
		//向前移动
		Process(conn, 200*time.Millisecond, []DoneFunc{machinedoll.Backward}, []DoneFunc{machinedoll.BackwardStop}, false)
	case 2:
		//向后移动
		Process(conn, 200*time.Millisecond, []DoneFunc{machinedoll.Forward}, []DoneFunc{machinedoll.ForwardStop}, false)
	case 3:
		//向左移动
		Process(conn, 200*time.Millisecond, []DoneFunc{machinedoll.Left}, []DoneFunc{machinedoll.LeftStop}, false)
	case 4:
		//向右移动
		Process(conn, 200*time.Millisecond, []DoneFunc{machinedoll.Right}, []DoneFunc{machinedoll.RightStop}, false)
	case 5:
		//投币
		//Process(conn, 0*time.Millisecond, []DoneFunc{machinedoll.Coin}, []DoneFunc{}, false)
		machinedoll.Coin(conn)
		go CoinResult(session, conn, msg.Snid, msg.GetId())
	}
	return nil
}

// 下抓
func SMDollMachineGrabHandler(session *netlib.Session, packetId int, data interface{}) error {
	logger.Logger.Tracef("SMDollMachineGrabHandler %v", data)
	msg, ok := data.(*machine.SMDollMachineGrab)
	if !ok {
		return nil
	}

	conn, ok := machinedoll.MachineMgr.ConnMap[int(msg.GetId())]
	if !ok || conn == nil {
		return nil
	}

	send := func(net.Conn) {
		session.Send(int(machine.DollMachinePacketID_PACKET_MSDollMachineoPerateResult), &machine.MSDollMachineoPerateResult{
			Snid:   msg.Snid,
			Id:     msg.GetId(),
			Result: 1,
			TypeId: 2,
		})
	}

	switch msg.GetTypeId() {
	case 1:
		//弱抓
		Process(conn, 0, []DoneFunc{machinedoll.WeakGrab}, []DoneFunc{send}, false)
	case 2:
		//强力抓
		Process(conn, 0, []DoneFunc{machinedoll.Grab}, []DoneFunc{send}, false)
	}
	go DollMachineGrabResult(session, conn, msg.Snid, msg.GetId())
	return nil
}

// 监听抓取结果返回
func DollMachineGrabResult(session *netlib.Session, conn *machinedoll.Conn, snid, id int32) {
	for {
		// 读取数据
		fmt.Println("监听抓取结果返回!")
		buf := make([]byte, 1024)
		conn.SetDeadline(time.Now().Add(10 * time.Second))
		n, err := conn.Read(buf)
		if err != nil {
			fmt.Println("Failed to read response from client:", err)
			return
		}

		// 将读取到的数据按照 221 进行分割
		parts := bytes.Split(buf[:n], []byte{221})
		fmt.Println("获取到的返回值：", parts)
		instruction := []byte{0xAA, 0x05, 0x02, 0x50, 0x09, 0x00}
		instruction1 := []byte{0xAA, 0x05, 0x02, 0x50, 0x09, 0x01}
		// 遍历分割结果,打印出每个部分
		for i, part := range parts {
			if len(part) > 0 {
				part = part[:len(part)-1] // 去除最后一个字节，该字节为分隔符
				fmt.Println("比较返回结果 part = ", part)
				if bytes.Contains(part, instruction) {
					fmt.Printf("Part %d: %s\n", i+1, part)
					//回应数据
					_, err = conn.Write([]byte{0xAA, 0x04, 0x01, 0x50, 0x09, 0x5c, 0xdd})
					if err != nil {
						fmt.Println("Failed to read response from server:", err)
						return
					}
					session.Send(int(machine.DollMachinePacketID_PACKET_MSDollMachineoPerateResult), &machine.MSDollMachineoPerateResult{
						Snid:   snid,
						Id:     id,
						Result: 0,
						TypeId: 2,
					})
					fmt.Println("没有抓到礼品！！！！！！！！")
					return
				}
				if bytes.Contains(part, instruction1) {
					fmt.Printf("Part %d: %s\n", i+1, part)
					//回应数据
					_, err = conn.Write([]byte{0xAA, 0x04, 0x01, 0x50, 0x09, 0x5c, 0xdd})
					if err != nil {
						fmt.Println("Failed to read response from server:", err)
						return
					}
					session.Send(int(machine.DollMachinePacketID_PACKET_MSDollMachineoPerateResult), &machine.MSDollMachineoPerateResult{
						Snid:   snid,
						Id:     id,
						Result: 1,
						TypeId: 2,
					})
					fmt.Println("抓到礼品了！！！！！！！！")
					return
				}
			}
		}
	}
}
func CoinResult(session *netlib.Session, conn *machinedoll.Conn, snid, id int32) {
	// 读取服务端的响应
	buf := make([]byte, 1024)
	n, err := conn.Read(buf)
	if err != nil {
		fmt.Println("Failed to read response from server:", err)
		return
	}
	if buf[4] == 1 {
		fmt.Println("上分成功！！！！n = ", n)
	}
	if buf[4] == 0 {
		fmt.Println("上分失败！！！")
	}
	//返回消息
	session.Send(int(machine.DollMachinePacketID_PACKET_MSDollMachineoPerateResult), &machine.MSDollMachineoPerateResult{
		Snid:   snid,
		Id:     id,
		Result: int32(buf[4]),
		TypeId: 1,
	})
}

// 与游戏服务器连接成功，向游戏服务器推送所有娃娃机连接
func SMGameLinkSucceedHandler(session *netlib.Session, packetId int, data interface{}) error {
	logger.Logger.Trace("与游戏服务器连接成功")
	//开始向游戏服务器发送娃娃机连接信息
	msg := &machine.MSDollMachineList{}
	for i, _ := range machinedoll.MachineMgr.ConnMap {
		info := &machine.DollMachine{}
		info.Id = int32(i)
		info.VideoAddr = "www.baidu.com"
		msg.Data = append(msg.Data, info)
	}
	session.Send(int(machine.DollMachinePacketID_PACKET_MSDollMachineList), msg)
	logger.Logger.Tracef("向游戏服务器发送娃娃机连接信息：%v", msg)
	return nil
}
func init() {
	netlib.Register(int(machine.DollMachinePacketID_PACKET_SMDollMachinePerate), &machine.SMDollMachineoPerate{}, SMDollMachinePerateHandler)
	netlib.Register(int(machine.DollMachinePacketID_PACKET_SMDollMachineGrab), &machine.SMDollMachineGrab{}, SMDollMachineGrabHandler)
	//链接成功 返回消息
	netlib.Register(int(machine.DollMachinePacketID_PACKET_SMGameLinkSucceed), &machine.SMGameLinkSucceed{}, SMGameLinkSucceedHandler)
}