package controller

import (
	"encoding/json"
	"fmt"

	"be.ems/src/framework/i18n"
	"be.ems/src/framework/reqctx"
	"be.ems/src/framework/resp"
	"be.ems/src/framework/utils/parse"
	neFetchlink "be.ems/src/modules/network_element/fetch_link"
	"be.ems/src/modules/network_element/model"
	neService "be.ems/src/modules/network_element/service"
	traceService "be.ems/src/modules/trace/service"

	"github.com/gin-gonic/gin"
)

// NewNeConfig 网元参数配置 实例化控制层
var NewNeConfig = &NeConfigController{
	neConfigService: neService.NewNeConfig,
	neInfoService:   neService.NewNeInfo,
}

// 网元参数配置
//
// PATH /config
type NeConfigController struct {
	neConfigService *neService.NeConfig // 网元参数配置可用属性值服务
	neInfoService   *neService.NeInfo   // 网元信息服务
}

// 网元参数配置可用属性值列表
//
// GET /list
func (s NeConfigController) List(c *gin.Context) {
	query := reqctx.QueryMap(c)
	rows, total := s.neConfigService.FindByPage(query)
	c.JSON(200, resp.OkData(map[string]any{"total": total, "rows": rows}))
}

// 网元参数配置可用属性值信息
//
// GET /info/:id
func (s NeConfigController) Info(c *gin.Context) {
	language := reqctx.AcceptLanguage(c)
	id := parse.Number(c.Query("id"))
	if id <= 0 {
		c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: id is empty"))
		return
	}

	data := s.neConfigService.FindById(id)
	if data.ID != id {
		// 没有可访问参数配置数据！
		c.JSON(200, resp.ErrMsg(i18n.TKey(language, "neConfig.noData")))
		return
	}

	// 将字符串转json数据
	if err := json.Unmarshal([]byte(data.ParamJson), &data.ParamData); err != nil {
		c.JSON(400, resp.CodeMsg(400, err.Error()))
		return
	}
	c.JSON(200, resp.OkData(data))
}

// 网元参数配置可用属性值新增
//
// POST /
func (s NeConfigController) Add(c *gin.Context) {
	var body model.NeConfig
	if err := c.ShouldBindBodyWithJSON(&body); err != nil {
		errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
		c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
		return
	}

	// 将json数据转字符串存储
	paramDataByte, err := json.Marshal(body.ParamData)
	if err != nil {
		c.JSON(200, resp.ErrMsg(err.Error()))
		return
	}
	body.ParamJson = string(paramDataByte)

	insertId := s.neConfigService.Insert(body)
	if insertId > 0 {
		c.JSON(200, resp.Ok(nil))
		return
	}
	c.JSON(200, resp.Err(nil))
}

// 网元参数配置可用属性值修改
//
// PUT /
func (s NeConfigController) Edit(c *gin.Context) {
	language := reqctx.AcceptLanguage(c)
	var body model.NeConfig
	if err := c.ShouldBindBodyWithJSON(&body); err != nil {
		errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
		c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
		return
	}

	// 检查是否存在
	data := s.neConfigService.FindById(body.ID)
	if data.ID != body.ID {
		// 没有可访问主机命令数据！
		c.JSON(200, resp.ErrMsg(i18n.TKey(language, "neConfig.noData")))
		return
	}

	// 将json数据转字符串存储
	paramDataByte, err := json.Marshal(body.ParamData)
	if err != nil {
		c.JSON(200, resp.ErrMsg(err.Error()))
		return
	}
	body.ParamJson = string(paramDataByte)

	rows := s.neConfigService.Update(body)
	if rows > 0 {
		c.JSON(200, resp.Ok(nil))
		return
	}
	c.JSON(200, resp.Err(nil))
}

// 网元参数配置可用属性值删除
//
// DELETE /
func (s NeConfigController) Remove(c *gin.Context) {
	language := reqctx.AcceptLanguage(c)
	id := c.Query("id")
	if id == "" {
		c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: id is empty"))
		return
	}

	// 处理字符转id数组后去重
	uniqueIDs := parse.RemoveDuplicatesToArray(id, ",")
	// 转换成int64数组类型
	ids := make([]int64, 0)
	for _, v := range uniqueIDs {
		ids = append(ids, parse.Number(v))
	}

	rows, err := s.neConfigService.DeleteByIds(ids)
	if err != nil {
		c.JSON(200, resp.ErrMsg(i18n.TKey(language, err.Error())))
		return
	}
	msg := i18n.TTemplate(language, "app.common.deleteSuccess", map[string]any{"num": rows})
	c.JSON(200, resp.OkMsg(msg))
}

