package sys

import (
	"errors"
	"os"
	"os/exec"
	"strconv"
	"webserver/extend/config"
	"webserver/extend/util"

	"fmt"
	"net"
	"strings"
	"time"
)

func execRootCommand(cmd string) ([]byte, error) {
	pwd := config.Server.SudoPassword
	cmdStr := fmt.Sprintf("echo %s | sudo -S %s", pwd, cmd)

	return exec.Command("/bin/bash", "-c", cmdStr).Output()
}

// 检查 root权限
func CheckRootPermissions() bool {
	showRootCMD := exec.Command("/bin/bash", "-c", "ls /root/")
	if _, err := showRootCMD.Output(); err != nil {
		return false
	}

	return true
}

// 获取本机网卡IP
func GetLocalIP(networkName string) (ipv4 string, mask string, err error) {
	interfaces, err := net.Interfaces()
	if err != nil {
		return "", "", err
	}

	for _, i := range interfaces {
		byName, err := net.InterfaceByName(i.Name)
		if err != nil {
			return "", "", err
		}
		addresses, err := byName.Addrs()
		for _, v := range addresses {
			if ipnet, ok := v.(*net.IPNet); ok && !ipnet.IP.IsLoopback() {
				if ipnet.IP.To4() != nil {
					if byName.Name == networkName {
						maskStr := ipnet.Mask.String()
						mask64, _ := strconv.ParseUint(maskStr, 16, 32)
						return ipnet.IP.String(), util.IpIntToString(int(mask64)), nil
					}
				}
			}
		}
	}
	return "", "", errors.New("ipv4 not found")
}

// 获取本机网关ip
func GetDefaultRoute(networkName string) (route string, err error) {
	cmdStr := fmt.Sprintf("ip route show | grep -P \"^default.*%s onlink\" | awk '{printf $3}'", networkName)
	cmd := exec.Command("/bin/sh", "-c", cmdStr)
	b, err := cmd.Output()
	if err != nil {
		return "", err
	}

	return string(b), nil
}

func GetDnsServer() (dns string, err error) {
	cmd := exec.Command("/bin/sh", "-c", "cat /etc/resolv.conf | grep nameserver | head -1 |awk '{printf $2}'")
	b, err := cmd.Output()
	if err != nil {
		return "", err
	}

	return string(b), nil
}

// 配置服务器网络
func SetNetworkConfig(ipv4, netmask, gateway, dns string) (bool, string) {
	networkConfigScript := "/opt/vasystem/script/netconfig"
	ifname := config.Server.NetworkAdapter
	localIPv4, localNetMask, _ := GetLocalIP(ifname)
	localGW, _ := GetDefaultRoute(ifname)
	localDNS, _ := GetDnsServer()

	if localIPv4 == ipv4 && localNetMask == netmask && localGW == gateway && localDNS == dns {
		return true, ""
	}

	// 检查文件是否存在
	if _, err := os.Stat(networkConfigScript); err != nil {
		return false, "network Config Script not exist"
	}
	// # netconfig enp59s0f0 192.168.1.2 255.255.255.0 192.168.1.1 192.168.100.1
	cmdStr := fmt.Sprintf("%s %s %s %s %s %s", networkConfigScript, ifname, ipv4, netmask, gateway, dns)
	stdout, err := execRootCommand(cmdStr)

	return err == nil, string(stdout)
}

// 配置时区
func TimeZone() (string, int64) {
	cmd := exec.Command("/bin/sh", "-c", "echo -n $TZ")
	tz, _ := cmd.Output()
	if tzstr := string(tz); tzstr != "" {
		return tzstr, time.Now().Unix()
	}

	zone, _ := time.Now().Zone()
	return zone, time.Now().Unix()
}

func NTPConfig() (bool, string, string) {
	status, server, interval := false, "", ""

	cron, _ := execRootCommand("crontab -l | grep ntpdate | tr -d '\n'")
	if task := string(cron); task != "" {
		status = true
		slice := strings.Split(task, " ")
		interval, server = slice[0][2:], slice[len(slice)-1]
	}

	return status, server, interval
}

