package main

import (
	"flag"
	"fmt"
	"log"
	"os"
	"path/filepath"
	"time"

	"basic.com/aps/aps_deploy.git/src/cluster"
	"basic.com/aps/aps_deploy.git/src/rancher"
	"basic.com/aps/aps_deploy.git/src/util"
	"k8s.io/client-go/kubernetes"
	"k8s.io/client-go/tools/clientcmd"

	"basic.com/aps/aps_deploy.git/src/k8s"

	"github.com/spf13/viper"
)

var (
	replicas      int32 = 1
	port          int32 = 9081
	usedNodePorts       = make(map[int32]bool)
	namespaces          = []string{"testFactory1", "testFactory2", "testFactory3"}
)

func rancher_install_test(node rancher.Node) {
	/*	nodes := []Node{
		{
			Roles:       []string{"etcd", "controlplane", "worker"},
			IP:          "192.168.20.189",
			SSHUsername: "basic",
			SSHPassword: "123",
			SSHPort:     22,
		},
		{
			Roles:       []string{"worker"},
			IP:          "192.168.20.10",
			SSHUsername: "basic",
			SSHPassword: "123",
			SSHPort:     22,
		},
		{
			Roles:       []string{"worker"},
			IP:          "192.168.20.115",
			SSHUsername: "basic",
			SSHPassword: "alien123",
			SSHPort:     22,
		},
		// Add more nodes here if needed
	}*/

	//install rancher on master node
	err := rancher.InstallDockerAndRancher(node.IP, node.SSHUsername, node.SSHPassword, node.SSHPort)
	if err != nil {
		log.Fatalf("Failed to install Rancher: %v", err)
	}

	os.Exit(0)
}

func cluster_test(clusterName string, rancherClusterConfig rancher.RancherClusterConfig) {

	// Create the cluster
	// Rancher configuration
	/*rancherConfig := RancherConfig{
		RancherURL:  "https://192.168.20.119:8443",
		BearerToken: "token-nnrsc:w68zdt8s47fnpjd5xqdl5hhzpz4j2d56kt5nx49nsswcbpdzc28kh5",
	}*/

	fmt.Println(rancherClusterConfig)
	fmt.Println(rancherClusterConfig.RancherURL)
	fmt.Println(rancherClusterConfig.BearerToken)
	//	Deploy clusterId
	clusterID, err := cluster.GetClusterID(rancherClusterConfig.RancherURL, rancherClusterConfig.BearerToken, clusterName)
	if err != nil {
		fmt.Printf("Cluster not found: %s %v\n", clusterName, err)
		_, err = cluster.CreateCluster(rancherClusterConfig, clusterName)
		if err != nil {
			log.Fatalf("Failed to create cluster: %v", err)
		}
		fmt.Printf("Cluster created: %s\n", clusterName)
		clusterID, err = cluster.GetClusterID(rancherClusterConfig.RancherURL, rancherClusterConfig.BearerToken, clusterName)
		if err != nil {
			log.Fatal(err)
		}
	}
	fmt.Println(clusterID)

	//	Deploy nodeCommand
	nodeCommand, err := cluster.GetNodeCommand(rancherClusterConfig.RancherURL, rancherClusterConfig.BearerToken, clusterID)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(nodeCommand)

	for _, node := range rancherClusterConfig.Nodes {
		//Deploy Docker on each node
		err = util.InstallDocker(node.IP, node.SSHUsername, node.SSHPassword, node.SSHPort)
		if err != nil {
			log.Fatal(err)
		}

		// Deploy Kubectl on each node
		err = util.InstallKubectl(node.IP, node.SSHUsername, node.SSHPassword, node.SSHPort)
		if err != nil {
			log.Fatal(err)
		}

		// Deploy Kubernetes roles on each node
		err = cluster.Deployk8sRolesOnNode(node.IP, node.SSHUsername, node.SSHPassword, nodeCommand, node.SSHPort, node.Roles)
		if err != nil {
			log.Fatal(err)
		}
	}
	os.Exit(0)
}