// 网元参数配置可用属性值列表指定网元类型全部无分页
//
// GET /list/:neType
//
//	@Tags			network_element/config
//	@Accept			json
//	@Produce		json
//	@Param			neType	path		string	true	"NE Type"	Enums(IMS,AMF,AUSF,UDM,SMF,PCF,NSSF,NRF,UPF,MME,CBC,OMC,SGWC,SMSC)
//	@Success		200		{object}	object	"Response Results"
//	@Security		TokenAuth
//	@Summary		Network Element Parameter Configuration Available Attribute Values List Specify Network Element Type All Unpaged
//	@Description	Network Element Parameter Configuration Available Attribute Values List Specify Network Element Type All Unpaged
//	@Router			/ne/config/list/{neType} [get]
func (s NeConfigController) ListByNeType(c *gin.Context) {
	neType := c.Param("neType")
	if neType == "" {
		c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: neType is empty"))
		return
	}
	data := s.neConfigService.FindByNeType(neType)
	c.JSON(200, resp.OkData(data))
}

// 网元参数配置数据信息
//
// GET /data
//
//	@Tags			network_element/config
//	@Accept			json
//	@Produce		json
//	@Param			neType		query		string	true	"NE Type"	Enums(IMS,AMF,AUSF,UDM,SMF,PCF,NSSF,NRF,UPF,MME,CBC,OMC,SGWC,SMSC)
//	@Param			neId		query		string	true	"NE ID"		default(001)
//	@Param			paramName	query		string	true	"Available attributes, based on querying the list of attributes"
//	@Success		200			{object}	object	"Response Results"
//	@Security		TokenAuth
//	@Summary		Network Element Parameter Configuration Data Information
//	@Description	Network Element Parameter Configuration Data Information
//	@Router			/ne/config/data [get]
func (s NeConfigController) DataInfo(c *gin.Context) {
	language := reqctx.AcceptLanguage(c)
	var query struct {
		NeType    string `form:"neType" binding:"required"`    // 网元类型
		NeId      string `form:"neId" binding:"required"`      // 网元ID
		ParamName string `form:"paramName" binding:"required"` // 可用属性
	}
	if err := c.ShouldBindQuery(&query); err != nil {
		errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
		c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
		return
	}

	neInfo := s.neInfoService.FindByNeTypeAndNeID(query.NeType, query.NeId)
	if neInfo.NeId != query.NeId || neInfo.IP == "" {
		c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
		return
	}

	if query.NeType == "OMC" {
		resData := s.neConfigService.GetOMCYaml(query.ParamName)
		c.JSON(200, resp.OkData(resData))
		return
	}

	// 网元直连
	resData, err := neFetchlink.NeConfigInfo(neInfo, query.ParamName)
	if err != nil {
		c.JSON(200, resp.ErrMsg(err.Error()))
		return
	}

	c.JSON(200, resp.Ok(resData))
}

// 网元参数配置数据修改
//
// PUT /data
//
//	@Tags			network_element/config
//	@Accept			json
//	@Produce		json
//	@Param			data	body		object	true	"Request Param"
//	@Success		200		{object}	object	"Response Results"
//	@Security		TokenAuth
//	@Summary		Network element parameter configuration data modification
//	@Description	Network element parameter configuration data modification
//	@Router			/ne/config/data [put]
func (s NeConfigController) DataEdit(c *gin.Context) {
	language := reqctx.AcceptLanguage(c)
	var body struct {
		NeType    string         `json:"neType" binding:"required"` // 网元类型
		NeId      string         `json:"neId" binding:"required"`   // 网元ID
		ParamName string         `json:"paramName" binding:"required"`
		ParamData map[string]any `json:"paramData" binding:"required"`
		Loc       string         `json:"loc"` // 仅array使用与数据对象内index一致,有多层时划分嵌套层(index/subParamName/index)
	}
	if err := c.ShouldBindBodyWithJSON(&body); err != nil {
		errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
		c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
		return
	}

	neInfo := s.neInfoService.FindByNeTypeAndNeID(body.NeType, body.NeId)
	if neInfo.NeId != body.NeId || neInfo.IP == "" {
		c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
		return
	}
	if body.NeType == "OMC" {
		err := s.neConfigService.ModifyOMCYaml(body.ParamName, body.Loc, body.ParamData)
		if err != nil {
			c.JSON(200, resp.ErrMsg(err.Error()))
			return
		}
		// 重开跟踪任务信令数据通道UDP
		if body.ParamName == "trace" {
			traceService.NewTraceTask.CreateUDP(true)
		}
		c.JSON(200, resp.Ok(nil))
		return
	}

	// 网元直连
	resData, err := neFetchlink.NeConfigUpdate(neInfo, body.ParamName, body.Loc, body.ParamData)
	if err != nil {
		c.JSON(200, resp.ErrMsg(err.Error()))
		return
	}
	c.JSON(200, resp.OkData(resData))
}

