package executor

import "strings"

type BaseFunc interface {
	Exec(baseFuncName string, funcArgs ...string) string
}

type AgentOsOperator struct {
	InstallCommandPrefix []string `json:"install_command_prefix",comment:"apt-get install or yum install"`

	RemoveCommandPrefix []string `json:"remove_command_prefix",comment:"apt-get remove or yum remove"`

	CanAccessInternet bool `json:"can_access_internet",comment:"是否可以访问公网"`

	IsOsTypeUbuntu bool `json:"is_os_type_ubuntu",comment:"主机操作系统是否为ubuntu系列"`

	IsAgentInnerWall bool `json:"is_agent_inner_wall", comment:"主机是否身处国内"`

	AgentArch string `json:"agent_arch",comment:"主机的CPU架构，可选为amd64 arm64"`

	AgentOSReleaseCode string `json:"agent_os_release_code",comment:"主机操作系统的发行版代号， focal之类的"`
}

// Exec 执行基础功能函数
func (op *AgentOsOperator) Exec(baseFuncName string, funcArgs ...string) string {

	var multiLineCommand [][]string

	switch baseFuncName {

	case "shutdownFirewall":
		multiLineCommand = op.shutdownFirewall()
		break
	case "modifyHostname":
		multiLineCommand = op.modifyHostname(funcArgs)
		break
	case "enableSwap":
		multiLineCommand = op.enableSwap()
		break
	case "disableSwap":
		multiLineCommand = op.disableSwap()
		break
	case "installDocker":
		multiLineCommand = op.installDocker(funcArgs)
		break
	case "removeDocker":
		multiLineCommand = op.removeDocker()
		break
	case "installDockerCompose":
		multiLineCommand = op.installDockerCompose()
		break
	case "modifyDockerConfig":
		multiLineCommand = op.modifyDockerConfig()
		break
	case "installHelm":
		multiLineCommand = op.installHelm()
		break
	case "installHarbor":
		multiLineCommand = op.installHarbor(funcArgs)
		break
	case "chronyToPublicNTP":
		multiLineCommand = op.chronyToPublicNTP()
		break
	case "chronyToMaster":
		multiLineCommand = op.chronyToMaster(funcArgs)
		break
	case "installZSH":
		multiLineCommand = op.installZSH()
		break
	case "modifySshPort":
		multiLineCommand = op.modifySshPort(funcArgs)
		break
	case "openBBR":
		multiLineCommand = op.openBBR()
		break
	default:
		multiLineCommand = op.ok(funcArgs)

	}

	log.DebugF("multiLineCommand are => %v", multiLineCommand)

	// exec the command here
	for _, singleLineCommand := range multiLineCommand {
		ReadTimeCommandExecutor(singleLineCommand)
	}

	// 归一化处理
	return strings.Join([]string{}, "")
}

func (op *AgentOsOperator) shutdownFirewall() [][]string {

	shutdownFunc := [][]string{
		{"systemctl", "stop", "firewalld"},
		{"systemctl", "disable", "firewalld"},
	}

	if !op.IsOsTypeUbuntu {
		shutdownFunc = append(shutdownFunc,
			[]string{
				"sed",
				"-i",
				"s/SELINUX=enforcing/SELINUX=disabled/g",
				"/etc/selinux/config",
			},
		)
	}

	return shutdownFunc
}

func (op *AgentOsOperator) modifyHostname(args []string) [][]string {

	return [][]string{}
}

func (op *AgentOsOperator) enableSwap() [][]string {

	enableSwapFunc := [][]string{
		{
			"cp",
			"-f",
			"/etc/fstab_back",
			"/etc/fstab",
		},
		{
			"cat",
			"/etc/fstab",
		},
	}

	return enableSwapFunc
}

func (op *AgentOsOperator) disableSwap() [][]string {

	disableSwapFunc := [][]string{
		{
			"swapoff",
			"-a",
		},
		{
			"cp",
			"-f",
			"/etc/fstab",
			"/etc/fstab_back",
		},
		{
			"sed",
			"-i",
			"/swap/d",
			"/etc/fstab",
		},
	}

	return disableSwapFunc
}

func (op *AgentOsOperator) removeDocker() [][]string {

	removeDockerLine := append(op.RemoveCommandPrefix, []string{
		"docker",
		"docker-client",
		"docker-client-latest",
		"docker-ce-cli",
		"docker-common",
		"docker-latest",
		"docker-latest-logrotate",
		"docker-logrotate",
		"docker-selinux",
		"docker-engine-selinux",
		"docker-engine",
		"kubelet",
		"kubeadm",
		"kubectl",
	}...)

	removeDockerFunc := [][]string{
		removeDockerLine,
	}

	return removeDockerFunc
}

