package controller

/*
   @Title  文件名称 : PoliticsstatusController.go
   @Description 描述: Controller层PoliticsstatusController

   @Author  作者: leijianming  时间(2021-10-23 12:25:18)
   @Update  作者: leijianming  时间(2021-10-23 12:25:18)

*/

import (
	"context"
	"encoding/json"
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/micro/go-micro/v2"
	"github.com/micro/go-micro/v2/logger"
	"github.com/micro/go-micro/v2/registry"
	"github.com/micro/go-micro/v2/registry/etcd"
	basedto "gitee.com/ichub/go-factroy2024/cms/base/dto"
	basemodel "gitee.com/ichub/go-factroy2024/cms/base/model"
	"gitee.com/ichub/go-factroy2024/cms/base/utils"
	"gitee.com/ichub/go-factroy2024/cms/shop/dto"
	_ "gitee.com/ichub/go-factroy2024/cms/shop/inter"
	"gitee.com/ichub/go-factroy2024/cms/shop/model"
	politicsstatusProto "gitee.com/ichub/go-factroy2024/grpc/proto/politicsstatus"

	"io/ioutil"
	"strconv"
	"time"
)

type PoliticsstatusRpcClientInfo struct {
	Hostip, ServerName, ClientName string
}
type PoliticsstatusRpcController struct {
	iniFlag bool

	rpcService politicsstatusProto.PoliticsstatusService
}

var InstPoliticsstatusRpcController PoliticsstatusRpcController

func (cInst *PoliticsstatusRpcController) getRpcService() politicsstatusProto.PoliticsstatusService {
	rpcClientInfo := PoliticsstatusRpcClientInfo{
		"192.168.4.119:2379",
		"shop.service",
		"shop.client",
	}
	if cInst.iniFlag == false {
		cInst.registerClient(rpcClientInfo)
		cInst.iniFlag = true
	}
	return cInst.rpcService
}

func (cInst *PoliticsstatusRpcController) registerClient(rpcClientInfo PoliticsstatusRpcClientInfo) {

	reg := etcd.NewRegistry(func(options *registry.Options) {
		options.Addrs = []string{
			rpcClientInfo.Hostip,
		}
	})

	service := micro.NewService(
		micro.Registry(reg),
		micro.Name(rpcClientInfo.ClientName),
	)
	// Initialise the client and parse command line flags
	service.Init()

	cInst.rpcService = politicsstatusProto.NewPoliticsstatusService(rpcClientInfo.ServerName, service.Client())

}

