package controller

import (
	"blazing/common/core"
	"blazing/common/data/entity"
	"blazing/common/socket/cmd"
	"blazing/common/socket/handler"
	"blazing/cool"
	"blazing/logic/service"

	"bytes"
	"context"
	"fmt"
	"reflect"

	"github.com/gogf/gf/v2/os/gcmd"
	"github.com/gogf/gf/v2/os/glog"
	"github.com/gogf/gf/v2/util/gconv"
	"github.com/lunixbochs/struc"
	"github.com/panjf2000/gnet/v2"
)

var Maincontroller = NewController() //注入service
// 分发cmd逻辑实现Controller
type Controller struct {
	Port      uint32
	RPCClient struct {
		Kick          func(int32) error
		Quit          func(int32) error
		RegisterLogic func(int32) error
		UserLogin     func(int32, int32) error
		UserLogout    func(int32, int32) error
	}
}

func (h *Controller) KickPerson(a int) error {
	//TODO 这里待实现踢人
	fmt.Println("检测到踢人请求", a)
	service.KickPlayer(uint32(a))
	return nil
}
func NewController() *Controller {
	return &Controller{}
}

func parseCmd[T any](a T, data []byte) T {
	// := info.NewLoginSidInfo()
	struc.Unpack(bytes.NewBuffer(data), &a)
	return a
	//fmt.Println(pinfo)
	//login.OnData_1001(pinfo, player)
	//fmt.Println(data)
}

func init() { //默认初始化扫描
	// 解析命令行参数
	cool.Config.PortBL = gcmd.GetOpt("port", "1").Uint32()
	// 获取对象的反射值和类型
	value := reflect.ValueOf(Maincontroller)

	// 获取类型
	typ := value.Type()

	for i := 0; i < typ.NumMethod(); i++ {
		method := typ.Method(i)

		// TODO 接收者 + 2个参数 一个是类型,一个是player
		//method.Type.In(1) == reflect.TypeOf([]byte{}

		// 获取方法值
		methodValue := value.MethodByName(method.Name)
		methodValue.Type().NumIn()
		var func_cmd cmd.EnumCommandID

		func_cmd = getcmd(methodValue.Type().In(0))
		if func_cmd == 0 { //说明不是注册方法
			continue
		}
		if !cmd.Isexist(cmd.CommandID, cmd.EnumCommandID(func_cmd)) {
			fmt.Println("ID方法存在cmd未注册", func_cmd)

		}
		if cool.Config.PortBL == 0 && func_cmd > 1000 { //判断login服务器
			break

		}

		if cool.Config.PortBL != 0 && func_cmd < 1000 { //判断login服务器
			continue

		}
		//	fmt.Println(methodValue.Interface().(func(gnet.Conn, handler.TomeeHeader)))
		_, ok := core.Maincmdcache.LoadOrStore(func_cmd, methodValue) //TODO 待实现对不同用户初始化方法以取消全局cmdcache

		if ok { //方法已存在init
			glog.Error(context.Background(), "方法已存在init,不会初始化后面的方法", func_cmd)
		}
	}
}

func getcmd(t reflect.Type) cmd.EnumCommandID {
	// 处理指针类型
	if t.Kind() == reflect.Ptr {
		t = t.Elem() // 获取指针指向的类型
	}

	// 确保是结构体
	if t.Kind() != reflect.Struct {
		fmt.Println("非结构体类型")
		return 0
	}

	// 遍历结构体字段
	//	fmt.Printf("结构体 %s 的字段信息：\n", t.Name())
	for i := 0; i < t.NumField(); i++ {
		field := t.Field(i)
		//fmt.Printf("- 字段名: %s\n", field.Name)
		//fmt.Printf("  类型: %v\n", field.Type)
		if field.Type == reflect.TypeOf(handler.TomeeHeader{}) {
			//	fmt.Println(reflect.ValueOf(field))

			return cmd.EnumCommandID(gconv.Uint32(field.Tag.Get("cmd")))

		}
		// fmt.Printf("  类型: %v\n", field.Type)
		// fmt.Printf("  标签: %q\n", field.Tag)

		// 递归处理嵌套结构体
		if field.Type.Kind() == reflect.Struct ||
			(field.Type.Kind() == reflect.Ptr && field.Type.Elem().Kind() == reflect.Struct) {
			fmt.Println("  嵌套结构体字段:")
			nestedType := field.Type
			if nestedType.Kind() == reflect.Ptr {
				nestedType = nestedType.Elem()
			}
			getcmd(nestedType)
		}
		//	fmt.Println()
	}
	return 0
}

// 遍历结构体方法并执行RECV_cmd
func Recv(c gnet.Conn, data handler.TomeeHeader) {

	tt, ok := core.Maincmdcache.Load(data.CMD)
	if !ok {

		glog.Error(context.Background(), data.CMD, "cmd未注册")
		return //TODO 待实现cmd未注册
	}
	cmdlister := tt.(reflect.Value)
	//	fmt.Println(cmdlister)

	params := []reflect.Value{}

	//funct := cmdlister.Type().NumIn()

	// 如果需要可设置的变量（用于修改值），创建指针并解引用
	ptrValue := reflect.New(cmdlister.Type().In(0))

	tt1 := ptrValue.Elem().Addr().Interface()
	//	fmt.Println(tt1)
	err := struc.Unpack(bytes.NewBuffer(data.Data), tt1)
	if err != nil {
		fmt.Println(err)
	}
	//fmt.Println(tt1)
	ptrValue1 := ptrValue.Elem()
	// 设置 Name 字段
	nameField := ptrValue.Elem().Field(0) //首个为header
	if nameField.IsValid() && nameField.CanSet() {
		nameField.Set(reflect.ValueOf(data))
	}
	if cmdlister.Type().In(1) == reflect.TypeOf(entity.Player{}) {

		params = append(params, ptrValue1, reflect.ValueOf(service.GetPlayer(c, data.UserID)))
	} else {

		params = append(params, ptrValue1, reflect.ValueOf(c))
	}

	ret := cmdlister.Call(params)
	//return core.Pack(data.Handler.UserID, data.Handler.CMD, t1, 0)
	//core.Pack(c, cmd cmd.EnumCommandID, data any, iserror uint32)
	_, err = c.Write(ret[0].Interface().([]byte))
	if err != nil {
		fmt.Println(err)
	}
	// switch ret[0].Interface().(type) { //TODO  待修改
	// case []byte: //原始包

	// 	c.Write(ret[0].Interface().([]byte)) //这里直接发送原始包,应该是已经拼接过的原始包,通常不同使用

	// //case uint32: //错误码 实际上这里包含在结构体里了 ,错误码应该构造在返回之前

	// default:

	// 	var data1 bytes.Buffer
	// 	struc.Pack(&data1, &data)
	// 	c.Write(data1.Bytes())

	// }
}