package gns

import (
	"fmt"
	"golang.org/x/net/context"
	"io"
	"net"
	"net/http"
	"os"
	"os/exec"
	"runtime"
	"strings"
	"time"

	"gitee.com/liumou_site/gbm"
	"gitee.com/liumou_site/logger"
	"github.com/spf13/cast"
)

// HttpStatus 是一个使用tcp检测网页是否正常访问的功能
// host: 需要检查的主机
func (api *Api) HttpStatus(host string) bool {
	var urls string
	if api.port == 80 {
		urls = host
	} else {
		p := cast.ToString(api.port)
		urls = host + ":" + p
	}
	if api.https {
		urls = "https://" + urls
	} else {
		urls = "http://" + urls
	}
	mode := strings.ToUpper(api.agreement)
	logger.Debug("Generate url", urls)
	logger.Debug("Usage mode", mode)
	return api.HttpStatusUrl(urls) == nil
}

// PortTcpStatus 是一个检测TCP端口是否开启的功能
func PortTcpStatus(ip, port string, out time.Duration) bool {
	conn, err := net.DialTimeout("tcp", net.JoinHostPort(ip, port), time.Second*out)
	if err != nil {
		logger.Error("Connection error: %s", err)
		return false
	}
	defer func(conn net.Conn) {
		err := conn.Close()
		if err != nil {
			return
		}
	}(conn)
	logger.Info("Connection successful: [ %s:%s ]", ip, port)
	return true
}

// PortUdpStatus 是一个检测TCP端口是否开启的功能(目前并不准确)
func PortUdpStatus(ip, port string, out time.Duration) bool {
	conn, err := net.DialTimeout("udp", net.JoinHostPort(ip, port), time.Second*out)
	if err != nil {
		logger.Error("Connection error: %s", err)
		return false
	}
	defer func(conn net.Conn) {
		err := conn.Close()
		if err != nil {
			return
		}
	}(conn)
	logger.Info("Connection successful: [ %s:%s ]", ip, port)
	return true
}

// DownloadFile 是一个下载文件的功能,通过传入url和保存路径即可开始下载，结果返回布尔值
// save 保存路径,默认当前目录下以URL后缀文件名进行保存
func DownloadFile(url string, save string) bool {
	logger.Debug("Downloading URL: %s", url)
	logger.Debug("Save File Path: %s", save)
	res, err := http.Get(url)
	status := false
	if err != nil {
		return false
	} else {
		f, err := os.Create(save)
		if err != nil {
			return false
		} else {
			_, err := io.Copy(f, res.Body)
			if err != nil {
				return false
			}
			status = true
		}
	}
	logger.Info("End of download")
	return status
}

func printError(err error) {
	if err != nil {
		// 判断是否为上下文取消错误
		if err == context.DeadlineExceeded {
			logger.Error("请求已取消：", err)
		} else if err == context.Canceled {
			logger.Error("请求超时：", err)
		} else {
			logger.Error("其他类型的错误: ", err)
		}
	}
}

func (api *Api) HttpStatusUrl(url string) error {
	//logger.Debug(i)
	// 创建一个新的上下文，并设置超时时间为 5 秒钟
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	// 使用新的上下文创建一个 http 客户端
	client := &http.Client{}
	req, err := http.NewRequest(http.MethodGet, url, nil)
	if err != nil {
		return err
	}
	// 将新的上下文作为请求的上下文
	req = req.WithContext(ctx)

	// 发送请求
	_, err = client.Do(req)
	if err != nil {
		return err
	}
	defer func(Body io.ReadCloser) {
		err := Body.Close()
		if err != nil {
			return
		}
	}(req.Body) // 确保在返回前关闭响应体

	// 如果需要，可以在这里处理其他响应相关的逻辑

	return nil
}

// HttpStatusUrlBool 使用Get方式判断网页是否正常访问(使用code指定状态)
func (api *Api) HttpStatusUrlBool(url string) bool {
	t := time.Duration(api.timeout) * time.Second
	client := &http.Client{Timeout: t}
	api.Req, api.Err = http.NewRequest(api.request, url, nil)
	if api.Err != nil {
		logger.Error("新建连接请求失败")
		if api.debug {
			fmt.Println(api.Err)
		}
	}
	if api.Err != nil {
		return false
	}
	api.Resp, api.Err = client.Do(api.Req)
	if api.Err != nil {
		logger.Error("访问失败")
		if api.debug {
			fmt.Println(api.Err)
		}
		err := api.Resp.Body.Close()
		if err != nil {
			return false
		}
		return false
	}
	if api.Resp.StatusCode == api.code {
		return true
	}
	logger.Warn("Current request status: ", api.Resp.StatusCode)
	return false
}

// shellSystem 执行命令并支持实时获取输出,和Python的os.system函数一样,返回退出代码
func (p *PingCmdAPI) shellSystem() (code int, out string, err error) {
	var arg []string
	commandPath := "ping" // 定义命令路径
	if runtime.GOOS == "windows" {
		arg = append([]string{"-w", cast.ToString(p.timeout)}, p.host) // 在切片头部添加/C参数
	} else {
		arg = append([]string{"-c", cast.ToString(p.pingCount), "-W", cast.ToString(p.timeout)}, p.host) // 在切片头部添加-c参数
	}
	cmdline := commandPath + gbm.SliceToString(arg, " ")
	cmd := exec.Command(commandPath, arg...) // 创建命令实例
	// 命令的错误输出和标准输出都连接到同一个管道
	stdout, err := cmd.StdoutPipe()
	cmd.Stderr = cmd.Stdout

	if err != nil {
		logger.Error("管道创建失败")
		logger.Debug("Execute command: ", cmdline)
		return 1, "管道创建失败", err
	}
	runErr := cmd.Start()
	if runErr != nil {
		logger.Error("命令启动失败 :", runErr)
		logger.Debug("Execute command: ", cmdline)
		return 2, "命令启动失败", runErr
	}
	// 创建字符串保存输出信息
	var result string
	// 从管道中实时获取输出并打印到终端
	for {
		tmp := make([]byte, 1024)
		_, err := stdout.Read(tmp)
		// 如果开启了实时打印,则将信息逐行输出到终端
		if p.Realtime {
			fmt.Print(string(tmp))
		}
		result = result + cast.ToString(string(tmp))
		if err != nil {
			break
		}
	}

	// 等待命令退出，并等待任何复制到stdin或从stdout或stderr复制完成。
	waitErr := cmd.Wait()
	// ExitCode返回已退出进程的退出代码，如果进程尚未退出或被信号终止，则返回-1。
	exitCode := cmd.ProcessState.ExitCode()
	if p.ExitStatus {
		logger.Info("Exit Code: ", exitCode)
	}
	if waitErr == nil {
		if exitCode != 0 {
			logger.Error("Error :", waitErr)
			logger.Debug("Execute command: ", cmdline)
			return exitCode, result, runErr
		}
		if exitCode == 0 {
			return exitCode, result, nil
		}
	}
	return exitCode, result, waitErr
}

// IsLoopbackV4 判断是否属于回环
func IsLoopbackV4(ipAddr string) bool {
	return ipAddr == "127.0.0.1"
}

// IsDockerDevice 判断是否Docker网卡
func IsDockerDevice(eth string) bool {
	return eth == "docker0"
}