package http

import (
	"encoding/json"
	"errors"
	"fmt"
	"reflect"

	"github.com/gin-gonic/gin"
	"github.com/infraboard/mcube/http/response"

	"gitee.com/player1111/restful-api-demo.git/apps/host"
)

//用于暴露host servic接口

// handler 引用gin的格式，需要gin.context参数
func (h *HostHandler) handleCreate(c *gin.Context) {
	switch svc := h.svc.(type) {
	case host.HostService:
		ins := host.NewHost()

		//判断用户传参
		if err := c.Bind(ins); err != nil {
			response.Failed(c.Writer, err)
			return
		}
		// 接口调用
		ins, err := svc.Create(c.Request.Context(), ins)
		if err != nil {
			response.Failed(c.Writer, err)
			return
		}
		response.Success(c.Writer, ins)

	default:
		response.Failed(c.Writer, fmt.Errorf("unsupported service type"))
		return
	}
}

func (h *HostHandler) handleQuery(c *gin.Context) {
	// 从querystring中获取参数
	req := host.QueryHostFromHTTP(c.Request)

	/*自建request：inSet, err := h.svc.Query(c.Request.Context(), host.NewQueryHostRequest(20, 1, "Resource"))*/
	inSet, err := h.svc.Query(c.Request.Context(), req)

	if err != nil {
		response.Failed(c.Writer, err)
		return
	}
	response.Success(c.Writer, inSet)
}

func (h *HostHandler) handleDescribe(c *gin.Context) {
	req := host.NewDescribeHostRequestWithId(c.Param("id"))
	target, err := h.svc.Describe(c.Request.Context(), req)

	if err != nil {
		response.Failed(c.Writer, err)
		return
	}
	response.Success(c.Writer, target)
}

// 处理http请求中传入的数据
func (h *HostHandler) handleUpdate(c *gin.Context) {
	var updateData host.Host
	resourceField := make(map[string]interface{})
	describeField := make(map[string]interface{})

	// 获取请求中更新数据所在id
	req := host.NewUpdateHostRequest(c.Param("id"))

	// 解析请求中的json body数据（更新字段的内容）
	if err := json.NewDecoder(c.Request.Body).Decode(&updateData); err != nil {
		response.Failed(c.Writer, err)
		return
	}

	if updateData.Resource != nil && updateData.Resource.Id != "" {
		response.Failed(c.Writer, errors.New("updating ID is not allowed"))
		return
	}
	h.log.Debugf("updateData:%+v", updateData)

	// 创建映射
	/*fieldType := reflect.TypeOf(updateData)
	fieldValue := reflect.ValueOf(updateData)*/

	// 获取Resource结构体的类型和值
	var resourceType reflect.Type
	var resourceValue reflect.Value
	var resourceFieldNum int
	if updateData.Resource != nil {
		resourceType = reflect.TypeOf(*updateData.Resource)
		resourceValue = reflect.ValueOf(*updateData.Resource)
		resourceFieldNum = resourceType.NumField()

		h.log.Debugf("resourceValue:%v", resourceValue)

		// 遍历Resource结构体的字段和值
		for i := 0; i < resourceType.NumField(); i++ {
			rFieldValue := resourceValue.Field(i)

			if rFieldValue.Kind() == reflect.String && rFieldValue.String() == "" {
				continue
			}
			if resourceType.Field(i).Name == "Vendor" {
				continue
			}
			if rFieldValue.Kind() == reflect.Int64 || rFieldValue.Kind() == reflect.Int {
				// 将 reflect.Value 转换为原始类型，然后与 0 进行比较
				if rFieldValue.Int() == 0 {
					continue
				}
			}
			resourceField[resourceType.Field(i).Tag.Get("json")] = resourceValue.Field(i).Interface()
			// 处理Resource字段和值
			h.log.Debugf("第%d次: Resource Field: %s, Value: %v\n", i+1, resourceType.Field(i).Name, resourceValue.Field(i).Interface())
		}
	} else {
		resourceFieldNum = 0
		h.log.Warn("Resource is nil!")
	}

	// 获取Describe结构体的类型和值
	var describeType reflect.Type
	var describeValue reflect.Value
	var describeFieldNum int
	if updateData.Describe != nil {
		describeType = reflect.TypeOf(*updateData.Describe)
		describeValue = reflect.ValueOf(*updateData.Describe)
		describeFieldNum = describeType.NumField()

		h.log.Debugf("describeValue:%v", describeValue)
		// 遍历Describe结构体的字段和值
		for i := 0; i < describeType.NumField(); i++ {
			dFieldValue := describeValue.Field(i)

			if dFieldValue.Kind() == reflect.String && dFieldValue.String() == "" {
				continue
			}

			if dFieldValue.Kind() == reflect.Int64 || dFieldValue.Kind() == reflect.Int {
				// 将 reflect.Value 转换为原始类型，然后与 0 进行比较
				if dFieldValue.Int() == 0 {
					continue
				}
			}

			describeField[describeType.Field(i).Tag.Get("json")] = describeValue.Field(i).Interface()
			// 处理Describe字段和值
			h.log.Debugf("第%d次：Describe Field: %s, Value: %v\n", i+1, describeType.Field(i).Name, describeValue.Field(i).Interface())
		}
	} else {
		describeFieldNum = 0
		h.log.Warn("Describe is nil!")
	}

	// 后端根据字段数量判定模式 传给req
	switch resourceFieldNum + describeFieldNum - 3 {
	case host.HOST_MODIFY_FIELD_NUM:
		req.UpdateMode = host.UPDATE_PUT
		h.log.Info("Use the PUT Update Mode")
	default:
		req.UpdateMode = host.UPDATE_PATCH
		h.log.Info("Use the Patch Update Mode")
	}

	req.Ins = &updateData
	req.ResourceUpdates = resourceField
	req.DescribeUpdates = describeField

	h.log.Debugf("ResourceUpdates:%v", resourceField)
	h.log.Debugf("DescribeUpdates:%v", describeField)

	// 实际的执行逻辑
	ins, err := h.svc.Update(c.Request.Context(), req)

	if err != nil {
		response.Failed(c.Writer, err)
		return
	}

	response.Success(c.Writer, ins)
}

// 暂不做开发
func (h *ServerHandler) handleCreate(c *gin.Context) {
	response.Failed(c.Writer, fmt.Errorf("unsupported service type"))
}

/*// 根据服务类型创建 Handler 实例
func CreateHandler() *Handler {
	// 在这里可以根据不同的服务类型创建不同的 Handler 实例
	return &Handler{}
}
*/