package controller

import (
	"fmt"
	"strings"

	"github.com/gin-gonic/gin"

	"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/ne/fetch_link"
	"be.ems/src/modules/ne/model"
	"be.ems/src/modules/ne/service"
)

// 实例化控制层 NeLicenseController 结构体
var NewNeLicense = &NeLicenseController{
	neLicenseService: service.NewNeLicense,
	neInfoService:    service.NewNeInfo,
}

// 网元授权激活请求
//
// PATH /license
type NeLicenseController struct {
	neLicenseService *service.NeLicense // 网元授权激活服务
	neInfoService    *service.NeInfo    // 网元信息服务
}

// 网元授权激活列表
//
// GET /list
//
//	@Tags			ne
//	@Accept			json
//	@Produce		json
//	@Param			neType		query		string	false	"NE Type"	Enums(IMS,AMF,AUSF,UDM,SMF,PCF,NSSF,NRF,UPF,MME,CBC,OMC,SGWC,SMSC)
//	@Param			neId		query		string	false	"NE ID"
//	@Param			expiryDate	query		string	false	"ExpiryDate"
//	@Param			pageNum		query		number	true	"pageNum"	default(1)
//	@Param			pageSize	query		number	true	"pageSize"	default(10)
//	@Success		200			{object}	object	"Response Results"
//	@Security		TokenAuth
//	@Summary		Net Element License Activation List
//	@Description	Net Element License Activation List
//	@Router			/ne/license/list [get]
func (s *NeLicenseController) List(c *gin.Context) {
	query := reqctx.QueryMap(c)
	rows, total := s.neLicenseService.FindByPage(query)

	// 过滤屏蔽授权文件
	arr := &rows
	for i := range *arr {
		(*arr)[i].ActivationRequestCode = "-"
		(*arr)[i].LicensePath = "-"
	}

	c.JSON(200, resp.OkData(map[string]any{"total": total, "rows": rows}))
}

// 网元授权激活信息
//
// GET /:id
func (s *NeLicenseController) Info(c *gin.Context) {
	language := reqctx.AcceptLanguage(c)
	id := parse.Number(c.Param("id"))
	if id <= 0 {
		c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: id is empty"))
		return
	}

	neLicense := s.neLicenseService.FindById(id)
	if neLicense.ID != id {
		// 没有可访问网元授权激活数据！
		c.JSON(200, resp.ErrMsg(i18n.TKey(language, "neLicense.noData")))
		return
	}

	c.JSON(200, resp.OkData(neLicense))
}

// 网元neType和neID查询
//
// GET /byTypeAndID
//
//	@Tags			ne
//	@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)
//	@Success		200		{object}	object	"Response Results"
//	@Security		TokenAuth
//	@Summary		Network element neType and neID queries
//	@Description	Network element neType and neID queries
//	@Router			/ne/license/byTypeAndID [get]
func (s *NeLicenseController) NeTypeAndID(c *gin.Context) {
	language := reqctx.AcceptLanguage(c)
	var querys struct {
		NeType string `form:"neType" binding:"required"`
		NeId   string `form:"neId" binding:"required"`
	}
	if err := c.ShouldBindQuery(&querys); err != nil {
		errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
		c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
		return
	}

	neLicense := s.neLicenseService.FindByNeTypeAndNeID(querys.NeType, querys.NeId)
	if neLicense.NeId != querys.NeId {
		// 没有可访问网元授权激活数据！
		c.JSON(200, resp.ErrMsg(i18n.TKey(language, "neLicense.noData")))
		return
	}

	c.JSON(200, resp.OkData(neLicense))
}

// 网元授权激活授权申请码
//
// GET /code
//
//	@Tags			ne
//	@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)
//	@Success		200		{object}	object	"Response Results"
//	@Security		TokenAuth
//	@Summary		Network Element License Activation License Application Code
//	@Description	Network Element License Activation License Application Code
//	@Router			/ne/license/code [get]
func (s *NeLicenseController) Code(c *gin.Context) {
	language := reqctx.AcceptLanguage(c)
	var querys struct {
		NeType string `form:"neType" binding:"required"`
		NeId   string `form:"neId" binding:"required"`
	}
	if err := c.ShouldBindQuery(&querys); err != nil {
		errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
		c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
		return
	}

	// 检查是否存在授权记录
	neLicense := s.neLicenseService.FindByNeTypeAndNeID(querys.NeType, querys.NeId)
	if neLicense.NeId != querys.NeId {
		// 没有可访问网元授权激活数据！
		c.JSON(200, resp.ErrMsg(i18n.TKey(language, "neLicense.noData")))
		return
	}

	// 更新授权码
	code, licensePath := s.neLicenseService.ReadLicenseInfo(neLicense)
	neLicense.ActivationRequestCode = code
	if licensePath != "" {
		neLicense.LicensePath = licensePath
	} else {
		neLicense.SerialNum = ""
		neLicense.ExpiryDate = ""
		neLicense.UeNumber = 0
		neLicense.NbNumber = 0
		neLicense.Status = "0"
	}
	neLicense.UpdateBy = reqctx.LoginUserToUserName(c)
	s.neLicenseService.Update(neLicense)

	c.JSON(200, resp.OkData(code))
}

