// +build linux

package main

import (
	"encoding/json"
	"fmt"
	"net"
	"os"
	"strconv"
	"strings"
	"time"

	"github.com/sirupsen/logrus"
	"github.com/urfave/cli"

	"github.com/containernetworking/cni/pkg/skel"
	"github.com/containernetworking/cni/pkg/types"
	"github.com/containernetworking/cni/pkg/types/current"
	"github.com/containernetworking/cni/pkg/version"
	"k8s.io/apimachinery/pkg/util/wait"

	kexec "k8s.io/utils/exec"
	"ovn4nfv-k8s-plugin/internal/pkg/kube"

	"ovn4nfv-k8s-plugin/cmd/ovn4nfvk8s-cni/app"
	"ovn4nfv-k8s-plugin/internal/pkg/config"
)

func argString2Map(args string) (map[string]string, error) {
	argsMap := make(map[string]string)

	pairs := strings.Split(args, ";")
	for _, pair := range pairs {
		kv := strings.Split(pair, "=")
		if len(kv) != 2 {
			return nil, fmt.Errorf("ARGS: invalid pair %q", pair)
		}
		keyString := kv[0]
		valueString := kv[1]
		argsMap[keyString] = valueString
	}

	return argsMap, nil
}

func parseOvnNetworkObject(ovnnetwork string) ([]map[string]string, error) {
	var ovnNet []map[string]string

	if ovnnetwork == "" {
		return nil, fmt.Errorf("parseOvnNetworkObject:error")
	}

	if err := json.Unmarshal([]byte(ovnnetwork), &ovnNet); err != nil {
		return nil, fmt.Errorf("parseOvnNetworkObject: failed to load ovn network err: %v | ovn network: %v", err, ovnnetwork)
	}

	return ovnNet, nil
}

func mergeWithResult(srcObj, dstObj types.Result) (types.Result, error) {

	if dstObj == nil {
		return srcObj, nil
	}
	src, err := current.NewResultFromResult(srcObj)
	if err != nil {
		return nil, fmt.Errorf("Couldn't convert old result to current version: %v", err)
	}
	dst, err := current.NewResultFromResult(dstObj)
	if err != nil {
		return nil, fmt.Errorf("Couldn't convert old result to current version: %v", err)
	}

	ifacesLength := len(dst.Interfaces)

	for _, iface := range src.Interfaces {
		dst.Interfaces = append(dst.Interfaces, iface)
	}
	for _, ip := range src.IPs {
		if ip.Interface != nil && *(ip.Interface) != -1 {
			ip.Interface = current.Int(*(ip.Interface) + ifacesLength)
		}
		dst.IPs = append(dst.IPs, ip)
	}
	for _, route := range src.Routes {
		dst.Routes = append(dst.Routes, route)
	}

	for _, ns := range src.DNS.Nameservers {
		dst.DNS.Nameservers = append(dst.DNS.Nameservers, ns)
	}
	for _, s := range src.DNS.Search {
		dst.DNS.Search = append(dst.DNS.Search, s)
	}
	for _, opt := range src.DNS.Options {
		dst.DNS.Options = append(dst.DNS.Options, opt)
	}
	// TODO: what about DNS.domain?
	return dst, nil
}

func prettyPrint(i interface{}) string {
	s, _ := json.MarshalIndent(i, "", "\t")
	return string(s)
}

