cmd

var BPFAuthCmd = &cobra.Command{
	Use:   "auth",
	Short: "Manage authenticated connections between identities",
}

var BPFBandwidthCmd = &cobra.Command{
	Use:   "bandwidth",
	Short: "BPF datapath bandwidth settings",
}

var BPFCmd = &cobra.Command{
	Use:   "bpf",
	Short: "Direct access to local BPF maps",
}

var BPFConfigCmd = &cobra.Command{
	Use:   "config",
	Short: "Manage runtime config",
}

var BPFCtCmd = &cobra.Command{
	Use:   "ct",
	Short: "Connection tracking tables",
}

var BPFEgressCmd = &cobra.Command{
	Use:   "egress",
	Short: "Manage the egress routing rules",
}

var BPFEndpointCmd = &cobra.Command{
	Use:   "endpoint",
	Short: "Local endpoint map",
}

var BPFIPCacheCmd = &cobra.Command{
	Use:   "ipcache",
	Short: "Manage the IPCache mappings for IP/CIDR <-> Identity",
}

var BPFIPMasqCmd = &cobra.Command{
	Use:   "ipmasq",
	Short: "ip-masq-agent CIDRs",
}

var BPFLBCmd = &cobra.Command{
	Use:   "lb",
	Short: "Load-balancing configuration",
}

var BPFMaglevCmd = &cobra.Command{
	Use:   "maglev",
	Short: "Maglev lookup table",
}

var BPFMetricsCmd = &cobra.Command{
	Use:   "metrics",
	Short: "BPF datapath traffic metrics",
}

var BPFMountFSCmd = &cobra.Command{
	Use:   "fs",
	Short: "BPF filesystem mount",
}

var BPFNatCmd = &cobra.Command{
	Use:   "nat",
	Short: "NAT mapping tables",
}

var BPFNodeIDCmd = &cobra.Command{
	Use:   "nodeid",
	Short: "Manage the node IDs",
}

var BPFPolicyCmd = &cobra.Command{
	Use:   "policy",
	Short: "Manage policy related BPF maps",
}

var BPFRecorderCmd = &cobra.Command{
	Use:   "recorder",
	Short: "PCAP recorder",
}

var BPFSRv6Cmd = &cobra.Command{
	Use:   "srv6",
	Short: "Manage the SRv6 routing rules",
}

var BPFTemplateCmd = &cobra.Command{
	Use:     "sha",
	Aliases: []string{"template"},
	Short:   "Manage compiled BPF template objects",
}

var BPFTunnelCmd = &cobra.Command{
	Use:   "tunnel",
	Short: "Tunnel endpoint map",
}

var BPFVtepCmd = &cobra.Command{
	Use:   "vtep",
	Short: "Manage the VTEP mappings for IP/CIDR <-> VTEP MAC/IP",
}

var BgpCmd = &cobra.Command{
	Use:   "bgp",
	Short: "Access to BGP control plane",
}

var BgpPeersCmd = &cobra.Command{
	Use:     "peers",
	Aliases: []string{"neighbors"},
	Short:   "List current state of all peers",
	Long:    "List state of all peers defined in CiliumBGPPeeringPolicy",
	Run: func(cmd *cobra.Command, args []string) {
		res, err := client.Bgp.GetBgpPeers(nil)
		if err != nil {
			disabledErr := bgp.NewGetBgpPeersDisabled()
			if errors.As(err, &disabledErr) {
				fmt.Println("BGP Control Plane is disabled")
				return
			}
			Fatalf("cannot get peers list: %s\n", err)
		}

		if command.OutputOption() {
			if err := command.PrintOutput(res.GetPayload()); err != nil {
				Fatalf("error getting output in JSON: %s\n", err)
			}
		} else {
			printSummary(res.GetPayload())
		}
	},
}

var BgpRoutePoliciesCmd = &cobra.Command{
	Use:     "route-policies [vrouter <asn>]",
	Aliases: []string{"rps"},
	Short:   "List configured route policies",
	Long:    "List route policies configured in the underlying routing daemon",
	Run: func(cmd *cobra.Command, args []string) {
		var err error
		params := bgp.NewGetBgpRoutePoliciesParams()

		if len(args) > 0 {
			var asn int64
			asn, _, err = parseVRouterASN(args)
			if err != nil {
				Fatalf("failed to parse vrouter ASN: %s\n", err)
			}
			params.RouterAsn = pointer.Int64(asn)
		}

		res, err := client.Bgp.GetBgpRoutePolicies(params)
		if err != nil {
			disabledErr := bgp.NewGetBgpRoutePoliciesDisabled()
			if errors.As(err, &disabledErr) {
				fmt.Println("BGP Control Plane is disabled")
				return
			}
			Fatalf("cannot get route policies list: %s\n", err)
		}

		if command.OutputOption() {
			if err := command.PrintOutput(res.GetPayload()); err != nil {
				Fatalf("error getting output in JSON: %s\n", err)
			}
		} else {
			printBGPRoutePoliciesTable(res.GetPayload())
		}
	},
}