// 网元授权激活授权文件替换
//
// POST /change
//
//	@Tags			ne
//	@Accept			json
//	@Produce		json
//	@Param			data	body		object	true	"Request Param"
//	@Success		200		{object}	object	"Response Results"
//	@Security		TokenAuth
//	@Summary		Network element authorization activation status
//	@Description	Network element authorization activation status
//	@Router			/ne/license/change [post]
func (s *NeLicenseController) Change(c *gin.Context) {
	language := reqctx.AcceptLanguage(c)
	var body model.NeLicense
	err := c.ShouldBindBodyWithJSON(&body)
	if err != nil || body.LicensePath == "" {
		errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
		c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
		return
	}

	// 检查是否存在授权记录
	neLicense := s.neLicenseService.FindByNeTypeAndNeID(body.NeType, body.NeId)
	if neLicense.NeId != body.NeId {
		// 没有可访问网元授权激活数据！
		c.JSON(200, resp.ErrMsg(i18n.TKey(language, "neLicense.noData")))
		return
	}

	// 更新授权记录
	if body.Remark != "" {
		neLicense.Remark = body.Remark
	}
	neLicense.LicensePath = body.LicensePath
	neLicense.Status = "0"
	neLicense.UpdateBy = reqctx.LoginUserToUserName(c)
	upRows := s.neLicenseService.Update(neLicense)
	if upRows > 0 {
		// 进行上传替换
		err = s.neLicenseService.UploadLicense(body)
		if err != nil {
			c.JSON(200, resp.ErrMsg(err.Error()))
			return
		}
		c.JSON(200, resp.Ok(nil))
		return
	}
	c.JSON(200, resp.Err(nil))
}

// 网元授权激活状态
//
// GET /state
//
//	@Tags			ne
//	@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)
//	@Success		200		{object}	object	"Response Results"
//	@Security		TokenAuth
//	@Summary		Network element authorization activation status
//	@Description	Network element authorization activation status
//	@Router			/ne/license/state [get]
func (s *NeLicenseController) State(c *gin.Context) {
	language := reqctx.AcceptLanguage(c)
	var querys struct {
		NeType string `form:"neType" binding:"required"`
		NeId   string `form:"neId" binding:"required"`
	}
	if err := c.ShouldBindQuery(&querys); err != nil {
		c.JSON(400, resp.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
		return
	}

	// 检查是否存在授权记录
	neLicense := s.neLicenseService.FindByNeTypeAndNeID(querys.NeType, querys.NeId)
	if neLicense.NeId != querys.NeId {
		// 没有可访问网元授权激活数据！
		c.JSON(200, resp.ErrMsg(i18n.TKey(language, "neLicense.noData")))
		return
	}

	// 查询网元获取IP获取网元状态
	neInfo := s.neInfoService.FindByNeTypeAndNeID(neLicense.NeType, neLicense.NeId)
	if neInfo.NeId != neLicense.NeId || neInfo.IP == "" {
		c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
		return
	}
	if neState, err := neFetchlink.NeState(neInfo); err == nil && neState["sn"] != nil {
		neLicense.Status = "1"
		neLicense.SerialNum = fmt.Sprint(neState["sn"])
		neLicense.ExpiryDate = fmt.Sprint(neState["expire"])
		neLicense.UeNumber = parse.Number(neState["ueNumber"])
		neLicense.NbNumber = parse.Number(neState["nbNumber"])
	} else {
		neLicense.Status = "0"
	}
	// 更新授权码
	if neLicense.ActivationRequestCode == "" || strings.HasPrefix(neLicense.ActivationRequestCode, "SN") || neLicense.Status == "0" {
		code, licensePath := s.neLicenseService.ReadLicenseInfo(neLicense)
		neLicense.ActivationRequestCode = code
		neLicense.LicensePath = licensePath
	}

	// 更新授权信息
	neLicense.UpdateBy = reqctx.LoginUserToUserName(c)
	s.neLicenseService.Update(neLicense)

	if neLicense.Status == "1" {
		c.JSON(200, resp.OkData(map[string]any{
			"sn":       neLicense.SerialNum,
			"expire":   neLicense.ExpiryDate,
			"ueNumber": neLicense.UeNumber,
			"nbNumber": neLicense.NbNumber,
		}))
		return
	}
	c.JSON(200, resp.ErrMsg(fmt.Sprintf("%s service status exception", neLicense.NeType)))
}