func (cInst *PoliticsstatusRpcController) Query(ctx *gin.Context) {
	ctx.Header("Content-Type", "application/json")
	result := dto.PoliticsstatusPageResult{}

	defer ctx.Request.Body.Close()
	var bodyBytes []byte
	bodyBytes, err := ioutil.ReadAll(ctx.Request.Body)

	if err != nil {
		logger.Error(err)
		result.FailMessage(err.Error())
		ctx.String(basedto.CODE_REQUEST_BAD, result.String())
		return
	}

	var param dto.PoliticsstatusQueryParam
	err = json.Unmarshal(bodyBytes, &param)
	if err != nil {
		logger.Error(err)
		ctx.String(basedto.CODE_REQUEST_BAD, "bad request!")
		return
	}
	rpcParam := &politicsstatusProto.PoliticsstatusQueryParam{}

	rpcParam.PageSize = param.PageSize
	rpcParam.Current = param.Current
	rpcParam.OrderBys = param.OrderBys
	rpcParam.FuzzyQuery = utils.Bool2Str(param.FuzzyQuery)
	rpcParam.EsQuery = utils.Bool2Str(param.EsQuery)

	if param.Param != nil {
		rpcParam.Param = &politicsstatusProto.PoliticsstatusMessage{}
		pp := rpcParam.Param

		pp.InRanges = make(map[string]string)
		pp.DateRanges = make(map[string]*politicsstatusProto.PoliticsstatusIntList)
		pp.IntRanges = make(map[string]*politicsstatusProto.PoliticsstatusIntList)
		pp.StringRanges = make(map[string]*politicsstatusProto.PoliticsstatusStringList)

		pp.InRanges = param.Param.InRanges
		for k, v := range param.Param.DateRanges {
			pp.DateRanges[k] = &politicsstatusProto.PoliticsstatusIntList{Value: v}
		}
		for k, v := range param.Param.IntRanges {
			pp.IntRanges[k] = &politicsstatusProto.PoliticsstatusIntList{Value: v}

		}
		for k, v := range param.Param.StringRanges {
			pp.StringRanges[k] = &politicsstatusProto.PoliticsstatusStringList{Value: v}
		}

		cInst.CopyModel2PbMsg(&param.Param.Politicsstatus, pp)
	}
	rpcResult, err := cInst.getRpcService().Query(context.TODO(), rpcParam)

	if err != nil {
		logger.Error(err)
		result.FailMessage(err.Error())
		ctx.String(basedto.CODE_SUCCESS, result.String())
		return
	}
	result.Code = rpcResult.Code
	result.Msg = rpcResult.Msg
	result.Page.Current = rpcResult.Page.Current
	result.Page.PageSize = rpcResult.Page.PageSize
	result.Page.Count = int(rpcResult.Page.Count)
	result.Page.Total = rpcResult.Page.Total
	if result.Code == 200 {
		cInst.CopyPbMsg2Models(&result.Data, &rpcResult.Data)
	}

	ctx.String(basedto.CODE_SUCCESS, result.String())
}

func (cInst *PoliticsstatusRpcController) FindById(ctx *gin.Context) {
	jsonResult := &dto.PoliticsstatusJsonResult{}
	ctx.Header("Content-Type", "application/json")

	sid := ctx.DefaultQuery("id", "0")

	result, err := cInst.getRpcService().FindByID(context.TODO(), &politicsstatusProto.PoliticsstatusIDRequest{Id: sid})

	if err != nil {
		jsonResult.FailMessage(err.Error())
		ctx.Header("Content-Type", "application/json")
		ctx.String(basedto.CODE_SUCCESS, jsonResult.ToString())
		return
	}
	jsonResult.Code = result.Code
	jsonResult.Msg = result.Msg
	if result.Data != nil {
		jsonResult.Data = new(model.Politicsstatus)
		cInst.CopyPbMsg2Model(jsonResult.Data, result.Data)
	}

	ctx.Header("Content-Type", "application/json")
	ctx.String(basedto.CODE_SUCCESS, jsonResult.ToString())

}

func (cInst *PoliticsstatusRpcController) FindByIds(ctx *gin.Context) {
	result := &dto.PoliticsstatusPageResult{}
	ctx.Header("Content-Type", "application/json")

	ids := ctx.DefaultQuery("ids", "0")

	rpcResult, err := cInst.getRpcService().FindByIds(context.TODO(), &politicsstatusProto.PoliticsstatusByIdsRequest{Ids: ids})

	if err != nil {
		logger.Error(err)
		result.FailMessage(err.Error())
		ctx.String(basedto.CODE_SUCCESS, result.String())
		return
	}
	result.Code = rpcResult.Code
	result.Msg = rpcResult.Msg

	if rpcResult.Code == 200 {
		result.Page.Current = 1
		result.Page.PageSize = int32(len(rpcResult.Data))
		result.Page.Count = len(rpcResult.Data)
		result.Page.Total = result.Page.PageSize
		cInst.CopyPbMsg2Models(&result.Data, &rpcResult.Data)
	}

	ctx.String(basedto.CODE_SUCCESS, result.String())

}

