// Licensed to the Apache Software Foundation (ASF) under one or more
// contributor license agreements.  See the NOTICE file distributed with
// this work for additional information regarding copyright ownership.
// The ASF licenses this file to You under the Apache License, Version 2.0
// (the "License"); you may not use this file except in compliance with
// the License.  You may obtain a copy of the License at
//
//	http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package cmd

import (
	"context"
	"fmt"
	"io"
	"net"
	"os"
	"os/exec"
	"os/signal"
	"runtime"
	"strconv"
	"strings"
)

import (
	"github.com/spf13/cobra"

	"go.uber.org/zap/zapcore"

	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"

	"k8s.io/client-go/kubernetes"
)

import (
	"github.com/apache/dubbo-kubernetes/app/dubboctl/identifier"
	"github.com/apache/dubbo-kubernetes/app/dubboctl/internal/kube"
	"github.com/apache/dubbo-kubernetes/pkg/core/logger"
)

var (
	// TODO: think about a efficient way to change selectors and ports when yaml files change
	// ports are coming from /deploy/charts and /deploy/kubernetes
	ComponentPortMap = map[kube.ComponentName]int{
		kube.Admin:      8080,
		kube.Grafana:    3000,
		kube.Nacos:      8848,
		kube.Prometheus: 9090,
		kube.Skywalking: 8080,
		kube.Zipkin:     9411,
	}
	// ComponentSelectorMap selectors are coming from /deploy/charts and /deploy/kubernetes
	ComponentSelectorMap = map[kube.ComponentName]string{
		kube.Admin:      "app.kubernetes.io/name=dubbo-admin",
		kube.Grafana:    "app.kubernetes.io/name=grafana",
		kube.Nacos:      "app.kubernetes.io/name=nacos",
		kube.Prometheus: "app=prometheus",
		kube.Skywalking: "app=skywalking, component=ui",
		kube.Zipkin:     "app.kubernetes.io/name=zipkin",
	}
)

type DashboardCommonArgs struct {
	port           int
	host           string
	openBrowser    bool
	namespace      string
	KubeConfigPath string
	// selected cluster info of kubeconfig
	Context string
}

func (dca *DashboardCommonArgs) setDefault() {
	if dca == nil {
		return
	}
	if dca.host == "" {
		dca.host = "127.0.0.1"
	}
	if dca.namespace == "" {
		dca.namespace = identifier.DubboSystemNamespace
	}
}

func commonDashboardCmd(baseCmd *cobra.Command, compName kube.ComponentName) {
	nameStr := string(compName)
	lowerNameStr := strings.ToLower(nameStr)
	dcArgs := &DashboardCommonArgs{}
	cmd := &cobra.Command{
		Use:   lowerNameStr,
		Short: fmt.Sprintf("create PortForward between local address and target component %s pod. open browser by default", nameStr),
		Example: fmt.Sprintf(`  # create PortForward in 127.0.0.1:%d and open browser directly
  dubboctl dashboard %s
  # specify port
  dubboctl dashboard %s --port %d
  # do not open browser
  dubboctl dashboard %s --openBrowser false
  # specify namespace of Admin
  dubboctl dashboard %s --namespace ns_user_specified
`, ComponentPortMap[compName], lowerNameStr, lowerNameStr, ComponentPortMap[compName], lowerNameStr, lowerNameStr),
		RunE: func(cmd *cobra.Command, args []string) error {
			logger.InitCmdSugar(zapcore.AddSync(cmd.OutOrStdout()))
			dcArgs.setDefault()
			if err := portForward(dcArgs, compName, cmd.OutOrStdout()); err != nil {
				return err
			}
			return nil
		},
	}
	cmd.PersistentFlags().IntVarP(&dcArgs.port, "port", "p", 0,
		fmt.Sprintf("local port to listen on. If not set, it would be same as the default port of component %s", nameStr))
	cmd.PersistentFlags().StringVarP(&dcArgs.host, "host", "", "",
		"local host to bind. If not set, it would be 127.0.0.1")
	// openBrowser is default behaviour
	cmd.PersistentFlags().BoolVarP(&dcArgs.openBrowser, "openBrowser", "", true,
		"whether to open browser automatically")
	cmd.PersistentFlags().StringVarP(&dcArgs.namespace, "namespace", "n", "",
		fmt.Sprintf("namespace in which component %s is located", nameStr))
	cmd.PersistentFlags().StringVarP(&dcArgs.KubeConfigPath, "kubeConfig", "", "",
		"Path to kubeconfig")
	cmd.PersistentFlags().StringVarP(&dcArgs.Context, "context", "", "",
		"Context in kubeconfig to use")

	baseCmd.AddCommand(cmd)
}