func (op *AgentOsOperator) installDocker(args []string) [][]string {

	// remove docker all staff
	installDockerFunc := op.removeDocker()

	if op.IsOsTypeUbuntu {
		//
		installFirstLine := append(op.InstallCommandPrefix, []string{
			"apt-transport-https",
			"ca-certificates",
			"curl",
			"gnupg-agent",
			"software-properties-common",
		}...)

		if op.IsAgentInnerWall {
			// inner gfw
			installDockerFunc = append(installDockerFunc, [][]string{
				installFirstLine,
				{
					"curl",
					"-o",
					"/etc/docker/docker-utsc.gpg",
					"https://mirrors.ustc.edu.cn/docker-ce/linux/ubuntu/gpg",
				},
				{
					"apt-key",
					"add",
					"/etc/docker/docker-utsc.gpg",
				},
				{
					"add-apt-repository",
					"deb [arch=" + op.AgentArch + "] https://mirrors.ustc.edu.cn/docker-ce/linux/ubuntu " + op.AgentOSReleaseCode + " stable",
				},
			}...)
		} else {
			// outside world
			installDockerFunc = append(installDockerFunc, [][]string{
				installFirstLine,
				{
					"curl",
					"-o",
					"/etc/docker/docker.gpg",
					"https://download.docker.com/linux/ubuntu/gpg ",
				},
				{
					"apt-key",
					"add",
					"/etc/docker/docker.gpg",
				},
				{
					"add-apt-repository",
					"deb [arch=" + op.AgentArch + "] https://download.docker.com/linux/ubuntu " + op.AgentOSReleaseCode + " stable",
				},
			}...)
		}

		// look for specific docker-version to install
		installDockerFunc = append(installDockerFunc, []string{"apt-get", "update"})

		var specificDockerVersion string
		// hard code here 5:20.10.10~3-0~ubuntu-focal
		if strings.HasPrefix(args[0], "19") {
			specificDockerVersion = "5:19.03.15~3-0~ubuntu-focal"
		} else {
			specificDockerVersion = "5:20.10.10~3-0~ubuntu-focal"
		}

		installDockerFunc = append(installDockerFunc,
			append(
				op.InstallCommandPrefix,
				"docker-ce="+specificDockerVersion,
				"docker-ce-cli="+specificDockerVersion,
				"containerd.io",
				"docker-compose-plugin",
			),
		)

	} else {
		installFirstLine := append(op.InstallCommandPrefix,
			[]string{
				"yum-utils",
				"device-mapper-persistent-data",
				"lvm2",
			}...,
		)

		if op.IsAgentInnerWall {
			// inner gfw
			installDockerFunc = append(installDockerFunc, [][]string{
				installFirstLine,
				{
					"yum-config-manager",
					"--add-repo",
					"https://mirrors.ustc.edu.cn/docker-ce/linux/centos/docker-ce.repo",
				},
				{
					"sed ",
					"-i ",
					"'s/download.docker.com/mirrors.ustc.edu.cn\\/docker-ce/g' ",
					"/etc/yum.repos.d/docker-ce.repo",
				},
				{},
			}...)
		} else {
			// outside world
		}

	}

	return installDockerFunc
}

func (op *AgentOsOperator) installDockerCompose() [][]string {

	return [][]string{}
}

func (op *AgentOsOperator) installHelm() [][]string {

	return [][]string{}
}

func (op *AgentOsOperator) modifyDockerConfig() [][]string {

	return [][]string{}
}

func (op *AgentOsOperator) installHarbor(args []string) [][]string {

	return [][]string{}
}

func (op *AgentOsOperator) chronyToPublicNTP() [][]string {

	return [][]string{}
}

func (op *AgentOsOperator) chronyToMaster(args []string) [][]string {

	return [][]string{}
}

func (op *AgentOsOperator) installZSH() [][]string {

	return [][]string{}
}

func (op *AgentOsOperator) modifySshPort(args []string) [][]string {

	return [][]string{}
}

func (op *AgentOsOperator) openBBR() [][]string {

	return [][]string{}
}

func (op *AgentOsOperator) ok(args []string) [][]string {
	return [][]string{
		{"base function is ok , args are => " + strings.Join(args, " ")},
	}
}