func (cInst *PoliticsstatusRpcController) DeleteById(ctx *gin.Context) {
	jsonResult := &basedto.JsonResult{}
	ctx.Header("Content-Type", "application/json")

	sid := ctx.DefaultQuery("id", "0")

	result, err := cInst.getRpcService().DeleteById(context.TODO(), &politicsstatusProto.PoliticsstatusIDRequest{Id: sid})
	if err != nil {
		logger.Error(err)
		jsonResult.FailMessage(err.Error())
		ctx.String(basedto.CODE_SUCCESS, jsonResult.String())
		return
	}

	jsonResult.Code = result.Code
	jsonResult.Msg = result.Msg
	jsonResult.Data = result.Data

	ctx.String(basedto.CODE_SUCCESS, jsonResult.String())

}

func (cInst *PoliticsstatusRpcController) Save(ctx *gin.Context) {
	jsonResult := &basedto.JsonResult{}
	ctx.Header("Content-Type", "application/json")

	defer ctx.Request.Body.Close()
	var bodyBytes []byte
	bodyBytes, err := ioutil.ReadAll(ctx.Request.Body)
	if err != nil {
		ctx.String(basedto.CODE_REQUEST_BAD, "bad request!")
		return
	}

	// 新建缓冲区并替换原有Request.body
	//ctx.Request.DataBody = ioutil.NopCloser(bytes.NewBuffer(bodyBytes))
	var entity model.Politicsstatus
	err = json.Unmarshal(bodyBytes, &entity)
	if err != nil {
		ctx.String(basedto.CODE_REQUEST_BAD, err.Error())
		return
	}
	fmt.Println(entity.ToString())
	var in *politicsstatusProto.PoliticsstatusMessage = &politicsstatusProto.PoliticsstatusMessage{}
	cInst.CopyModel2PbMsg(&entity, in)
	result, err := cInst.getRpcService().Save(context.TODO(), in)

	if err != nil {
		jsonResult.FailMessage(err.Error())
		ctx.String(basedto.CODE_SUCCESS, jsonResult.ToString())

		return
	}
	jsonResult.Code = result.Code
	jsonResult.Msg = result.Msg
	jsonResult.Data = result.Data

	ctx.String(basedto.CODE_SUCCESS, jsonResult.String())

}

func (cInst *PoliticsstatusRpcController) UpdateNotNullProps(ctx *gin.Context) {
	jsonResult := &basedto.JsonResult{}
	ctx.Header("Content-Type", "application/json")

	defer ctx.Request.Body.Close()
	var bodyBytes []byte
	bodyBytes, err := ioutil.ReadAll(ctx.Request.Body)
	if err != nil {
		ctx.String(basedto.CODE_REQUEST_BAD, "bad request!")
		return
	}

	// 新建缓冲区并替换原有Request.body
	//ctx.Request.DataBody = ioutil.NopCloser(bytes.NewBuffer(bodyBytes))
	var entity model.Politicsstatus
	err = json.Unmarshal(bodyBytes, &entity)

	if err != nil {
		ctx.String(basedto.CODE_REQUEST_BAD, "bad request!")
		return
	}

	var politicsstatusMessageData politicsstatusProto.PoliticsstatusMessageData
	politicsstatusMessageData.Data = entity.String()

	result, err := cInst.getRpcService().UpdateNotNullProps(context.TODO(), &politicsstatusMessageData)

	if err != nil {
		jsonResult.FailMessage(err.Error())
		ctx.String(basedto.CODE_SUCCESS, jsonResult.ToString())
		return
	}
	jsonResult.Code = result.Code
	jsonResult.Msg = result.Msg
	jsonResult.Data = result.Data

	ctx.String(basedto.CODE_SUCCESS, jsonResult.String())
}

func (cInst *PoliticsstatusRpcController) CopyModel2PbMsgs(entities []model.Politicsstatus, pbentities *[]*politicsstatusProto.PoliticsstatusMessage) {

	for _, v := range entities {
		out := &politicsstatusProto.PoliticsstatusMessage{}
		cInst.CopyModel2PbMsg(&v, out)
		*pbentities = append(*pbentities, out)
	}

}

func (cInst *PoliticsstatusRpcController) CopyModel2PbMsg(entity *model.Politicsstatus, pbentity *politicsstatusProto.PoliticsstatusMessage) {

	pbentity.Id = entity.GetId()
	pbentity.Name = entity.GetName()

}