func ConfigDashboardAdminCmd(baseCmd *cobra.Command) {
	commonDashboardCmd(baseCmd, kube.Admin)
}

func ConfigDashboardGrafanaCmd(baseCmd *cobra.Command) {
	commonDashboardCmd(baseCmd, kube.Grafana)
}

func ConfigDashboardNacosCmd(baseCmd *cobra.Command) {
	commonDashboardCmd(baseCmd, kube.Nacos)
}

func ConfigDashboardPrometheusCmd(baseCmd *cobra.Command) {
	commonDashboardCmd(baseCmd, kube.Prometheus)
}

func ConfigDashboardSkywalkingCmd(baseCmd *cobra.Command) {
	commonDashboardCmd(baseCmd, kube.Skywalking)
}

func ConfigDashboardZipkinCmd(baseCmd *cobra.Command) {
	commonDashboardCmd(baseCmd, kube.Zipkin)
}

func portForward(args *DashboardCommonArgs, compName kube.ComponentName, writer io.Writer) error {
	// process args
	var podPort int
	podPort = ComponentPortMap[compName]
	if args.port == 0 {
		args.port = podPort
	}

	// prepare PortForward args
	labelSelector := ComponentSelectorMap[compName]
	cfg, err := kube.BuildConfig(args.KubeConfigPath, args.Context)
	if err != nil {
		return fmt.Errorf("build kube config failed, err: %s", err)
	}
	// todo: unify kube client
	cli, err := kubernetes.NewForConfig(cfg)
	if err != nil {
		return fmt.Errorf("create kube RESTClient failed, err: %s", err)
	}
	pods, err := cli.CoreV1().Pods(args.namespace).List(context.Background(), metav1.ListOptions{
		LabelSelector: labelSelector,
	})
	if err != nil {
		return fmt.Errorf("list pod failed, err: %s", err)
	}
	if len(pods.Items) < 1 {
		return fmt.Errorf("no %s pods found", string(compName))
	}
	// use name of the first pod
	podName := pods.Items[0].Name

	pf, err := kube.NewPortForward(podName, args.namespace, args.host, args.port, podPort, cfg)
	if err != nil {
		return fmt.Errorf("create PortForward failed, err: %s", err)
	}
	if err := pf.Run(); err != nil {
		pf.Stop()
		return fmt.Errorf("PortForward running failed, err: %s", err)
	}

	logger.CmdSugar().Infof("PortForward to %s pod is running", podName)

	// wait for interrupt
	go func() {
		signals := make(chan os.Signal, 1)
		signal.Notify(signals, os.Interrupt)
		defer signal.Stop(signals)
		<-signals
		logger.CmdSugar().Info("PortForward stops")
		pf.Stop()
	}()

	if args.openBrowser {
		address := net.JoinHostPort(args.host, strconv.Itoa(args.port))
		url := "http://" + address
		openBrowser(url, writer)
	}

	pf.Wait()

	return nil
}

// openBrowser uses syscall from different runtime
func openBrowser(url string, writer io.Writer) {
	var err error

	fmt.Fprintf(writer, "open browser in %s\n", url)

	switch runtime.GOOS {
	case "linux":
		err = exec.Command("xdg-open", url).Start()
	case "windows":
		err = exec.Command("rundll32", "url.dll,FileProtocolHandler", url).Start()
	case "darwin":
		err = exec.Command("open", url).Start()
	default:
		fmt.Fprintf(writer, "unsupported platform %q. pls open %s in your browser.\n", runtime.GOOS, url)
	}

	if err != nil {
		fmt.Fprintf(writer, "open browser failed; open %s in your browser.\n", url)
	}
}