var BgpRoutesCmd = &cobra.Command{
	Use:   "routes <available | advertised> <afi> <safi> [vrouter <asn>] [peer|neighbor <address>]",
	Short: "List routes in the BGP Control Plane's RIBs",
	Long:  "List routes in the BGP Control Plane's Routing Information Bases (RIBs)",
	Example: `  Get all IPv4 unicast routes available:
    cilium-dbg bgp routes available ipv4 unicast

  Get all IPv6 unicast routes available for a specific vrouter:
    cilium-dbg bgp routes available ipv6 unicast vrouter 65001

  Get IPv4 unicast routes advertised to a specific peer:
    cilium-dbg bgp routes advertised ipv4 unicast peer 10.0.0.1`,

	Run: func(cmd *cobra.Command, args []string) {
		var err error
		params := bgp.NewGetBgpRoutesParams()

		params.TableType, params.Afi, params.Safi, args, err = parseBGPRoutesMandatoryArgs(args, command.OutputOption())
		if err != nil {
			Fatalf("invalid argument: %s\n", err)
		}

		if len(args) > 0 && args[0] == vRouterKW {
			var asn int64
			asn, args, err = parseVRouterASN(args)
			if err != nil {
				Fatalf("failed to parse vrouter ASN: %s\n", err)
			}
			params.RouterAsn = pointer.Int64(asn)
		}

		if params.TableType == adjRIBOutTableType && len(args) > 0 {
			addr, err := parseBGPPeerAddr(args)
			if err != nil {
				Fatalf("failed to parse peer address: %s\n", err)
			}
			params.Neighbor = &addr
		}

		res, err := client.Bgp.GetBgpRoutes(params)
		if err != nil {
			disabledErr := bgp.NewGetBgpRoutesDisabled()
			if errors.As(err, &disabledErr) {
				fmt.Println("BGP Control Plane is disabled")
				return
			}
			Fatalf("failed retrieving routes: %s\n", err)
		}

		if command.OutputOption() {
			if err := command.PrintOutput(res.GetPayload()); err != nil {
				Fatalf("failed getting output in JSON: %s\n", err)
			}
		} else {

			printPeer := (params.TableType == adjRIBOutTableType) && (params.Neighbor == nil || *params.Neighbor == "")
			printBGPRoutesTable(res.GetPayload(), printPeer)
		}
	},
}

var CgroupsCmd = &cobra.Command{
	Use:   "cgroups",
	Short: "Cgroup metadata",
}

var CncryptCmd = &cobra.Command{
	Use:   "encrypt",
	Short: "Manage transparent encryption",
}

var EndpointCmd = &cobra.Command{
	Use:   "endpoint",
	Short: "Manage endpoints",
}

var IPCmd = &cobra.Command{
	Use:   "ip",
	Short: "Manage IP addresses and associated information",
}

var IdentityCmd = &cobra.Command{
	Use:   "identity",
	Short: "Manage security identities",
}

var LRPCmd = &cobra.Command{
	Use:   "lrp",
	Short: "Manage local redirect policies",
}

var MAPCmd = &cobra.Command{
	Use:   "map",
	Short: "Access userspace cached content of BPF maps",
}

var MetricsCmd = &cobra.Command{
	Use:   "metrics",
	Short: "Access metric status",
}

var MetricsListCmd = &cobra.Command{
	Use:   "list",
	Short: "List all metrics",
	Run: func(cmd *cobra.Command, args []string) {
		res, err := client.Metrics.GetMetrics(nil)
		if err != nil {
			Fatalf("Cannot get metrics list: %s", err)
		}

		re, err := regexp.Compile(matchPattern)
		if err != nil {
			Fatalf("Cannot compile regex: %s", err)
		}

		metrics := make([]*models.Metric, 0, len(res.Payload))
		for _, metric := range res.Payload {
			if re.MatchString(metric.Name) {
				metrics = append(metrics, metric)
			}
		}

		if command.OutputOption() {
			if err := command.PrintOutput(metrics); err != nil {
				os.Exit(1)
			}
			return
		}

		w := tabwriter.NewWriter(os.Stdout, 5, 0, 3, ' ', 0)

		fmt.Fprintln(w, "Metric\tLabels\tValue")
		for _, metric := range metrics {
			label := ""
			if len(metric.Labels) > 0 {
				labelArray := []string{}
				keys := make([]string, 0, len(metric.Labels))
				for k := range metric.Labels {
					keys = append(keys, k)
				}
				sort.Strings(keys)
				for _, k := range keys {
					labelArray = append(labelArray, fmt.Sprintf(`%s="%s"`, k, metric.Labels[k]))
				}
				label = strings.Join(labelArray, " ")
			}
			fmt.Fprintf(w, "%s\t%s\t%f\n", metric.Name, label, metric.Value)
		}
		w.Flush()
	},
}

var NodeCmd = &cobra.Command{
	Use:   "node",
	Short: "Manage cluster nodes",
}

var NodeIDCmd = &cobra.Command{
	Use:   "nodeid",
	Short: "List node IDs and associated information",
}

var PolicyCmd = &cobra.Command{
	Use:   "policy",
	Short: "Manage security policies",
}

var PreFilterCmd = &cobra.Command{
	Use:   "prefilter",
	Short: "Manage XDP CIDR filters",
}

var PreflightCmd = &cobra.Command{
	Use:   "preflight",
	Short: "Cilium upgrade helper",
	Long:  `CLI to help upgrade cilium`,
}

var RecorderCmd = &cobra.Command{
	Use:   "recorder",
	Short: "Introspect or mangle pcap recorder",
}

var RootCmd = &cobra.Command{
	Use:   "cilium-dbg",
	Short: "CLI",
	Long:  `CLI for interacting with the local Cilium Agent`,
}

var ServiceCmd = &cobra.Command{
	Use:   "service",
	Short: "Manage services & loadbalancers",
}

var StatedbCmd = &cobra.Command{
	Use:   "statedb",
	Short: "Inspect StateDB",
}