package service

import (
	"basic.com/pubsub/protomsg.git"
	"basic.com/valib/bhomedbapi.git"
	"regexp"
	"strings"
	"vamicro/sysinfo-service/models/gogpu"

	"github.com/shirou/gopsutil/process"
)

const ProcName = "sysinfo-service"

var BasicProc = map[string]string{
	"analysis":      "算法处理单元",
	"apiserver":     "basic接口服务",
	"decoder":       "视频解码服务",
	"elasticsearch": "分布式数据搜索引擎",
	"faceDetect":    "人脸识别服务",
	"file-service":  "文件服务",
	"pollcontrol":   "轮询管理",
	"ruleServer":    "规则处理单元",
	"dataProcess":   "规则处理单元",
	"schedule":      "调度进程",
	"sdkCompare":    "人脸比对服务",
	"sshd":          "ssh服务端",
	"videopublish":  "实时视频推流服务",
	"videosvr.out":  "国标上级服务",
	"weed":          "分布式文件系统",
}

type UsedMap map[int]int64

func (u UsedMap) Get(key int) int64 {
	if _, ok := u[key]; !ok {
		return 0
	} else {
		return u[key] / 1024 / 1024
	}
}

type Proc struct {
	Name string  `json:"name"`
	Desc string  `json:"desc"`
	Pid  int32   `json:"pid"`
	Cpu  float64 `json:"cpu"`
	Mem  float32 `json:"mem"`
	disk int64   `json:"disk"`
	Gpu  int64   `json:"gpu"`
	Net  int32   `json:"net"`
}

func CollectAlgoProcess() []Proc {
	var procs []Proc
	var gpuMemTotal int64
	var re = regexp.MustCompile(`-sdk=(\S+)`)
	gpuPer := UsedMap{}

	gpuInfo, err := gogpu.Info()
	if err == nil {
		for _, gpu := range gpuInfo.Info {
			gpuMemTotal = gpuMemTotal + gpu.GpuMemoryTotal
		}

		for _, proc := range gpuInfo.Processes {
			if _, ok := gpuPer[proc.Pid]; ok {
				gpuPer[proc.Pid] = gpuPer[proc.Pid] + int64(proc.UsedMem)
			} else {
				gpuPer[proc.Pid] = int64(proc.UsedMem)
			}
		}
	}

	ps, _ := process.Processes()

	// 统计算法信息
	for _, p := range ps {
		if name, err := p.Name(); err == nil {
			if name == "analysis" {
				cmdLine, _ := p.Cmdline()
				if len(cmdLine) > 0 {
					match := re.FindAllStringSubmatch(cmdLine, -1)
					if len(match) > 0 && len(match[0]) > 1 {
						proc := Proc{
							Name: match[0][1],
							Pid:  p.Pid,
							Desc: match[0][1],
						}

						proc.Cpu, _ = p.CPUPercent()
						proc.Mem, _ = p.MemoryPercent()
						proc.Gpu = gpuPer.Get(int(p.Pid))

						procs = append(procs, proc)
					}
				}
			}
		}

	}

	return procs
}

func CollectAppProcess() []Proc {
	var procs []Proc
	var gpuMemTotal int64

	dbApi := bhomedbapi.AppApi{}
	installedAppMap := make(map[string]protomsg.App)

	// 存储appMap的文件名
	apps := dbApi.FindAppMap()
	for k, v := range dbApi.FindAppMap() {
		if v.ProcName != "" {
			installedAppMap[v.ProcName] = apps[k]
		}
	}

	// 统计gpu
	gpuPer := UsedMap{}

	gpuInfo, err := gogpu.Info()
	if err == nil {
		for _, gpu := range gpuInfo.Info {
			gpuMemTotal = gpuMemTotal + gpu.GpuMemoryTotal
		}

		for _, proc := range gpuInfo.Processes {
			if _, ok := gpuPer[proc.Pid]; ok {
				gpuPer[proc.Pid] = gpuPer[proc.Pid] + int64(proc.UsedMem)
			} else {
				gpuPer[proc.Pid] = int64(proc.UsedMem)
			}
		}
	}

	// 统计正在运行的应用信息
	ps, _ := process.Processes()
	for _, p := range ps {
		if name, err := p.Name(); err == nil {
			if app, isExist := installedAppMap[name]; isExist {
				proc := Proc{
					Name: app.Name,
					Pid:  p.Pid,
					Desc: app.Title,
				}

				proc.Cpu, _ = p.CPUPercent()
				proc.Mem, _ = p.MemoryPercent()
				proc.Gpu = gpuPer.Get(int(p.Pid))

				procs = append(procs, proc)

				delete(installedAppMap, name)
			}
		}
	}

	// 追加未启动的应用
	for _, v := range installedAppMap {
		proc := Proc{
			Name: v.Name,
			Pid:  0,
			Desc: v.Title,
		}

		proc.Cpu = 0
		proc.Mem = 0
		proc.Gpu = 0

		procs = append(procs, proc)
	}

	return procs
}

func CollectVasystemService() (rsp []Proc) {
	ps, _ := process.Processes()

	for k, v := range BasicProc {
		proc := Proc{
			Name: k,
			Desc: v,
		}

		for _, p := range ps {
			if name, err := p.Name(); err == nil {
				if name == k {
					proc.Pid = p.Pid

					break
				}
			}

			if k == "elasticsearch" {
				cmdLine, _ := p.Cmdline()
				if strings.Contains(cmdLine, k) {
					proc.Pid = p.Pid

					break
				}
			}
		}

		rsp = append(rsp, proc)
	}

	return
}