// 模块控制接口-基站参数
// 秒寻科技
// zt 2024-02-16

package bparamhandler

import (
	"encoding/binary"
	"fmt"
	"ipsomc/core/dao/mysql/mysqlmodel"
	"ipsomc/core/gin/bind"
	"ipsomc/core/gin/resp"
	"ipsomc/module/bparam/bparamapi"
	"ipsomc/module/bparam/bparamlogic"
	"ipsomc/module/bparam/bparammodel"
	"ipsomc/module/bparam/bparamoam"
	"ipsomc/public"
	"os"
	"strconv"
	"strings"
	"time"

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

type BparamHan struct {
	bindApi      bind.BindApi
	bparamApi    bparamapi.BparamApi
	bparamLgc    bparamlogic.BparamLgc
	bparamOamApi bparamoam.BparamOam
}

// 新增基站基本参数
func (obj *BparamHan) AddBtsBaseParamHan(c *gin.Context) {
	dataModel := new(bparammodel.BtsBaseParam)

	//把前端数据绑定到模型上
	if err := obj.bindApi.Bind2Model(c, dataModel); err != nil {
		resp.RespFail(c, "数据错误")
		return
	}

	//保存数据
	if err := obj.bparamApi.AddBtsBaseParam(dataModel); err != nil {
		resp.RespFail(c, err.Error())
		return
	}

	//返回数据
	resp.RespId(c, dataModel.ID)
}

// 修改
func (obj *BparamHan) UpdateBtsBaseParamHan(c *gin.Context) {
	dataModel := new(bparammodel.BtsBaseParam)
	dataMap := make(map[string]interface{})

	//把前端数据绑定到模型
	if err := obj.bindApi.Bind2Map(c, dataModel, dataMap); err != nil {
		resp.RespFail(c, err.Error())
		return
	}

	//保存数据
	if err := obj.bparamApi.UpdateBtsBaseParam(dataModel, dataMap); err != nil {
		resp.RespFail(c, err.Error())
		return
	}

	//返回数据
	resp.RespOk(c)
}

// 启用和停用基站
func (obj *BparamHan) EnableBtsBaseParamHan(c *gin.Context) {
	dataModel := new(bparammodel.BtsBaseParam)

	//把前端数据绑定到模型
	if err := obj.bindApi.Bind2Model(c, dataModel); err != nil {
		resp.RespFail(c, "数据错误")
		return
	}

	//保存数据
	if err := obj.bparamApi.EnableBtsBaseParam(dataModel); err != nil {
		resp.RespFail(c, err.Error())
		return
	}

	//返回数据
	resp.RespOk(c)
}

// 启用和停用基站
func (obj *BparamHan) EnableLayerBtsHan(c *gin.Context) {
	dataModel := new(bparammodel.BtsBaseParam)

	//把前端数据绑定到模型
	if err := obj.bindApi.Bind2Model(c, dataModel); err != nil {
		resp.RespFail(c, "数据错误")
		return
	}

	//保存数据
	if err := obj.bparamApi.EnableLayerBts(dataModel); err != nil {
		resp.RespFail(c, err.Error())
		return
	}

	//返回数据
	resp.RespOk(c)
}

// 删除
func (obj *BparamHan) DeleteBtsBaseParamHan(c *gin.Context) {
	dataModel := new(bparammodel.BtsBaseParam)

	//把前端数据绑定到模型
	if err := obj.bindApi.Bind2Model(c, dataModel); err != nil {
		resp.RespFail(c, "数据解析错误")
		return
	}

	if err := obj.bparamApi.DeleteBtsBaseParam(dataModel); err != nil {
		resp.RespFail(c, err.Error())
		return
	}

	//返回数据
	resp.RespOk(c)
}

// 查询单条记录
func (obj *BparamHan) GetBtsBaseParamByIdHan(c *gin.Context) {
	dataModel := new(bparammodel.BtsBaseParam)

	//把前端数据绑定到模型
	if err := obj.bindApi.Bind2Model(c, dataModel); err != nil {
		resp.RespFail(c, "数据解析错误")
		return
	}

	if err := obj.bparamApi.GetBtsBaseParamById(dataModel); err != nil {
		resp.RespFail(c, err.Error())
		return
	}

	//返回数据
	resp.RespData(c, dataModel)
}

// 查询满足条件的所有记录
func (obj *BparamHan) GetBtsBaseParamListHan(c *gin.Context) {
	dataModel := new(bparammodel.BtsBaseParam)
	listParam := new(mysqlmodel.ListParam)
	dataList := []bparammodel.BtsBaseParam{}

	//把前端数据绑定到模型
	if err := obj.bindApi.Bind2Query(c, listParam); err != nil {
		resp.RespFail(c, "数据解析错误")
		return
	}

	//查询满足条件的记录
	err := obj.bparamApi.GetBtsBaseParamList(dataModel, listParam, &dataList)
	if err != nil {
		resp.RespFail(c, err.Error())
		return
	}

	//更新基站在线状态
	existFlag := false
	if len(public.Gpub_mapHeart) > 0 {
		//更新基站状态
		for i, btsParam := range dataList {
			existFlag = false

			//修改基站状态
			for _, v := range public.Gpub_mapHeart {
				if btsParam.ProjectID == v.ProjectID && btsParam.BtsID == v.BtsID {
					dataList[i].Status = 2 //在线
					existFlag = true
					break
				}
			}

			if !existFlag && btsParam.Status == 2 {
				dataList[i].Status = 1 //离线
			}

		}
	}

	//返回记录
	resp.RespList(c, dataList)
}

// 分页查询
func (obj *BparamHan) GetBtsBaseParamPageListHan(c *gin.Context) {
	dataModel := new(bparammodel.BtsBaseParam)
	pageListParam := new(mysqlmodel.PageListParam)
	dataList := []bparammodel.BtsBaseParam{}

	//把前端数据绑定到模型
	if err := obj.bindApi.Bind2PageQuery(c, pageListParam); err != nil {
		resp.RespFail(c, "数据解析错误")
		return
	}

	pageListData, err := obj.bparamApi.GetBtsBaseParamPageList(dataModel, pageListParam, &dataList)
	if err != nil {
		resp.RespFail(c, err.Error())
		return
	}

	//更新基站在线状态
	existFlag := false
	if len(public.Gpub_mapHeart) > 0 {
		//更新基站状态
		for i, btsParam := range dataList {
			existFlag = false

			//修改基站状态
			for _, v := range public.Gpub_mapHeart {
				if btsParam.ProjectID == v.ProjectID && btsParam.BtsID == v.BtsID {
					dataList[i].Status = 2 //在线
					existFlag = true
					break
				}
			}

			if !existFlag && btsParam.Status == 2 {
				dataList[i].Status = 1 //离线
			}

		}
	}

	resp.RespList(c, pageListData)
}

// 移动端查询基站参数
func (obj *BparamHan) GetMobileBtsParamListHan(c *gin.Context) {
	dataModel := new(bparammodel.BtsBaseParam)

	//把前端数据绑定到模型
	if err := obj.bindApi.Bind2Model(c, dataModel); err != nil {
		resp.RespFail(c, "数据解析错误")
		return
	}

	//查询满足条件的
	dataList, err := obj.bparamApi.GetMobileBtsParamList(dataModel)
	if err != nil {
		resp.RespFail(c, "查询数据错误")
		return
	}

	//返回记录
	resp.RespList(c, dataList)
}

// 移动端查询某大楼某楼层基站参数
func (obj *BparamHan) GetMobileLayerBtsParamListHan(c *gin.Context) {
	dataModel := new(bparammodel.BtsBaseParam)

	//把前端数据绑定到模型
	if err := obj.bindApi.Bind2Model(c, dataModel); err != nil {
		resp.RespFail(c, "数据解析错误")
		return
	}

	//查询满足条件的
	dataList, err := obj.bparamApi.GetMobileLayerBtsParamList(dataModel)
	if err != nil {
		resp.RespFail(c, "查询数据错误")
		return
	}

	//返回记录
	resp.RespList(c, dataList)
}

// 本地网管新增基站基本参数
func (obj *BparamHan) GuiUploadBtsBaseParamAddHan(c *gin.Context) {
	dataModel := new(bparammodel.BtsBaseParam)

	//把前端数据绑定到模型上
	if err := obj.bindApi.Bind2Model(c, dataModel); err != nil {
		resp.RespFail(c, "数据错误")
		return
	}

	//保存数据
	if err := obj.bparamApi.AddBtsBaseParam(dataModel); err != nil {
		resp.RespFail(c, err.Error())
		return
	}

	//返回数据
	resp.RespId(c, dataModel.ID)
}

// 本地网管修改基站基本参数
func (obj *BparamHan) GuiUploadBtsBaseParamUpdateHan(c *gin.Context) {
	dataModel := new(bparammodel.BtsBaseParam)
	dataMap := make(map[string]interface{})

	//把前端数据绑定到模型
	if err := obj.bindApi.Bind2Map(c, dataModel, dataMap); err != nil {
		resp.RespFail(c, err.Error())
		return
	}

	//保存数据
	if err := obj.bparamLgc.UploadBparamLgc(dataModel, dataMap); err != nil {
		resp.RespFail(c, err.Error())
		return
	}

	//返回数据
	resp.RespOk(c)
}

//***********************************以上是http命令**********************************************
//**********************************************************************************************
//***********************************下面是socket命令********************************************

// 保存http请求通道
func (obj *BparamHan) SaveRequestChan(httpReqChan chan interface{}, ProjectID int, BtsID int, mcpCmdType uint8, moduleId uint8) {
	requestIdStr := fmt.Sprintf("%08X", ProjectID) + "-" + fmt.Sprintf("%08X", BtsID) + "-" + fmt.Sprintf("%d", mcpCmdType) + "-" + fmt.Sprintf("%d", moduleId)
	public.Gpub_mutex.Lock()
	public.Gpub_mapChan[requestIdStr] = httpReqChan //保存通道
	public.Gpub_mutex.Unlock()
}

// 返回数据并删除http请求通道
func (obj *BparamHan) RespDataWithChan(c *gin.Context, httpReqChan chan interface{}, ProjectID int, BtsID int, mcpCmdType uint8, moduleId uint8) {
	requestIdStr := fmt.Sprintf("%08X", ProjectID) + "-" + fmt.Sprintf("%08X", BtsID) + "-" + fmt.Sprintf("%d", mcpCmdType) + "-" + fmt.Sprintf("%d", moduleId)

	//把数据返回给客户端
	select {
	case v := <-httpReqChan:
		resp.RespData(c, v) //数据返回前端
	case <-time.After(10 * time.Second): // 10秒超时
		resp.RespFail(c, "查询超时")
	}

	close(httpReqChan) //关闭通道

	public.Gpub_mutex.Lock()
	delete(public.Gpub_mapChan, requestIdStr)
	public.Gpub_mutex.Unlock()
}

// 查询基站设备参数
func (obj *BparamHan) GetBtsOamParamDeviceHan(c *gin.Context) {
	dataModel := new(bparammodel.BtsBaseParam)

	//把前端数据绑定到模型上
	if err := obj.bindApi.Bind2Model(c, dataModel); err != nil {
		resp.RespFail(c, "数据错误")
		return
	}

	//生成并保存http请求通道
	httpReqChan := make(chan interface{})
	obj.SaveRequestChan(httpReqChan, dataModel.ProjectID, dataModel.BtsID, public.BTS_MCP_QUERY, public.BTS_MODULE_DEVICE)

	//查询基站参数
	if err := obj.bparamOamApi.OamQueryDeviceParam(dataModel); err != nil {
		resp.RespFail(c, "查询数据错误")
	}

	//返回数据并删除http请求通道
	obj.RespDataWithChan(c, httpReqChan, dataModel.ProjectID, dataModel.BtsID, public.BTS_MCP_QUERY, public.BTS_MODULE_DEVICE)
}

// 查询基站网管参数
func (obj *BparamHan) GetBtsOamParamNetworkHan(c *gin.Context) {
	dataModel := new(bparammodel.BtsBaseParam)

	//把前端数据绑定到模型上
	if err := obj.bindApi.Bind2Model(c, dataModel); err != nil {
		resp.RespFail(c, "数据错误")
		return
	}

	//生成并保存http请求通道
	httpReqChan := make(chan interface{})
	obj.SaveRequestChan(httpReqChan, dataModel.ProjectID, dataModel.BtsID, public.BTS_MCP_QUERY, public.BTS_MODULE_NETWORK)

	//查询基站参数
	if err := obj.bparamOamApi.OamQueryNetworkParam(dataModel); err != nil {
		resp.RespFail(c, "查询数据错误")
	}

	//返回数据并删除http请求通道
	obj.RespDataWithChan(c, httpReqChan, dataModel.ProjectID, dataModel.BtsID, public.BTS_MCP_QUERY, public.BTS_MODULE_NETWORK)
}

// 设置基站网管参数
func (obj *BparamHan) SetBtsOamParamNetworkHan(c *gin.Context) {
	dataModel := new(bparammodel.BtsBaseParam)

	//把前端数据绑定到模型上
	if err := obj.bindApi.Bind2Model(c, dataModel); err != nil {
		resp.RespFail(c, "数据错误")
		return
	}

	//生成并保存http请求通道
	httpReqChan := make(chan interface{})
	obj.SaveRequestChan(httpReqChan, dataModel.ProjectID, dataModel.BtsID, public.BTS_MCP_SET, public.BTS_MODULE_NETWORK)

	//设置基站参数
	if err := obj.bparamOamApi.OamSetNetworkParam(dataModel); err != nil {
		resp.RespFail(c, "设置数据错误")
	}

	//返回数据并删除http请求通道
	obj.RespDataWithChan(c, httpReqChan, dataModel.ProjectID, dataModel.BtsID, public.BTS_MCP_SET, public.BTS_MODULE_NETWORK)
}

// 查询基站同步参数
func (obj *BparamHan) GetBtsOamParamSyncHan(c *gin.Context) {
	dataModel := new(bparammodel.BtsBaseParam)

	//把前端数据绑定到模型上
	if err := obj.bindApi.Bind2Model(c, dataModel); err != nil {
		resp.RespFail(c, "数据错误")
		return
	}

	//生成并保存http请求通道
	httpReqChan := make(chan interface{})
	obj.SaveRequestChan(httpReqChan, dataModel.ProjectID, dataModel.BtsID, public.BTS_MCP_QUERY, public.BTS_MODULE_SYNC)

	//查询基站参数
	if err := obj.bparamOamApi.OamQuerySyncParam(dataModel); err != nil {
		resp.RespFail(c, "查询数据错误")
	}

	//返回数据并删除http请求通道
	obj.RespDataWithChan(c, httpReqChan, dataModel.ProjectID, dataModel.BtsID, public.BTS_MCP_QUERY, public.BTS_MODULE_SYNC)
}

// 设置基站同步参数
func (obj *BparamHan) SetBtsOamParamSyncHan(c *gin.Context) {
	dataModel := new(bparammodel.BtsBaseParam)

	//把前端数据绑定到模型上
	if err := obj.bindApi.Bind2Model(c, dataModel); err != nil {
		resp.RespFail(c, "数据错误")
		return
	}

	//生成并保存http请求通道
	httpReqChan := make(chan interface{})
	obj.SaveRequestChan(httpReqChan, dataModel.ProjectID, dataModel.BtsID, public.BTS_MCP_SET, public.BTS_MODULE_SYNC)

	//设置基站参数
	if err := obj.bparamOamApi.OamSetSyncParam(dataModel); err != nil {
		resp.RespFail(c, "设置数据错误")
	}

	//返回数据并删除http请求通道
	obj.RespDataWithChan(c, httpReqChan, dataModel.ProjectID, dataModel.BtsID, public.BTS_MCP_SET, public.BTS_MODULE_SYNC)
}

// 查询基站增益参数
func (obj *BparamHan) GetBtsOamParamGainHan(c *gin.Context) {
	dataModel := new(bparammodel.BtsDeviceParam)

	//把前端数据绑定到模型上
	if err := obj.bindApi.Bind2Model(c, dataModel); err != nil {
		resp.RespFail(c, "数据错误")
		return
	}

	//生成并保存http请求通道
	httpReqChan := make(chan interface{})
	obj.SaveRequestChan(httpReqChan, dataModel.ProjectID, dataModel.BtsID, public.BTS_MCP_QUERY, public.BTS_MODULE_GAIN)

	//查询基站参数
	if err := obj.bparamOamApi.OamQueryGainParam(dataModel); err != nil {
		resp.RespFail(c, "查询数据错误")
	}

	//返回数据并删除http请求通道
	obj.RespDataWithChan(c, httpReqChan, dataModel.ProjectID, dataModel.BtsID, public.BTS_MCP_QUERY, public.BTS_MODULE_GAIN)
}

// 设置基站增益参数
func (obj *BparamHan) SetBtsOamParamGainHan(c *gin.Context) {
	dataModel := new(bparammodel.BtsBaseParam)

	//把前端数据绑定到模型上
	if err := obj.bindApi.Bind2Model(c, dataModel); err != nil {
		resp.RespFail(c, "数据错误")
		return
	}

	//生成并保存http请求通道
	httpReqChan := make(chan interface{})
	obj.SaveRequestChan(httpReqChan, dataModel.ProjectID, dataModel.BtsID, public.BTS_MCP_SET, public.BTS_MODULE_GAIN)

	//设置基站参数
	if err := obj.bparamOamApi.OamSetGainParam(dataModel); err != nil {
		resp.RespFail(c, "设置数据错误")
	}

	//返回数据并删除http请求通道
	obj.RespDataWithChan(c, httpReqChan, dataModel.ProjectID, dataModel.BtsID, public.BTS_MCP_SET, public.BTS_MODULE_GAIN)
}

// 查询安装参数
func (obj *BparamHan) GetBtsOamParamInstallHan(c *gin.Context) {
	dataModel := new(bparammodel.BtsDeviceParam)

	//把前端数据绑定到模型上
	if err := obj.bindApi.Bind2Model(c, dataModel); err != nil {
		resp.RespFail(c, "数据错误")
		return
	}

	//生成并保存http请求通道
	httpReqChan := make(chan interface{})
	obj.SaveRequestChan(httpReqChan, dataModel.ProjectID, dataModel.BtsID, public.BTS_MCP_QUERY, public.BTS_MODULE_INSTALL)

	//查询基站参数
	if err := obj.bparamOamApi.OamQueryInstallParam(dataModel); err != nil {
		resp.RespFail(c, "查询数据错误")
	}

	//返回数据并删除http请求通道
	obj.RespDataWithChan(c, httpReqChan, dataModel.ProjectID, dataModel.BtsID, public.BTS_MCP_QUERY, public.BTS_MODULE_INSTALL)
}

// 配置基站参数
func (obj *BparamHan) SetBtsOamParamInstallHan(c *gin.Context) {
	dataModel := new(bparammodel.BtsBaseParam)

	//把前端数据绑定到模型上
	if err := obj.bindApi.Bind2Model(c, dataModel); err != nil {
		resp.RespFail(c, "数据错误")
		return
	}

	//生成并保存http请求通道
	httpReqChan := make(chan interface{})
	obj.SaveRequestChan(httpReqChan, dataModel.ProjectID, dataModel.BtsID, public.BTS_MCP_SET, public.BTS_MODULE_INSTALL)

	//设置基站参数
	if err := obj.bparamOamApi.OamSetInstallParam(dataModel); err != nil {
		resp.RespFail(c, "设置数据错误")
	}

	//返回数据并删除http请求通道
	obj.RespDataWithChan(c, httpReqChan, dataModel.ProjectID, dataModel.BtsID, public.BTS_MCP_SET, public.BTS_MODULE_INSTALL)
}

// 查询基站参数
func (obj *BparamHan) GetBtsOamParamBtsHan(c *gin.Context) {
	dataModel := new(bparammodel.BtsDeviceParam)

	//把前端数据绑定到模型上
	if err := obj.bindApi.Bind2Model(c, dataModel); err != nil {
		resp.RespFail(c, "数据错误")
		return
	}

	//生成并保存http请求通道
	httpReqChan := make(chan interface{})
	obj.SaveRequestChan(httpReqChan, dataModel.ProjectID, dataModel.BtsID, public.BTS_MCP_QUERY, public.BTS_MODULE_BTS)

	//查询基站参数
	if err := obj.bparamOamApi.OamQueryBtsParam(dataModel); err != nil {
		resp.RespFail(c, "查询数据错误")
	}

	//返回数据并删除http请求通道
	obj.RespDataWithChan(c, httpReqChan, dataModel.ProjectID, dataModel.BtsID, public.BTS_MCP_QUERY, public.BTS_MODULE_BTS)
}

// 配置基站参数
func (obj *BparamHan) SetBtsOamParamBtsHan(c *gin.Context) {
	dataModel := new(bparammodel.BtsBaseParam)

	//把前端数据绑定到模型上
	if err := obj.bindApi.Bind2Model(c, dataModel); err != nil {
		resp.RespFail(c, "数据错误")
		return
	}

	//生成并保存http请求通道
	httpReqChan := make(chan interface{})
	obj.SaveRequestChan(httpReqChan, dataModel.ProjectID, dataModel.BtsID, public.BTS_MCP_SET, public.BTS_MODULE_BTS)

	//设置基站参数
	if err := obj.bparamOamApi.OamSetBtsParam(dataModel); err != nil {
		resp.RespFail(c, "设置数据错误")
	}

	//返回数据并删除http请求通道
	obj.RespDataWithChan(c, httpReqChan, dataModel.ProjectID, dataModel.BtsID, public.BTS_MCP_SET, public.BTS_MODULE_BTS)
}

// 查询定位类型参数
func (obj *BparamHan) GetBtsOamParamLocationTypeHan(c *gin.Context) {
	dataModel := new(bparammodel.BtsDeviceParam)

	//把前端数据绑定到模型上
	if err := obj.bindApi.Bind2Model(c, dataModel); err != nil {
		resp.RespFail(c, "数据错误")
		return
	}

	//生成并保存http请求通道
	httpReqChan := make(chan interface{})
	obj.SaveRequestChan(httpReqChan, dataModel.ProjectID, dataModel.BtsID, public.BTS_MCP_QUERY, public.BTS_MODULE_BTS)

	//查询基站参数
	if err := obj.bparamOamApi.OamQueryLocationTypeParam(dataModel); err != nil {
		resp.RespFail(c, "查询数据错误")
	}

	//返回数据并删除http请求通道
	obj.RespDataWithChan(c, httpReqChan, dataModel.ProjectID, dataModel.BtsID, public.BTS_MCP_QUERY, public.BTS_MODULE_BTS)
}

// 配置定位类型参数
func (obj *BparamHan) SetBtsOamParamLocationTypeHan(c *gin.Context) {
	dataModel := new(bparammodel.BtsBaseParam)

	//把前端数据绑定到模型上
	if err := obj.bindApi.Bind2Model(c, dataModel); err != nil {
		resp.RespFail(c, "数据错误")
		return
	}

	//生成并保存http请求通道
	httpReqChan := make(chan interface{})
	obj.SaveRequestChan(httpReqChan, dataModel.ProjectID, dataModel.BtsID, public.BTS_MCP_SET, public.BTS_MODULE_BTS)

	//设置基站参数
	if err := obj.bparamOamApi.OamSetLocationTypeParam(dataModel); err != nil {
		resp.RespFail(c, "设置数据错误")
	}

	//返回数据并删除http请求通道
	obj.RespDataWithChan(c, httpReqChan, dataModel.ProjectID, dataModel.BtsID, public.BTS_MCP_SET, public.BTS_MODULE_BTS)
}

// 查询rtc参数
func (obj *BparamHan) GetBtsOamParamRtcHan(c *gin.Context) {
	dataModel := new(bparammodel.BtsBaseParam)

	//把前端数据绑定到模型上
	if err := obj.bindApi.Bind2Model(c, dataModel); err != nil {
		resp.RespFail(c, "数据错误")
		return
	}

	//生成并保存http请求通道
	httpReqChan := make(chan interface{})
	obj.SaveRequestChan(httpReqChan, dataModel.ProjectID, dataModel.BtsID, public.BTS_MCP_QUERY, public.BTS_MODULE_RTC)

	//查询基站参数
	if err := obj.bparamOamApi.OamQueryRtcParam(dataModel); err != nil {
		resp.RespFail(c, "查询数据错误")
	}

	//返回数据并删除http请求通道
	obj.RespDataWithChan(c, httpReqChan, dataModel.ProjectID, dataModel.BtsID, public.BTS_MCP_QUERY, public.BTS_MODULE_RTC)
}

// 配置rtc参数
func (obj *BparamHan) SetBtsOamParamRtcHan(c *gin.Context) {
	dataModel := new(bparammodel.BtsBaseParam)

	//把前端数据绑定到模型上
	if err := obj.bindApi.Bind2Model(c, dataModel); err != nil {
		resp.RespFail(c, "数据错误")
		return
	}

	//生成并保存http请求通道
	httpReqChan := make(chan interface{})
	obj.SaveRequestChan(httpReqChan, dataModel.ProjectID, dataModel.BtsID, public.BTS_MCP_SET, public.BTS_MODULE_RTC)

	//设置基站参数
	if err := obj.bparamOamApi.OamSetRtcParam(dataModel); err != nil {
		resp.RespFail(c, "设置数据错误")
	}

	//返回数据并删除http请求通道
	obj.RespDataWithChan(c, httpReqChan, dataModel.ProjectID, dataModel.BtsID, public.BTS_MCP_SET, public.BTS_MODULE_RTC)
}

// 保存参数
func (obj *BparamHan) SaveOamParamHan(c *gin.Context) {
	dataModel := new(bparammodel.BtsBaseParam)

	//把前端数据绑定到模型上
	if err := obj.bindApi.Bind2Model(c, dataModel); err != nil {
		resp.RespFail(c, "数据错误")
		return
	}

	//生成并保存http请求通道
	httpReqChan := make(chan interface{})
	obj.SaveRequestChan(httpReqChan, dataModel.ProjectID, dataModel.BtsID, public.BTS_MCP_SET, public.BTS_MODULE_GAIN)

	//设置基站参数
	if err := obj.bparamOamApi.OamSaveParam(dataModel); err != nil {
		resp.RespFail(c, "设置数据错误")
	}

	//返回数据并删除http请求通道
	obj.RespDataWithChan(c, httpReqChan, dataModel.ProjectID, dataModel.BtsID, public.BTS_MCP_SET, public.BTS_MODULE_GAIN)
}

// 复位基站
func (obj *BparamHan) ResetBtsHan(c *gin.Context) {
	dataModel := new(bparammodel.BtsBaseParam)

	//把前端数据绑定到模型上
	if err := obj.bindApi.Bind2Model(c, dataModel); err != nil {
		resp.RespFail(c, "数据错误")
		return
	}

	//设置基站参数
	if err := obj.bparamOamApi.OamResetBts(dataModel); err != nil {
		resp.RespFail(c, "设置数据错误")
	}

	resp.RespOk(c)
}

// 按照大楼和楼层导出基站安装参数
func (obj *BparamHan) ExportBtsInstallParamHan(c *gin.Context) {
	dataModel := new(bparammodel.BtsBaseParam)

	//把前端数据绑定到模型上
	if err := obj.bindApi.Bind2Model(c, dataModel); err != nil {
		resp.RespFail(c, "数据错误")
		return
	}

	dataList, err := obj.bparamApi.ExportBtsInstallParam(dataModel)
	if err != nil {
		resp.RespFail(c, "查询数据错误")
		return
	}

	// 创建二进制文件
	file, err := os.Create("build_layer_bts_param.bin")
	if err != nil {
		resp.RespFail(c, "文件操作失败")
		panic(err)
	}
	defer file.Close()

	//生成bin文件
	buf := make([]byte, 4)
	for _, v := range dataList {
		//大楼编号
		binary.LittleEndian.PutUint32(buf, uint32(v.BuildID))
		if _, err := file.Write(buf); err != nil {
			resp.RespFail(c, "文件操作失败")
			panic(err)
		}

		//楼层编号
		binary.LittleEndian.PutUint32(buf, uint32(v.LayerID))
		if _, err := file.Write(buf); err != nil {
			resp.RespFail(c, "文件操作失败")
			panic(err)
		}

		//基站编号
		binary.LittleEndian.PutUint32(buf, uint32(v.BtsID))
		if _, err := file.Write(buf); err != nil {
			resp.RespFail(c, "文件操作失败")
			panic(err)
		}

		//载波编号
		binary.LittleEndian.PutUint32(buf, uint32(v.CarrierID))
		if _, err := file.Write(buf); err != nil {
			resp.RespFail(c, "文件操作失败")
			panic(err)
		}

		//时隙编号
		binary.LittleEndian.PutUint32(buf, uint32(v.Timeslot))
		if _, err := file.Write(buf); err != nil {
			resp.RespFail(c, "文件操作失败")
			panic(err)
		}

		//X坐标
		binary.LittleEndian.PutUint32(buf, uint32(v.CoordX))
		if _, err := file.Write(buf); err != nil {
			resp.RespFail(c, "文件操作失败")
			panic(err)
		}

		//Y坐标
		binary.LittleEndian.PutUint32(buf, uint32(v.CoordY))
		if _, err := file.Write(buf); err != nil {
			resp.RespFail(c, "文件操作失败")
			panic(err)
		}

		//Z坐标
		binary.LittleEndian.PutUint32(buf, uint32(v.CoordZ))
		if _, err := file.Write(buf); err != nil {
			resp.RespFail(c, "文件操作失败")
			panic(err)
		}

		//定位类型
		binary.LittleEndian.PutUint32(buf, uint32(v.LocationType))
		if _, err := file.Write(buf); err != nil {
			resp.RespFail(c, "文件操作失败")
			panic(err)
		}

		//两站数量
		binary.LittleEndian.PutUint32(buf, uint32(v.TwoBtsNum))
		if _, err := file.Write(buf); err != nil {
			resp.RespFail(c, "文件操作失败")
			panic(err)
		}

		//两站列表
		if v.LocationType == 1 || v.LocationType == 3 {
			input := strings.ReplaceAll(v.TwoBtsList, " ", "") // 去除空格
			parts := strings.Split(input, ",")                 // 分割字符串
			btsNum := len(parts)
			for _, part := range parts {
				if part == "" {
					continue // 跳过空字符串
				}
				num, _ := strconv.ParseInt(part, 10, 32)
				binary.LittleEndian.PutUint32(buf, uint32(num))
				if _, err := file.Write(buf); err != nil {
					resp.RespFail(c, "文件操作失败")
					panic(err)
				}
			}

			//补齐6个两站定位编号
			for i := btsNum; i < 6; i++ {
				binary.LittleEndian.PutUint32(buf, uint32(0))
				if _, err := file.Write(buf); err != nil {
					resp.RespFail(c, "文件操作失败")
					panic(err)
				}
			}
		} else {
			//初始化6个两站定位编号
			for i := 0; i < 6; i++ {
				binary.LittleEndian.PutUint32(buf, uint32(0))
				if _, err := file.Write(buf); err != nil {
					resp.RespFail(c, "文件操作失败")
					panic(err)
				}
			}
		}
	}

	//TODO 把bin文件发送到前端

	resp.RespOk(c)
}