// 网元参数配置数据新增（array）
//
// POST /data
//
//	@Tags			network_element/config
//	@Accept			json
//	@Produce		json
//	@Param			data	body		object	true	"Request Param"
//	@Success		200		{object}	object	"Response Results"
//	@Security		TokenAuth
//	@Summary		Network element parameter configuration data added (array)
//	@Description	Network element parameter configuration data added (array)
//	@Router			/ne/config/data [post]
func (s NeConfigController) DataAdd(c *gin.Context) {
	language := reqctx.AcceptLanguage(c)
	var body struct {
		NeType    string         `json:"neType" binding:"required"`    // 网元类型
		NeId      string         `json:"neId" binding:"required"`      // 网元ID
		ParamName string         `json:"paramName" binding:"required"` // 根据配置可选值
		ParamData map[string]any `json:"paramData" binding:"required"` // 数据对象
		Loc       string         `json:"loc" binding:"required"`       // 与数据对象内index一致,有多层时划分嵌套层(index/subParamName/index)
	}
	if err := c.ShouldBindBodyWithJSON(&body); err != nil {
		errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
		c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
		return
	}

	// 检查是否array
	info := s.neConfigService.FindByNeTypeAndParamName(body.NeType, body.ParamName)
	if info.ParamType != "array" {
		c.JSON(200, resp.ErrMsg("this attribute does not support adding"))
		return
	}
	// 必须含有index
	_, idxOk := body.ParamData["index"]
	if info.ParamType == "array" && !idxOk {
		c.JSON(200, resp.ErrMsg("array data must contain index"))
		return
	}

	neInfo := s.neInfoService.FindByNeTypeAndNeID(body.NeType, body.NeId)
	if neInfo.NeId != body.NeId || neInfo.IP == "" {
		c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
		return
	}

	// 网元直连
	resData, err := neFetchlink.NeConfigAdd(neInfo, body.ParamName, body.Loc, body.ParamData)
	if err != nil {
		c.JSON(200, resp.ErrMsg(err.Error()))
		return
	}
	c.JSON(200, resp.OkData(resData))
}

// 网元参数配置数据删除（array）
//
// DELETE /data
//
//	@Tags			network_element/config
//	@Accept			json
//	@Produce		json
//	@Param			neType		query		string	true	"NE Type"	Enums(IMS,AMF,AUSF,UDM,SMF,PCF,NSSF,NRF,UPF,MME,CBC,OMC,SGWC,SMSC)
//	@Param			neId		query		string	true	"NE ID"		default(001)
//	@Param			paramName	query		string	true	"Available attributes, based on querying the list of attributes"
//	@Param			loc			query		string	true	"Array index"
//	@Success		200			{object}	object	"Response Results"
//	@Security		TokenAuth
//	@Summary		Network element parameter configuration data deletion (array)
//	@Description	Network element parameter configuration data deletion (array)
//	@Router			/ne/config/data [delete]
func (s NeConfigController) DataRemove(c *gin.Context) {
	language := reqctx.AcceptLanguage(c)
	var query struct {
		NeType    string `form:"neType" binding:"required"` // 网元类型
		NeId      string `form:"neId" binding:"required"`   // 网元ID
		ParamName string `form:"paramName" binding:"required"`
		Loc       string `form:"loc" binding:"required"` // 与数据对象内index一致,有多层时划分嵌套层(index/subParamName/index)
	}
	if err := c.ShouldBindQuery(&query); err != nil {
		errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
		c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
		return
	}

	// 检查是否array
	info := s.neConfigService.FindByNeTypeAndParamName(query.NeType, query.ParamName)
	if info.ParamType != "array" {
		c.JSON(200, resp.ErrMsg("this attribute does not support adding"))
		return
	}

	neInfo := s.neInfoService.FindByNeTypeAndNeID(query.NeType, query.NeId)
	if neInfo.NeId != query.NeId || neInfo.IP == "" {
		c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
		return
	}

	// 网元直连
	resData, err := neFetchlink.NeConfigDelete(neInfo, query.ParamName, query.Loc)
	if err != nil {
		c.JSON(200, resp.ErrMsg(err.Error()))
		return
	}
	c.JSON(200, resp.OkData(resData))
}