func (cInst *PoliticsstatusRpcController) IniPbMsg() (pbentity *politicsstatusProto.PoliticsstatusMessage) {

	pbentity = &politicsstatusProto.PoliticsstatusMessage{}

	pbentity.Id = 0
	pbentity.Name = ""

	return
}

func (cInst *PoliticsstatusRpcController) CopyPbMsg2Models(entities *[]model.Politicsstatus, pbentities *[]*politicsstatusProto.PoliticsstatusMessage) {

	for _, v := range *pbentities {
		out := &model.Politicsstatus{}
		cInst.CopyPbMsg2Model(out, v)
		*entities = append(*entities, *out)
	}

}

func (cInst *PoliticsstatusRpcController) CopyPbMsg2Model(entity *model.Politicsstatus, pbentity *politicsstatusProto.PoliticsstatusMessage) {

	entity.Ini(true)

	*entity.Id = pbentity.GetId()
	*entity.Name = pbentity.GetName()

}

func (cInst *PoliticsstatusRpcController) IniRanges(pp *politicsstatusProto.PoliticsstatusMessage) {

	pp.InRanges = make(map[string]string)
	pp.DateRanges = make(map[string]*politicsstatusProto.PoliticsstatusIntList)
	pp.IntRanges = make(map[string]*politicsstatusProto.PoliticsstatusIntList)
	pp.StringRanges = make(map[string]*politicsstatusProto.PoliticsstatusStringList)

}

func (cInst *PoliticsstatusRpcController) UpdateNotNil(ctx *gin.Context) {
	cInst.Update(ctx, nil)
}

func (cInst *PoliticsstatusRpcController) UpdateActive(ctx *gin.Context) {
	cInst.Update(ctx, cInst.TransActive)
}

func (cInst *PoliticsstatusRpcController) TransActive(entity *model.Politicsstatus) *model.Politicsstatus {
	rentity := entity
	/*rentity = &model.Politicsstatus{}
	rentity.ColumnId = entity.ColumnId
	rentity.Active = entity.Active
	fmt.Println("TransUpdateActive")
	if rentity.ColumnId == nil || rentity.Active == nil {

		return nil
	}*/

	return rentity
}

func (cInst *PoliticsstatusRpcController) Update(ctx *gin.Context, funTrans func(entity *model.Politicsstatus) *model.Politicsstatus) {
	jsonResult := &basedto.JsonResult{}
	ctx.Header("Content-Type", "application/json")

	defer ctx.Request.Body.Close()
	var bodyBytes []byte
	bodyBytes, err := ioutil.ReadAll(ctx.Request.Body)
	if err != nil {
		ctx.String(basedto.CODE_REQUEST_BAD, "bad request!")
		return
	}

	// 新建缓冲区并替换原有Request.body
	//ctx.Request.DataBody = ioutil.NopCloser(bytes.NewBuffer(bodyBytes))
	var entity model.Politicsstatus
	err = json.Unmarshal(bodyBytes, &entity)

	if err != nil {
		ctx.String(basedto.CODE_REQUEST_BAD, "bad request!")
		return
	}
	if funTrans != nil {
		pentity := funTrans(&entity)
		if pentity == nil {

			jsonResult.FailMessage("param is nil")
			ctx.String(basedto.CODE_SUCCESS, jsonResult.ToString())
			return
		}
		entity = *pentity
	}
	var politicsstatusMessageData politicsstatusProto.PoliticsstatusMessageData
	politicsstatusMessageData.Data = entity.String()

	result, err := cInst.getRpcService().UpdateNotNullProps(context.TODO(), &politicsstatusMessageData)

	if err != nil {
		jsonResult.FailMessage(err.Error())
		ctx.String(basedto.CODE_SUCCESS, jsonResult.ToString())
		return
	}
	jsonResult.Code = result.Code
	jsonResult.Msg = result.Msg
	jsonResult.Data = result.Data

	ctx.String(basedto.CODE_SUCCESS, jsonResult.String())
}