package cmd

import (
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"os"
	"os/exec"
	"path/filepath"
	"strconv"
	"strings"

	"git.apinb.com/bsm-sdk/engine/env"
	"git.apinb.com/bsm-sdk/engine/utils"
)

func getRegistryReleases() Releases {
	body, err := utils.HttpGet(registryUrl)
	checkError(err)

	var ms Releases
	err = json.Unmarshal(body, &ms)
	checkError(err)

	return ms
}

func getService(srv string) *Service {
	reles := getRegistryReleases()
	for _, v := range reles.Data {
		if v.ServiceKey == srv {
			return &v
		}
	}

	return nil
}

func getCurrentVersion(srv string) string {
	var data map[string]string

	execbin := filepath.Join(env.MeshEnv.Prefix, srv)
	cmd := exec.Command(execbin, "--json") // 替换为适合操作系统的命令
	output, err := cmd.Output()
	if err != nil {
		return " - "
	}

	err = json.Unmarshal(output, &data)
	if err != nil {
		return " - "
	}

	if val, ok := data["version"]; ok {
		return val
	}

	return " - "
}

func getProcessInfo(processName string) (string, string) {
	var info string = " - "
	cmd := exec.Command("ps", "-eo", "pid,%cpu,%mem,cmd") // 使用ps命令查询进程信息
	output, err := cmd.Output()                           // 获取命令输出结果
	if err != nil {
		return info, info
	}

	// 将输出按换行符分隔成多行字符串数组
	lines := strings.Split(string(output), "\n")[1:]

	for _, line := range lines {
		if strings.Contains(line, processName) {
			fields := strings.Fields(line) // 将每行按空格分隔为字段数组
			if len(fields) >= 3 {
				pid := fields[0]         // PID（进程标识）
				cpuUsage := fields[1]    // CPU使用情况
				memoryUsage := fields[2] // 内存使用情况
				info = fmt.Sprintf("CPU:%s%% / MEM:%s%%", cpuUsage, memoryUsage)
				return pid, info
			}
		}
	}

	return info, info
}

func checkProcessRunning(processName string) bool {
	cmd := exec.Command("ps", "-ef") // 替换为适合操作系统的命令
	output, err := cmd.Output()
	if err != nil {
		return false
	}

	// 将输出按行分割成切片
	lines := strings.Split(string(output), "\n")

	for _, line := range lines {
		if strings.Contains(line, processName) {
			return true
		}
	}

	return false
}

func DownloadFile(url, saveTo string, fb func(length, downLen int64)) {
	var (
		fsize   int64
		buf     = make([]byte, 32*1024)
		written int64
	)
	//创建一个http client
	client := new(http.Client)
	//get方法获取资源
	resp, err := client.Get(url)
	if err != nil {
		fmt.Printf("download %s error:%s\n", url, err)
		os.Exit(0)
	}
	//读取服务器返回的文件大小
	fsize, err = strconv.ParseInt(resp.Header.Get("Content-Length"), 10, 32)
	if err != nil {
		fmt.Println(err)
	}
	//创建文件
	file, err := os.Create(saveTo)
	file.Chmod(0777)
	if err != nil {
		fmt.Printf("Create %s error:%s\n", saveTo, err)
		os.Exit(0)
	}
	defer file.Close()
	if resp.Body == nil {
		fmt.Printf("resp %s error:%s\n", url, err)
		os.Exit(0)
	}
	defer resp.Body.Close()
	//下面是 io.copyBuffer() 的简化版本
	for {
		//读取bytes
		nr, er := resp.Body.Read(buf)
		if nr > 0 {
			//写入bytes
			nw, ew := file.Write(buf[0:nr])
			//数据长度大于0
			if nw > 0 {
				written += int64(nw)
			}
			//写入出错
			if ew != nil {
				err = ew
				break
			}
			//读取是数据长度不等于写入的数据长度
			if nr != nw {
				err = io.ErrShortWrite
				break
			}
		}
		if er != nil {
			if er != io.EOF {
				err = er
			}
			break
		}
		//没有错误了快使用 callback

		fb(fsize, written)
	}

	if err != nil {
		fmt.Printf("callback error:%s\n", err)
		os.Exit(0)
	}
}