package controller

import (
	"fmt"
	"path/filepath"
	"strings"
	"time"

	"be.ems/src/framework/constants"
	"be.ems/src/framework/i18n"
	"be.ems/src/framework/reqctx"
	"be.ems/src/framework/resp"
	"be.ems/src/framework/telnet"
	"be.ems/src/framework/utils/file"
	"be.ems/src/framework/utils/parse"
	neService "be.ems/src/modules/ne/service"
	"be.ems/src/modules/ne_data_nf/model"
	"be.ems/src/modules/ne_data_nf/service"

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

// 实例化控制层 UDMVolteIMSController 结构体
var NewUDMVolteIMS = &UDMVolteIMSController{
	udmVolteIMSService: service.NewUDMVolteIMSUser,
	neInfoService:      neService.NewNeInfo,
}

// UDMVolteIMS用户
//
// PATH /udm/volte-ims
type UDMVolteIMSController struct {
	udmVolteIMSService *service.UDMVolteIMSUser // UDMVolteIMS信息服务
	neInfoService      *neService.NeInfo        // 网元信息服务
}

// UDMVolteIMS用户重载数据
//
// PUT /reset
//
//	@Tags			network_data/udm/volte-ims
//	@Accept			json
//	@Produce		json
//	@Param			neUid	query		string	true	"NE UID"	default(8I73Y01Z)//	@Success		200		{object}	object	"Response Results"
//	@Security		TokenAuth
//	@Summary		UDM VolteIMS User Data Refresh
//	@Description	UDM Authenticated User Data List Refresh Synchronization Latest
//	@Router			/nf/udm/volte-ims/reset [put]
func (s *UDMVolteIMSController) ResetData(c *gin.Context) {
	var query struct {
		NeUID string `form:"neUid" 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.FindByNeUid(query.NeUID)
	if neInfo.ID == 0 || neInfo.NeUid != query.NeUID {
		c.JSON(200, resp.ErrMsg("neinfo not found"))
		return
	}

	data := s.udmVolteIMSService.ResetData(neInfo.ID)
	c.JSON(200, resp.OkData(data))
}

// UDMVolteIMS用户列表
//
// GET /list
//
//	@Tags			network_data/udm/volte-ims
//	@Accept			json
//	@Produce		json
//	@Param			neId		query		string	true	"NE ID"	default(001)
//	@Param			imsi		query		string	false	"IMSI"
//	@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		UDM VolteIMS User List
//	@Description	UDM VolteIMS User List
//	@Router			/nf/udm/volte-ims/list [get]
func (s *UDMVolteIMSController) List(c *gin.Context) {
	query := reqctx.QueryMap(c)
	rows, total := s.udmVolteIMSService.FindByPage(query)
	c.JSON(200, resp.OkData(map[string]any{"rows": rows, "total": total}))
}

// UDMVolteIMS用户信息
//
// GET /
//
//	@Tags			network_data/udm/volte-ims
//	@Accept			json
//	@Produce		json
//	@Param			neId	path		string	true	"NE ID"	default(001)
//	@Param			value	path		string	true	"IMSI"
//	@Param			msisdn		query		string	true	"MSISDN"
//	@Success		200		{object}	object	"Response Results"
//	@Security		TokenAuth
//	@Summary		UDM VolteIMS User Information
//	@Description	UDM VolteIMS User Information
//	@Router			/nf/udm/volte-ims [get]
func (s *UDMVolteIMSController) Info(c *gin.Context) {
	language := reqctx.AcceptLanguage(c)
	var query struct {
		NeUID  string `form:"neUid" binding:"required"`           // 网元唯一标识
		IMSI   string `form:"imsi" binding:"required"`            // IMSi
		MSISDN string `form:"msisdn" binding:"required"`          // MSISDN
		Volte  string `form:"volte" binding:"required,oneof=0 1"` // Volte
	}
	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.FindByNeUid(query.NeUID)
	if neInfo.ID == 0 || neInfo.NeUid != query.NeUID || neInfo.NeType != "UDM" {
		c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
		return
	}
	// 网元主机的Telnet客户端
	telnetClient, err := s.neInfoService.NeRunTelnetClient(neInfo.ID, 1)
	if err != nil {
		c.JSON(200, resp.ErrMsg(err.Error()))
		return
	}
	defer telnetClient.Close()

	// 发送MML
	cmd := fmt.Sprintf("dsp imsuser:imsi=%s,msisdn=%s,volte=%s", query.IMSI, query.MSISDN, query.Volte)
	data, err := telnet.ConvertToMap(telnetClient, cmd)
	if err != nil {
		c.JSON(200, resp.ErrMsg(err.Error()))
		return
	}

	if len(data) == 0 {
		c.JSON(200, resp.ErrMsg("No Volte IMS Data"))
		return
	}
	if _, ok := data["COMMAND NOT FOUND, opr"]; ok {
		c.JSON(200, resp.ErrMsg("command not found"))
		return
	}

	// 解析返回的数据
	u := s.udmVolteIMSService.ParseInfo(neInfo.ID, data)
	if u.ID > 0 {
		s.udmVolteIMSService.InsertByIMSI(neInfo.ID, query.IMSI)
		c.JSON(200, resp.OkData(u))
		return
	}
	c.JSON(200, resp.ErrMsg("No Volte IMS Data"))
}

// UDMVolteIMS用户新增
//
// POST /
//
//	@Tags			network_data/udm/volte-ims
//	@Accept			json
//	@Produce		json
//	@Param			neId	path		string	true	"NE ID"	default(001)
//	@Param			data	body		object	true	"Request Param"
//	@Success		200		{object}	object	"Response Results"
//	@Security		TokenAuth
//	@Summary		UDM VolteIMS User Added
//	@Description	UDM VolteIMS User Added If VoIP tag=0, then MSISDN and IMSI need to be the same.
//	@Router			/nf/udm/volte-ims [post]
func (s *UDMVolteIMSController) Add(c *gin.Context) {
	language := reqctx.AcceptLanguage(c)
	// 传入数量大于0时，为批量新增
	num := parse.Number(c.Query("num"))
	if num < 0 {
		c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: num is less than 0"))
		return
	}

	var body model.UDMVolteIMSUser
	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
	}
	if body.IMSI == "" {
		c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: imsi is empty"))
		return
	}

	// 查询网元信息
	neInfo := s.neInfoService.FindByNeId(body.NeID)
	if neInfo.ID == 0 || neInfo.ID != body.NeID || neInfo.NeType != "UDM" {
		c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
		return
	}
	// 网元主机的Telnet客户端
	telnetClient, err := s.neInfoService.NeRunTelnetClient(neInfo.ID, 1)
	if err != nil {
		c.JSON(200, resp.ErrMsg(err.Error()))
		return
	}
	defer telnetClient.Close()

	// 批量新增
	if num > 1 {
		// 发送MML
		cmd := fmt.Sprintf("baa imsuser:sub_num=%d,start_imsi=%s,start_msisdn=%s,volte=%s,vni=%s", num, body.IMSI, body.MSISDN, body.Tag, body.VNI)
		data, err := telnet.ConvertToStr(telnetClient, cmd)
		if err != nil {
			c.JSON(200, resp.ErrMsg(err.Error()))
			return
		}

		// 命令ok时
		if strings.Contains(data, "ok") {
			s.udmVolteIMSService.LoadData(neInfo.ID, body.IMSI, num)
		}
		c.JSON(200, resp.OkData(data))
		return
	}

	// 检查同IMSI下msisdn是否存在
	hasMsisdns := s.udmVolteIMSService.Find(model.UDMVolteIMSUser{IMSI: body.IMSI, MSISDN: body.MSISDN, NeID: neInfo.ID})
	if len(hasMsisdns) > 0 {
		c.JSON(200, resp.ErrMsg("IMSI and MSISDN already exist"))
		return
	}

	// 发送MML
	cmd := fmt.Sprintf("add imsuser:imsi=%s,msisdn=%s,volte=%s,vni=%s", body.IMSI, body.MSISDN, body.Tag, body.VNI)
	data, err := telnet.ConvertToStr(telnetClient, cmd)
	if err != nil {
		c.JSON(200, resp.ErrMsg(err.Error()))
		return
	}

	// 命令ok时
	if strings.Contains(data, "ok") {
		s.udmVolteIMSService.InsertByIMSI(neInfo.ID, body.IMSI)
	}
	c.JSON(200, resp.OkData(data))
}

// UDMVolteIMS用户删除
//
// DELETE /
//
//	@Tags			network_data/udm/volte-ims
//	@Accept			json
//	@Produce		json
//	@Param			neUid	query		string	true	"NE UID"	default(8I73Y01Z)//	@Param			imsi	query		string	true	"IMSI"
//	@Param			num		query		number	true	"Number of releases, value includes start imsi"
//	@Param			msisdn		query		string	false	"MSISDN"
//	@Success		200		{object}	object	"Response Results"
//	@Security		TokenAuth
//	@Summary		UDM VolteIMS User Batch Deletion
//	@Description	UDM VolteIMS User Batch Deletion
//	@Router			/nf/udm/volte-ims [delete]
func (s *UDMVolteIMSController) Remove(c *gin.Context) {
	language := reqctx.AcceptLanguage(c)
	var query struct {
		NeUID  string `form:"neUid" binding:"required"`         // 网元唯一标识
		IMSI   string `form:"imsi" binding:"required"`          // IMSi, 带数量时为批量
		MSISDN string `form:"msisdn" binding:"required"`        // MSISDN, 带数量时为批量
		Tag    string `form:"tag" binding:"required,oneof=0 1"` // tag
		Num    int64  `form:"num"`                              // 批量数量
	}
	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.FindByNeUid(query.NeUID)
	if neInfo.ID == 0 || neInfo.NeUid != query.NeUID || neInfo.NeType != "UDM" {
		c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
		return
	}
	// 网元主机的Telnet客户端
	telnetClient, err := s.neInfoService.NeRunTelnetClient(neInfo.ID, 1)
	if err != nil {
		c.JSON(200, resp.ErrMsg(err.Error()))
		return
	}
	defer telnetClient.Close()

	// 批量更新
	if query.Num > 1 {
		// 发送MML
		cmd := ""
		if query.Tag == "0" {
			cmd = fmt.Sprintf("bde imsuser:start_msisdn=%s,sub_num=%d,volte=0", query.MSISDN, query.Num)
		}
		if query.Tag == "1" {
			cmd = fmt.Sprintf("bde imsuser:start_imsi=%s,start_msisdn=%s,sub_num=%d,volte=1", query.IMSI, query.MSISDN, query.Num)
		}
		data, err := telnet.ConvertToStr(telnetClient, cmd)
		if err != nil {
			c.JSON(200, resp.ErrMsg(err.Error()))
			return
		}

		// 命令ok时
		if strings.Contains(data, "ok") {
			s.udmVolteIMSService.LoadData(neInfo.ID, query.IMSI, query.Num)
		}
		c.JSON(200, resp.OkData(data))
		return
	}

	// 发送MML
	cmd := fmt.Sprintf("del imsuser:imsi=%s,msisdn=%s,volte=%s", query.IMSI, query.MSISDN, query.Tag)
	data, err := telnet.ConvertToStr(telnetClient, cmd)
	if err != nil {
		c.JSON(200, resp.ErrMsg(err.Error()))
		return
	}
	// 命令ok时
	if strings.Contains(data, "ok") {
		s.udmVolteIMSService.Delete(neInfo.ID, query.IMSI)
	}
	c.JSON(200, resp.OkData(data))
}

// UDMVolteIMS用户导出
//
// GET /export
//
//	@Tags			network_data/udm/volte-ims
//	@Accept			json
//	@Produce		json
//	@Param			neUid	query		string	true	"NE UID"	default(8I73Y01Z)/	@Param			type		query		string	true	"File Type"	Enums(csv,txt)	default(txt)
//	@Param			imsi		query		string	false	"IMSI"
//	@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		UDM Authenticated User Export
//	@Description	UDM Authenticated User Export
//	@Router			/nf/udm/volte-ims/export [get]
func (s *UDMVolteIMSController) Export(c *gin.Context) {
	language := reqctx.AcceptLanguage(c)
	neUid := c.Query("neUid")
	if neUid == "" {
		c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: neUid is empty"))
		return
	}
	fileType := c.Query("type")
	if !(fileType == "csv" || fileType == "txt") {
		c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "file type error, only support csv,txt"))
		return
	}

	query := reqctx.QueryMap(c)
	rows, total := s.udmVolteIMSService.FindByPage(query)
	if total == 0 {
		// 导出数据记录为空
		c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
		return
	}
	if len(rows) <= 0 {
		// 导出数据记录为空
		c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
		return
	}

	// 文件名
	fileName := fmt.Sprintf("udm_volte_user_export_%s_%d.%s", neUid, time.Now().UnixMilli(), fileType)
	filePath := filepath.Join(file.ParseUploadFileDir(constants.UPLOAD_EXPORT), fileName)

	if fileType == "csv" {
		// 转换数据
		data := [][]string{}
		data = append(data, []string{"IMSI", "MSISDN", "TAG", "VNI"})
		for _, v := range rows {
			data = append(data, []string{v.IMSI, v.MSISDN, v.Tag, v.VNI})
		}
		// 输出到文件
		if err := file.WriterFileCSV(data, filePath); err != nil {
			c.JSON(200, resp.ErrMsg(err.Error()))
			return
		}
	}

	if fileType == "txt" {
		// 转换数据
		data := [][]string{}
		for _, v := range rows {
			data = append(data, []string{v.IMSI, v.MSISDN, v.Tag, v.VNI})
		}
		// 输出到文件
		if err := file.WriterFileTXTLine(data, ",", filePath); err != nil {
			c.JSON(200, resp.ErrMsg(err.Error()))
			return
		}
	}

	c.FileAttachment(filePath, fileName)
}

// UDMVolteIMS用户导入
//
// POST /import
//
//	@Tags			network_data/udm/volte-ims
//	@Accept			json
//	@Produce		json
//	@Param			data	body		object	true	"Request Param"
//	@Success		200		{object}	object	"Response Results"
//	@Security		TokenAuth
//	@Summary		UDM Authenticated User Import
//	@Description	UDM Authenticated User Import
//	@Router			/nf/udm/volte-ims/import [post]
func (s *UDMVolteIMSController) Import(c *gin.Context) {
	language := reqctx.AcceptLanguage(c)
	var body struct {
		NeUID      string `json:"neUid" binding:"required"`      // 网元唯一标识
		UploadPath string `json:"uploadPath" binding:"required"` // 上传文件路径
	}
	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
	}

	// 判断文件名
	if !(strings.HasSuffix(body.UploadPath, ".csv") || strings.HasSuffix(body.UploadPath, ".txt")) {
		c.JSON(200, resp.ErrMsg(i18n.TKey(language, "ne.udm.errImportUserAuthFileFormat")))
		return
	}

	// 查询网元信息
	neInfo := s.neInfoService.FindByNeUid(body.NeUID)
	if neInfo.ID == 0 || neInfo.NeUid != body.NeUID || neInfo.NeType != "UDM" {
		c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
		return
	}
	// 网元主机的SSH客户端
	sshClient, err := s.neInfoService.NeRunSSHClient(neInfo.ID)
	if err != nil {
		c.JSON(200, resp.ErrMsg(err.Error()))
		return
	}
	defer sshClient.Close()
	// 网元主机的SSH客户端进行文件传输
	sftpClient, err := sshClient.NewClientSFTP()
	if err != nil {
		c.JSON(200, resp.ErrMsg(err.Error()))
		return
	}
	defer sftpClient.Close()

	// 本地文件
	localFilePath := file.ParseUploadFileAbsPath(body.UploadPath)
	neFilePath := fmt.Sprintf("/tmp/%s", filepath.Base(localFilePath))
	// 复制到远程
	if err = sftpClient.CopyFileLocalToRemote(localFilePath, neFilePath); err != nil {
		c.JSON(200, resp.ErrMsg("error uploading file"))
		return
	}

	// 网元主机的Telnet客户端
	telnetClient, err := s.neInfoService.NeRunTelnetClient(neInfo.ID, 1)
	if err != nil {
		c.JSON(200, resp.ErrMsg(err.Error()))
		return
	}
	defer telnetClient.Close()

	// 结果信息
	var resultMsg string
	var resultErr error

	// 发送MML
	cmd := fmt.Sprintf("import imsuser:path=%s", neFilePath)
	resultMsg, resultErr = telnet.ConvertToStr(telnetClient, cmd)
	if resultErr != nil {
		c.JSON(200, resp.ErrMsg(resultErr.Error()))
		return
	}

	// 命令ok时
	if strings.Contains(resultMsg, "ok") {
		if strings.HasSuffix(body.UploadPath, ".csv") {
			data := file.ReadFileCSV(localFilePath)
			go s.udmVolteIMSService.InsertData(neInfo.ID, "csv", data)
		}
		if strings.HasSuffix(body.UploadPath, ".txt") {
			data := file.ReadFileTXTLine(",", localFilePath)
			go s.udmVolteIMSService.InsertData(neInfo.ID, "txt", data)
		}
	}
	c.JSON(200, resp.OkMsg(resultMsg))
}