ipv4

var NetworkFirewallIPv4Cmd = &cobra.Command{
	Use:   "ipv4",
	Short: "Manage IPv4 firewall rules",
}

var NetworkFirewallIPv4CreateCmd = &cobra.Command{
	Use:   "create",
	Short: "Create an IPv4 firewall rule for a network",
	PreRunE: func(cmd *cobra.Command, args []string) error {
		if err := cli.Preflight(true)(cmd, args); err != nil {
			return err
		}
		return cli.Validate(cmd,
			cli.Required("networkId"),
			cli.IsUlid("networkId"),
			cli.Required("trafficType"),
			cli.OneOf("trafficType", "Ingress", "Egress"),
			cli.Required("protocolType"),
			cli.OneOf("protocolType", "TCP", "UDP", "ICMP"),
			cli.Required("ipSource"),
			cli.Required("ipDestination"),
			cli.RequiredIf("publicIpId", func(v cli.Values) bool { return v.GetString("trafficType") == "Ingress" }),
			cli.RequiredIf("icmpCode", func(v cli.Values) bool { return v.GetString("protocolType") == "ICMP" }),
			cli.RequiredIf("icmpType", func(v cli.Values) bool { return v.GetString("protocolType") == "ICMP" }),
		)
	},
	RunE: func(cmd *cobra.Command, args []string) error {
		token := cli.TokenFromContext(cmd.Context())
		zoneId := cli.ZoneIDFromContext(cmd.Context())

		if err := cli.LoadFromCobraFlags(cmd, &firewallIPv4CreateOpts); err != nil {
			return err
		}

		body := map[string]interface{}{
			"traffic_type":   firewallIPv4CreateOpts.TrafficType,
			"protocol_type":  firewallIPv4CreateOpts.ProtocolType,
			"public_ip_id":   firewallIPv4CreateOpts.PublicIpId,
			"ip_source":      firewallIPv4CreateOpts.IPSource,
			"ip_destination": firewallIPv4CreateOpts.IPDestination,
		}

		if firewallIPv4CreateOpts.ProtocolType == "ICMP" {
			body["icmp_code"] = firewallIPv4CreateOpts.ICMPCode
			body["icmp_type"] = firewallIPv4CreateOpts.ICMPType
		} else {
			body["port_start"] = firewallIPv4CreateOpts.PortStart
			body["port_end"] = firewallIPv4CreateOpts.PortEnd
		}

		httpClient := http.NewClient(token)
		resp, err := httpClient.CreateIPv4FirewallRule(zoneId, firewallIPv4CreateOpts.NetworkID, body)
		if err != nil {
			slog.Error("failed to create IPv4 firewall rule", "error", err)
			return fmt.Errorf("failed to create IPv4 firewall rule: %w", err)
		}

		if resp.Data.Success {
			fmt.Println("IPv4 firewall rule created successfully.")
		} else {
			fmt.Println("Failed to create IPv4 firewall rule.")
		}
		return nil
	},
}

var NetworkFirewallIPv4DeleteCmd = &cobra.Command{
	Use:   "delete",
	Short: "Delete an IPv4 firewall rule from a network",
	PreRunE: func(cmd *cobra.Command, args []string) error {
		if err := cli.Preflight(true)(cmd, args); err != nil {
			return err
		}
		return cli.Validate(cmd,
			cli.Required("networkId"),
			cli.IsUlid("networkId"),
			cli.Required("ruleId"),
		)
	},
	RunE: func(cmd *cobra.Command, args []string) error {
		token := cli.TokenFromContext(cmd.Context())
		zoneId := cli.ZoneIDFromContext(cmd.Context())

		if err := cli.LoadFromCobraFlags(cmd, &firewallIPv4DeleteOpts); err != nil {
			return err
		}

		httpClient := http.NewClient(token)
		resp, err := httpClient.DeleteIPv4FirewallRule(zoneId, firewallIPv4DeleteOpts.NetworkID, firewallIPv4DeleteOpts.RuleID)
		if err != nil {
			slog.Error("failed to delete IPv4 firewall rule", "error", err)
			return fmt.Errorf("failed to delete IPv4 firewall rule: %w", err)
		}

		if resp.Data.Success {
			fmt.Println("IPv4 firewall rule deleted successfully.")
		} else {
			fmt.Println("Failed to delete IPv4 firewall rule.")
		}
		return nil
	},
}

var NetworkFirewallIPv4ListCmd = &cobra.Command{
	Use:   "list",
	Short: "List IPv4 firewall rules for a network",
	PreRunE: func(cmd *cobra.Command, args []string) error {
		if err := cli.Preflight(true)(cmd, args); err != nil {
			return err
		}
		return cli.Validate(cmd,
			cli.Required("networkId"),
			cli.IsUlid("networkId"),
		)
	},
	RunE: func(cmd *cobra.Command, args []string) error {
		token := cli.TokenFromContext(cmd.Context())
		zoneId := cli.ZoneIDFromContext(cmd.Context())

		if err := cli.LoadFromCobraFlags(cmd, &firewallIPv4ListOpts); err != nil {
			return err
		}

		httpClient := http.NewClient(token)
		resp, err := httpClient.ListIPv4FirewallRules(zoneId, firewallIPv4ListOpts.NetworkID)
		if err != nil {
			slog.Error("failed to list IPv4 firewall rules", "error", err)
			return fmt.Errorf("failed to list IPv4 firewall rules: %w", err)
		}

		if len(resp.Data) == 0 {
			fmt.Println("No IPv4 firewall rules found.")
			return nil
		}

		table := tablewriter.NewWriter(os.Stdout)
		table.SetHeader([]string{"ID", "Protocol", "TrafficType", "Source", "Destination", "Status", "CreatedAt"})

		for _, rule := range resp.Data {
			table.Append([]string{rule.ID, rule.Protocol, rule.TrafficType, rule.IPSource, rule.IPDestination, rule.Status, fmt.Sprintf("%d", rule.CreatedAt)})
		}
		table.Render()
		return nil
	},
}