// 设置时区
func SetTimeZone(tz string) bool {
	if _, err := time.LoadLocation(tz); err != nil {
		return false
	}

	// set env
	envCMD := exec.Command("/bin/sh", "-c", "TZ=%s", tz)
	envCMD.Run()
	// change permanent to the file '.profile'

	cleanTZ := exec.Command("/bin/sh", "-c", "sed -i '/^TZ=.*$/d' ~/.profile")
	cleanTZ.Run()

	TZ := "TZ='" + tz + "'; export TZ"
	appendTZCMD := fmt.Sprintf("echo \"%s\" >> ~/.profile;", TZ)
	appendTZ := exec.Command("/bin/sh", "-c", appendTZCMD)
	appendTZ.Run()

	return true
}

// 配置系统时间
func SetLocalTime(newTime string) bool {
	const TimeLayout = "2006-01-02 15:04:05"
	_, err := time.Parse(TimeLayout, newTime)
	if err != nil {
		return false
	}

	dateCMD := fmt.Sprintf("date -s \"%s\"", newTime)
	execRootCommand(dateCMD)
	stopNTPCron()

	return true
}

const NTPCRONTABFILE = "/tmp/.webServer.crontab"

func EnableNTPCron(server string, interval int) bool {
	stopNTPCron()

	if ip := net.ParseIP(server); ip == nil {
		return false
	}

	update := fmt.Sprintf("echo \"*/%d * * * * /usr/sbin/ntpdate %s\" >> %s", interval, server, NTPCRONTABFILE)
	execRootCommand(update)

	addNTPTask := fmt.Sprintf("crontab %s", NTPCRONTABFILE)
	execRootCommand(addNTPTask)

	return true
}

func stopNTPCron() {
	update := fmt.Sprintf("crontab -l | grep -v /usr/sbin/ntpdate > %s", NTPCRONTABFILE)
	execRootCommand(update)

	cleanNTPTask := fmt.Sprintf("crontab %s", NTPCRONTABFILE)
	execRootCommand(cleanNTPTask)
}

func RunNTPDate(server string) bool {
	if ip := net.ParseIP(server); ip == nil {
		return false
	}

	ntpdate := fmt.Sprintf("/usr/sbin/ntpdate %s", server)
	_, err := execRootCommand(ntpdate)

	return err == nil
}

func Reboot() (bool, string) {
	stdout, err := execRootCommand("reboot")

	return err == nil, string(stdout)
}

// * * * * * /bin/echo "$(date) Perform basic-reboot-task" >> /tmp/webserver.crontab.log;/sbin/reboot & >> /tmp/webserver.crontab.log
func ReadRebootTaskInCrontab() (bool, string) {
	stdout, err := execRootCommand("crontab -l | grep basic-reboot-task | sed -z -r 's/([^0-9* ]+)(.+)//g'")
	return err == nil, string(stdout)
}

func CleanRebootTask() {
	update := fmt.Sprintf("crontab -l | grep -v basic-reboot-task > %s", NTPCRONTABFILE)
	execRootCommand(update)

	crontab := fmt.Sprintf("crontab %s", NTPCRONTABFILE)
	execRootCommand(crontab)
}

func UpdateRebootTask(task string) bool {
	CleanRebootTask()

	tasks := fmt.Sprintf("%s /bin/echo \"$(date) Perform basic-reboot-task\" >> /tmp/webserver.crontab.log;/sbin/reboot & >> /tmp/webserver.crontab.log", task)
	update := fmt.Sprintf("echo '%s' >> %s", tasks, NTPCRONTABFILE)
	execRootCommand(update)
	addNTPTask := fmt.Sprintf("crontab %s", NTPCRONTABFILE)
	_, err := execRootCommand(addNTPTask)

	return err == nil
}

const ngConfig = "/opt/vasystem/config/system-2.0.conf"
func GetNginxListenPort() string {
	_, err := os.Stat(ngConfig)
	if err != nil {
		return "7003"
	}

	cmdStr := fmt.Sprintf("cat %s | grep listen | awk  '{printf $2}' | sed 's/;//g'", ngConfig)
	cmd := exec.Command("/bin/sh", "-c", cmdStr)
	port, err := cmd.Output()
	if err != nil {
		return ""
	}

	return string(port)
}

func SetNginxListenPort(port string) bool {
	_, err := os.Stat(ngConfig)
	if err != nil {
		return false
	}

	// 修改配置文件端口
	cmdStr := fmt.Sprintf("sed -i 's/listen.*/listen %s;/' %s", port, ngConfig)
	cmd := exec.Command("/bin/sh", "-c", cmdStr)
	_, err = cmd.Output()
	if err != nil {
		return false
	}

	// 重启nginx
	_, err = execRootCommand("service nginx reload")

	return err == nil
}