func main() {
	createCmd := flag.NewFlagSet("create", flag.ExitOnError)
	deleteCmd := flag.NewFlagSet("delete", flag.ExitOnError)
	testCmd := flag.NewFlagSet("test", flag.ExitOnError)
	clusterCmd := flag.NewFlagSet("cluster", flag.ExitOnError)
	rancherInstallCmd := flag.NewFlagSet("rancher_install", flag.ExitOnError)

	createNamespace := createCmd.String("ns", "", "Namespace name")
	createDeployment := createCmd.String("deployment", "", "Deployment name")
	fmt.Println(createDeployment)
	createService := createCmd.String("service", "", "Service name")
	fmt.Println(createService)
	deleteNamespace := deleteCmd.String("ns", "", "Namespace name")
	deleteDeployment := deleteCmd.String("deployment", "", "Deployment name")
	deleteService := deleteCmd.String("service", "", "Service name")

	if len(os.Args) < 2 {
		fmt.Println("create/delete/test/cluster/rancher_install command is required")
		os.Exit(1)
	}

	switch os.Args[1] {
	case "create":
		createCmd.Parse(os.Args[2:])
	case "delete":
		deleteCmd.Parse(os.Args[2:])
	case "test":
		testCmd.Parse(os.Args[2:])
	case "cluster":
		clusterCmd.Parse(os.Args[2:])
	case "rancher_install":
		rancherInstallCmd.Parse(os.Args[2:])
	default:
		flag.PrintDefaults()
		os.Exit(1)
	}

	if rancherInstallCmd.Parsed() {
		//// 初始化配置解析库
		//viper.SetConfigName("config")
		//viper.SetConfigType("yaml")
		//viper.AddConfigPath("./config")
		//
		//// 读取配置文件
		//err := viper.ReadInConfig()
		//if err != nil {
		//	log.Fatalf("Failed to read config file: %v", err)
		//}

		// 解析配置文件中的字段
		var rancherClusterConfig rancher.RancherClusterConfig
		//err = viper.Unmarshal(&rancherClusterConfig)
		//if err != nil {
		//	log.Fatalf("Failed to unmarshal config: %v", err)
		//}

		rancherClusterConfig.Nodes = make([]rancher.Node, 3)
		rancherClusterConfig.Nodes[0] = rancher.Node{
			Roles:       []string{"worker"},
			IP:          "192.168.49.1",
			SSHUsername: "me",
			SSHPassword: "123456",
			SSHPort:     22,
		}

		rancher_install_test(rancherClusterConfig.Nodes[0])
		os.Exit(1)
	}

	// 执行 create 命令
	if createCmd.Parsed() {

		// 配置 Kubernetes 集群的 kubeconfig 路径
		kubeconfig := flag.String("kubeconfig", filepath.Join(util.HomeDir(), ".kube", "config"), "kubeconfig file")
		flag.Parse()

		fmt.Println(&kubeconfig)

		// 创建 Kubernetes 客户端
		config, err := clientcmd.BuildConfigFromFlags("", *kubeconfig)
		if err != nil {
			panic(err.Error())
		}

		fmt.Println(&config)

		clientset, err := kubernetes.NewForConfig(config)
		if err != nil {
			panic(err.Error())
		}

		if *createNamespace == "" {
			fmt.Println("Namespace, Deployment, and Service names are required")
			createCmd.PrintDefaults()
			os.Exit(1)
		}

		err = k8s.CreateNamespace(clientset, *createNamespace)
		if err != nil {
			panic(err)
		}
		for _, proj := range k8s.Projects {
			obj := k8s.GetCreateObj(proj)
			err = obj.CreateDeploymentAndService(k8s.Config{
				Client:         clientset,
				NameSpace:      *createNamespace,
				DeploymentName: proj,
				ServiceName:    proj,
				Image:          "fai365.com:9088/aps/aps",
			}, nil)
			if err != nil {
				panic(err)
			}
		}

		nodeport, err := k8s.GetServiceNodePort(clientset, *createNamespace, "aps")
		if err != nil {
			panic(err)
		}

		log.Printf("Service NodePort: %d\n", nodeport)
	}

	// 执行 delete 命令
	if deleteCmd.Parsed() {
		// 配置 Kubernetes 集群的 kubeconfig 路径
		kubeconfig := flag.String("kubeconfig", filepath.Join(util.HomeDir(), ".kube", "config"), "kubeconfig file")
		flag.Parse()

		// 创建 Kubernetes 客户端
		config, err := clientcmd.BuildConfigFromFlags("", *kubeconfig)
		if err != nil {
			panic(err.Error())
		}

		clientset, err := kubernetes.NewForConfig(config)
		if err != nil {
			panic(err.Error())
		}

		if *deleteNamespace == "" || *deleteDeployment == "" || *deleteService == "" {
			fmt.Println("Namespace, Deployment, and Service names are required")
			deleteCmd.PrintDefaults()
			os.Exit(1)
		}

		for _, proj := range k8s.Projects {
			err = k8s.DeleteResources(clientset, *deleteNamespace, proj, proj)
			if err != nil {
				panic(err)
			}
			if err != nil {
				panic(err)
			}
		}

		fmt.Println("Resources deleted.")
	}

	// 执行创建和删除测试
	if testCmd.Parsed() {
		// 配置 Kubernetes 集群的 kubeconfig 路径
		kubeconfig := flag.String("kubeconfig", filepath.Join(util.HomeDir(), ".kube", "config"), "kubeconfig file")
		flag.Parse()

		// 创建 Kubernetes 客户端
		config, err := clientcmd.BuildConfigFromFlags("", *kubeconfig)
		if err != nil {
			panic(err.Error())
		}

		clientset, err := kubernetes.NewForConfig(config)
		if err != nil {
			panic(err.Error())
		}

		fmt.Println("\033[97;40mRunning create and delete tests...\033[0m")

		// 创建测试
		fmt.Println("\033[97;40m--- Create Test ---\033[0m")
		for _, ns := range namespaces {
			deploymentName := ns
			serviceName := ns
			for _, proj := range k8s.Projects {
				obj := k8s.GetCreateObj(proj)
				err = obj.CreateDeploymentAndService(k8s.Config{
					Client:         clientset,
					NameSpace:      ns,
					DeploymentName: deploymentName,
					ServiceName:    serviceName,
				}, nil)
				if err != nil {
					log.Printf("\033[97;41mFailed to create resources in namespace %s: %v\033[0m\n", ns, err)
				} else {
					nodeport, err := k8s.GetServiceNodePort(clientset, ns, ns)
					if err != nil {
						panic(err)
					}

					log.Printf("Service NodePort: %d\n", nodeport)
					log.Printf("\033[97;42mSuccessfully created resources in namespace %s\033[0m\n", ns)
				}
			}

		}

		// 延迟 1000 秒后删除创建的资源
		time.Sleep(1000 * time.Second)

		// 删除测试
		fmt.Println("\033[97;40m--- Delete Test ---\033[0m")

		// 删除多个 Namespace 下的相同名称的 Deployment 和 Service
		for _, ns := range namespaces {
			err = k8s.DeleteResources(clientset, ns, ns, ns)
			if err != nil {
				panic(err)
			}
		}

		fmt.Println("Resources deleted.")
	}

	if clusterCmd.Parsed() {
		// 初始化配置解析库
		viper.SetConfigName("config")
		viper.SetConfigType("yaml")
		viper.AddConfigPath("./config")

		// 读取配置文件
		err := viper.ReadInConfig()
		if err != nil {
			log.Fatalf("Failed to read config file: %v", err)
		}

		// 解析配置文件中的字段
		var rancherClusterConfig rancher.RancherClusterConfig
		err = viper.Unmarshal(&rancherClusterConfig)
		if err != nil {
			log.Fatalf("Failed to unmarshal config: %v", err)
		}
		clusterName := "kubernetus"
		fmt.Println(rancherClusterConfig)
		cluster_test(clusterName, rancherClusterConfig)
	}

}