func addMultipleInterfaces(args *skel.CmdArgs, ovnAnnotation, namespace, podName string) types.Result {
	logrus.Infof("ovn4nfvk8s-cni: addMultipleInterfaces ")

	var ovnAnnotatedMap []map[string]string
	ovnAnnotatedMap, err := parseOvnNetworkObject(ovnAnnotation)
	if err != nil {
		logrus.Errorf("addLogicalPort : Error Parsing Ovn Network List %v", ovnAnnotatedMap)
		return nil
	}
	if namespace == "" || podName == "" {
		logrus.Errorf("required CNI variable missing")
		return nil
	}
	var interfacesArray []*current.Interface
	var index int
	var result *current.Result
	var dstResult types.Result
	for _, ovnNet := range ovnAnnotatedMap {
		ipAddress := ovnNet["ip_address"]
		macAddress := ovnNet["mac_address"]
		gatewayIP := ovnNet["gateway_ip"]
		defaultGateway := ovnNet["defaultGateway"]

		if ipAddress == "" || macAddress == "" {
			logrus.Errorf("failed in pod annotation key extract")
			return nil
		}

		index++
		interfaceName := ovnNet["interface"]
		if interfaceName == "" {
			logrus.Errorf("addMultipleInterfaces: interface can't be null")
			return nil
		}
		logrus.Debugf("addMultipleInterfaces: ipAddress %v %v", ipAddress, interfaceName)
		interfacesArray, err = app.ConfigureInterface(args, namespace, podName, macAddress, ipAddress, gatewayIP, interfaceName, defaultGateway, config.Default.MTU)
		if err != nil {
			logrus.Errorf("Failed to configure interface in pod: %v", err)
			return nil
		}
		addr, addrNet, err := net.ParseCIDR(ipAddress)
		if err != nil {
			logrus.Errorf("failed to parse IP address %q: %v", ipAddress, err)
			return nil
		}
		ipVersion := "6"
		if addr.To4() != nil {
			ipVersion = "4"
		}
		var routes types.Route
		if defaultGateway == "true" {
			defaultAddr, defaultAddrNet, _ := net.ParseCIDR("0.0.0.0/0")
			routes = types.Route{Dst: net.IPNet{IP: defaultAddr, Mask: defaultAddrNet.Mask}, GW: net.ParseIP(gatewayIP)}

			result = &current.Result{
				Interfaces: interfacesArray,
				IPs: []*current.IPConfig{
					{
						Version:   ipVersion,
						Interface: current.Int(1),
						Address:   net.IPNet{IP: addr, Mask: addrNet.Mask},
						Gateway:   net.ParseIP(gatewayIP),
					},
				},
				Routes: []*types.Route{&routes},
			}
		} else {
			result = &current.Result{
				Interfaces: interfacesArray,
				IPs: []*current.IPConfig{
					{
						Version:   ipVersion,
						Interface: current.Int(1),
						Address:   net.IPNet{IP: addr, Mask: addrNet.Mask},
						Gateway:   net.ParseIP(gatewayIP),
					},
				},
			}

		}
		// Build the result structure to pass back to the runtime
		dstResult, err = mergeWithResult(types.Result(result), dstResult)
		if err != nil {
			logrus.Errorf("Failed to merge results: %v", err)
			return nil
		}
	}
	logrus.Infof("addMultipleInterfaces:  %s", prettyPrint(dstResult))
	return dstResult
}

func cmdAdd(args *skel.CmdArgs) error {
	logrus.Infof("ovn4nfvk8s-cni: cmdAdd ")
	conf := &types.NetConf{}
	if err := json.Unmarshal(args.StdinData, conf); err != nil {
		return fmt.Errorf("failed to load netconf: %v", err)
	}

	argsMap, err := argString2Map(args.Args)
	if err != nil {
		return err
	}

	namespace := argsMap["K8S_POD_NAMESPACE"]
	podName := argsMap["K8S_POD_NAME"]
	if namespace == "" || podName == "" {
		return fmt.Errorf("required CNI variable missing")
	}

	clientset, err := config.NewClientset(&config.Kubernetes)
	if err != nil {
		return fmt.Errorf("Could not create clientset for kubernetes: %v", err)
	}
	kubecli := &kube.Kube{KClient: clientset}

	// Get the IP address and MAC address from the API server.
	var annotationBackoff = wait.Backoff{Duration: 1 * time.Second, Steps: 14, Factor: 1.5, Jitter: 0.1}
	var annotation map[string]string
	if err := wait.ExponentialBackoff(annotationBackoff, func() (bool, error) {
		annotation, err = kubecli.GetAnnotationsOnPod(namespace, podName)
		if err != nil {
			// TODO: check if err is non recoverable
			logrus.Warningf("Error while obtaining pod annotations - %v", err)
			return false, nil
		}
		if _, ok := annotation["ovnIfaceList"]; ok {
			return true, nil
		}
		return false, nil
	}); err != nil {
		return fmt.Errorf("failed to get pod annotation - %v", err)
	}
	logrus.Infof("ovn4nfvk8s-cni: Annotation Found ")
	ovnAnnotation, ok := annotation["ovnIfaceList"]
	if !ok {
		return fmt.Errorf("Error while obtaining pod annotations")
	}
	result := addMultipleInterfaces(args, ovnAnnotation, namespace, podName)
	return result.Print()
}

func cmdDel(args *skel.CmdArgs) error {
	logrus.Infof("ovn4nfvk8s-cni: cmdDel ")
	for i := 0; i < 10; i++ {
		ifaceName := args.ContainerID[:14] + strconv.Itoa(i)
		done, err := app.PlatformSpecificCleanup(ifaceName)
		if err != nil {
			logrus.Errorf("Teardown error: %v", err)
		}
		if done {
			break
		}
	}
	return nil
}

func main() {
	logrus.Infof("ovn4nfvk8s-cni CNI Invoked by Multus")
	c := cli.NewApp()
	c.Name = "ovn4nfvk8s-cni"
	c.Usage = "a CNI plugin to set up or tear down a additional interfaces with OVN"
	c.Version = "0.0.2"
	c.Flags = config.Flags

	exec := kexec.New()
	c.Action = func(ctx *cli.Context) error {
		if _, err := config.InitConfig(ctx, exec, nil); err != nil {
			return err
		}

		skel.PluginMain(cmdAdd, cmdDel, version.All)
		return nil
	}

	if err := c.Run(os.Args); err != nil {
		// Print the error to stdout in conformance with the CNI spec
		e, ok := err.(*types.Error)
		if !ok {
			e = &types.Error{Code: 100, Msg: err.Error()}
		}
		e.Print()
	}
}