package service

import (
	"fmt"
	"sort"
	"strconv"

	"be.ems/src/modules/network_element/model"
	"be.ems/src/modules/network_element/repository"
	"github.com/tsmask/go-oam/framework/utils/parse"
)

// 实例化数据层 NEState 结构体
var NewNEState = &NEState{
	neStateRepository: repository.NewNEState,
}

// NEState 网元状态记录表 服务层处理
type NEState struct {
	neStateRepository *repository.NEState // 网元状态记录信息
}

// FindByPage 根据条件分页查询
func (r NEState) FindByPage(query model.NEStateQuery) ([]model.NEState, int64) {
	return r.neStateRepository.SelectByPage(query)
}

// Insert 插入数据
func (r NEState) Insert(item model.NEState) int64 {
	return r.neStateRepository.Insert(item)
}

// DeleteByTime 删除数据
func (r NEState) DeleteByTime(neType, neId string, ltTime int64) int64 {
	return r.neStateRepository.DeleteByTime(neType, neId, ltTime)
}

// Last 查询最新状态
func (r NEState) Last(neType, neId string) model.NEState {
	return r.neStateRepository.SelectByLast(neType, neId)
}

// ParseState 解析状态数据
func (r NEState) ParseState(neInfo model.NeInfo, state model.NEState) map[string]any {
	if state.ID == 0 {
		return map[string]any{}
	}
	return map[string]any{
		"neId":         neInfo.NeId,
		"neName":       neInfo.NeName,
		"neType":       neInfo.NeType,
		"neIP":         neInfo.IP,
		"standby":      state.Standby,
		"version":      state.NeVersion,
		"sn":           state.SerialNum,
		"expire":       state.ExpiryDate,
		"refreshTime":  state.RefreshTime,
		"ueNumber":     state.UENumber,
		"nbNumber":     state.NbNumber,
		"hostname":     state.HostName,
		"os":           state.OS,
		"sysCpuUsage":  state.SysCpuUsage,
		"sysMemUsage":  state.SysMemUsage,
		"sysDiskUsage": state.SysDiskUsage,
		"nfCpuUsage":   state.NfCpuUsage,
		"nfMemUsed":    state.NfMemUsed,
	}
}

// SaveState 网元直连返回的状态数据保存
func (r NEState) SaveState(state map[string]any) model.NEState {
	// 网元CPU使用率
	var nfCpuUsage float64 = 0
	// CPU使用率
	var sysCpuUsage float64 = 0
	if state["cpu"] != nil {
		cpu := state["cpu"].(map[string]any)
		v := parse.Number(cpu["sysCpuUsage"])
		sysCpuUsage = float64(v) / 100
		nfv := parse.Number(cpu["nfCpuUsage"])
		nfCpuUsage = float64(nfv) / 100
	}

	// 网元内存使用KB
	var nfMemUsed int64 = 0
	// 内存使用率
	var sysMemUsage float64 = 0
	if state["mem"] != nil {
		mem := state["mem"].(map[string]any)
		v := parse.Number(mem["sysMemUsage"])
		sysMemUsage = float64(v) / 100
		nfMemUsed = parse.Number(mem["nfUsedMem"])
	}

	// 磁盘使用率
	var sysDiskUsage float64 = 0
	if state["disk"] != nil {
		mem := state["disk"].(map[string]any)
		disks := mem["partitionInfo"].([]any)
		sort.Slice(disks, func(i, j int) bool {
			iUsed := parse.Number(disks[i].(map[string]any)["used"])
			jUsed := parse.Number(disks[j].(map[string]any)["used"])
			return iUsed > jUsed
		})
		disk := disks[0].(map[string]any)
		total := parse.Number(disk["total"])
		used := parse.Number(disk["used"])
		sysDiskUsage = (float64(used) / float64(total)) * 100
		sysDiskUsage, _ = strconv.ParseFloat(fmt.Sprintf("%.2f", sysDiskUsage), 64)
	}

	// 插入网元状态记录
	neState := model.NEState{
		NeType:       fmt.Sprint(state["neType"]),
		NeId:         fmt.Sprint(state["neId"]),
		NeVersion:    fmt.Sprint(state["version"]),
		Standby:      parse.Number(state["standby"]),
		UENumber:     parse.Number(state["ueNumber"]),
		NbNumber:     parse.Number(state["nbNumber"]),
		SerialNum:    fmt.Sprint(state["sn"]),
		ExpiryDate:   fmt.Sprint(state["expire"]),
		HostName:     fmt.Sprint(state["hostname"]),
		OS:           fmt.Sprint(state["os"]),
		SysCpuUsage:  sysCpuUsage,
		SysMemUsage:  sysMemUsage,
		SysDiskUsage: sysDiskUsage,
		NfCpuUsage:   nfCpuUsage,
		NfMemUsed:    nfMemUsed,
		RefreshTime:  parse.Number(state["refreshTime"]),
	}

	insertId := r.neStateRepository.Insert(neState)
	if insertId > 0 {
		neState.ID = insertId
	}
	return neState
}