package onvif

import (
	"context"
	"encoding/xml"
	"errors"
	"fmt"
	"strings"
	"time"

	"github.com/0x524a/onvif-go/internal/soap"
)

// Event service namespace.
const eventNamespace = "http://www.onvif.org/ver10/events/wsdl"

// Event service errors.
var (
	// ErrInvalidSubscriptionReference is returned when subscription reference is invalid.
	ErrInvalidSubscriptionReference = errors.New("invalid subscription reference")
	// ErrInvalidTerminationTime is returned when termination time is invalid.
	ErrInvalidTerminationTime = errors.New("invalid termination time")
	// ErrInvalidMessageLimit is returned when message limit is invalid.
	ErrInvalidMessageLimit = errors.New("invalid message limit: must be positive")
	// ErrInvalidTimeout is returned when timeout is invalid.
	ErrInvalidTimeout = errors.New("invalid timeout: must be positive")
	// ErrInvalidFilter is returned when filter expression is invalid.
	ErrInvalidFilter = errors.New("invalid filter expression")
	// ErrInvalidEventBrokerAddress is returned when event broker address is empty.
	ErrInvalidEventBrokerAddress = errors.New("invalid event broker address: cannot be empty")
	// ErrPullPointNotSupported is returned when pull point is not supported.
	ErrPullPointNotSupported = errors.New("pull point subscription not supported")
	// ErrEventBrokerConfigNil is returned when event broker config is nil.
	ErrEventBrokerConfigNil = errors.New("event broker config cannot be nil")
)

// EventServiceCapabilities represents the capabilities of the event service.
type EventServiceCapabilities struct {
	WSSubscriptionPolicySupport                   bool
	WSPausableSubscriptionManagerInterfaceSupport bool
	MaxNotificationProducers                      int
	MaxPullPoints                                 int
	PersistentNotificationStorage                 bool
	EventBrokerProtocols                          []string
	MaxEventBrokers                               int
	MetadataOverMQTT                              bool
}

// PullPointSubscription represents a pull point subscription.
type PullPointSubscription struct {
	SubscriptionReference string
	CurrentTime           time.Time
	TerminationTime       time.Time
}

// NotificationMessage represents a notification message from an event.
type NotificationMessage struct {
	Topic           string
	Message         EventMessage
	ProducerAddress string
	SubscriptionID  string
}

// EventMessage represents the content of an event message.
type EventMessage struct {
	PropertyOperation string
	UtcTime           time.Time
	Source            []SimpleItem
	Key               []SimpleItem
	Data              []SimpleItem
}

// EventSimpleItem represents a simple name-value pair in an event message.
// Note: Uses SimpleItem from types.go which has the same structure.

// TopicSet represents the set of topics supported by the device.
type TopicSet struct {
	Topics []Topic
}

// Topic represents an event topic.
type Topic struct {
	Name        string
	Description string
	Children    []Topic
}

// EventBrokerConfig represents an event broker configuration.
type EventBrokerConfig struct {
	Address            string
	TopicPrefix        string
	UserName           string
	Password           string
	CertificateID      string
	PublishFilter      string
	QoS                int
	Status             string
	CertPathValidation bool
	MetadataFilter     string
}

// EventProperties represents the event properties of the device.
type EventProperties struct {
	TopicNamespaceLocation           []string
	FixedTopicSet                    bool
	TopicSet                         TopicSet
	TopicExpressionDialects          []string
	MessageContentFilterDialects     []string
	ProducerPropertiesFilterDialects []string
	MessageContentSchemaLocation     []string
}

// getEventEndpoint returns the event endpoint, falling back to the default endpoint if not set.
func (c *Client) getEventEndpoint() string {
	c.mu.RLock()
	defer c.mu.RUnlock()

	if c.eventEndpoint != "" {
		return c.eventEndpoint
	}

	return c.endpoint
}

// SetEventEndpoint sets the event service endpoint.
func (c *Client) SetEventEndpoint(endpoint string) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.eventEndpoint = endpoint
}

// GetEventServiceCapabilities retrieves the capabilities of the event service.
func (c *Client) GetEventServiceCapabilities(ctx context.Context) (*EventServiceCapabilities, error) {
	endpoint := c.getEventEndpoint()

	type GetServiceCapabilities struct {
		XMLName xml.Name `xml:"tev:GetServiceCapabilities"`
		Xmlns   string   `xml:"xmlns:tev,attr"`
	}

	type GetServiceCapabilitiesResponse struct {
		XMLName      xml.Name `xml:"GetServiceCapabilitiesResponse"`
		Capabilities struct {
			WSSubscriptionPolicySupport                   bool   `xml:"WSSubscriptionPolicySupport,attr"`
			WSPausableSubscriptionManagerInterfaceSupport bool   `xml:"WSPausableSubscriptionManagerInterfaceSupport,attr"`
			MaxNotificationProducers                      int    `xml:"MaxNotificationProducers,attr"`
			MaxPullPoints                                 int    `xml:"MaxPullPoints,attr"`
			PersistentNotificationStorage                 bool   `xml:"PersistentNotificationStorage,attr"`
			EventBrokerProtocols                          string `xml:"EventBrokerProtocols,attr"`
			MaxEventBrokers                               int    `xml:"MaxEventBrokers,attr"`
			MetadataOverMQTT                              bool   `xml:"MetadataOverMQTT,attr"`
		} `xml:"Capabilities"`
	}

	req := GetServiceCapabilities{
		Xmlns: eventNamespace,
	}

	var resp GetServiceCapabilitiesResponse

	username, password := c.GetCredentials()
	soapClient := soap.NewClient(c.httpClient, username, password)

	if err := soapClient.Call(ctx, endpoint, "", req, &resp); err != nil {
		return nil, fmt.Errorf("GetEventServiceCapabilities failed: %w", err)
	}

	caps := &EventServiceCapabilities{
		WSSubscriptionPolicySupport:                   resp.Capabilities.WSSubscriptionPolicySupport,
		WSPausableSubscriptionManagerInterfaceSupport: resp.Capabilities.WSPausableSubscriptionManagerInterfaceSupport,
		MaxNotificationProducers:                      resp.Capabilities.MaxNotificationProducers,
		MaxPullPoints:                                 resp.Capabilities.MaxPullPoints,
		PersistentNotificationStorage:                 resp.Capabilities.PersistentNotificationStorage,
		MaxEventBrokers:                               resp.Capabilities.MaxEventBrokers,
		MetadataOverMQTT:                              resp.Capabilities.MetadataOverMQTT,
	}

	// Parse event broker protocols from space-separated string.
	if resp.Capabilities.EventBrokerProtocols != "" {
		caps.EventBrokerProtocols = splitSpaceSeparated(resp.Capabilities.EventBrokerProtocols)
	}

	return caps, nil
}

// CreatePullPointSubscription creates a new pull point subscription.
func (c *Client) CreatePullPointSubscription(
	ctx context.Context,
	filter string,
	initialTerminationTime *time.Duration,
	subscriptionPolicy string,
) (*PullPointSubscription, error) {
	endpoint := c.getEventEndpoint()

	type Filter struct {
		TopicExpression string `xml:"wsnt:TopicExpression,omitempty"`
	}

	type CreatePullPointSubscription struct {
		XMLName                xml.Name `xml:"tev:CreatePullPointSubscription"`
		XmlnsTev               string   `xml:"xmlns:tev,attr"`
		XmlnsWsnt              string   `xml:"xmlns:wsnt,attr"`
		Filter                 *Filter  `xml:"tev:Filter,omitempty"`
		InitialTerminationTime string   `xml:"tev:InitialTerminationTime,omitempty"`
		SubscriptionPolicy     string   `xml:"tev:SubscriptionPolicy,omitempty"`
	}

	type CreatePullPointSubscriptionResponse struct {
		XMLName               xml.Name `xml:"CreatePullPointSubscriptionResponse"`
		SubscriptionReference struct {
			Address string `xml:"Address"`
		} `xml:"SubscriptionReference"`
		CurrentTime     string `xml:"CurrentTime"`
		TerminationTime string `xml:"TerminationTime"`
	}

	req := CreatePullPointSubscription{
		XmlnsTev:  eventNamespace,
		XmlnsWsnt: "http://docs.oasis-open.org/wsn/b-2",
	}

	if filter != "" {
		req.Filter = &Filter{
			TopicExpression: filter,
		}
	}

	if initialTerminationTime != nil {
		if *initialTerminationTime <= 0 {
			return nil, ErrInvalidTerminationTime
		}
		req.InitialTerminationTime = formatDuration(*initialTerminationTime)
	}

	if subscriptionPolicy != "" {
		req.SubscriptionPolicy = subscriptionPolicy
	}

	var resp CreatePullPointSubscriptionResponse

	username, password := c.GetCredentials()
	soapClient := soap.NewClient(c.httpClient, username, password)

	if err := soapClient.Call(ctx, endpoint, "", req, &resp); err != nil {
		return nil, fmt.Errorf("CreatePullPointSubscription failed: %w", err)
	}

	subscription := &PullPointSubscription{
		SubscriptionReference: resp.SubscriptionReference.Address,
	}

	if resp.CurrentTime != "" {
		if t, err := time.Parse(time.RFC3339, resp.CurrentTime); err == nil {
			subscription.CurrentTime = t
		}
	}

	if resp.TerminationTime != "" {
		if t, err := time.Parse(time.RFC3339, resp.TerminationTime); err == nil {
			subscription.TerminationTime = t
		}
	}

	return subscription, nil
}

// PullMessages pulls notification messages from a pull point subscription.
func (c *Client) PullMessages(
	ctx context.Context,
	subscriptionReference string,
	timeout time.Duration,
	messageLimit int,
) ([]NotificationMessage, error) {
	if subscriptionReference == "" {
		return nil, ErrInvalidSubscriptionReference
	}

	if timeout <= 0 {
		return nil, ErrInvalidTimeout
	}

	if messageLimit <= 0 {
		return nil, ErrInvalidMessageLimit
	}

	type PullMessages struct {
		XMLName      xml.Name `xml:"tev:PullMessages"`
		Xmlns        string   `xml:"xmlns:tev,attr"`
		Timeout      string   `xml:"tev:Timeout"`
		MessageLimit int      `xml:"tev:MessageLimit"`
	}

	type SimpleItemXML struct {
		Name  string `xml:"Name,attr"`
		Value string `xml:"Value,attr"`
	}

	type PullMessagesResponse struct {
		XMLName              xml.Name `xml:"PullMessagesResponse"`
		CurrentTime          string   `xml:"CurrentTime"`
		TerminationTime      string   `xml:"TerminationTime"`
		NotificationMessages []struct {
			Topic struct {
				Value string `xml:",chardata"`
			} `xml:"Topic"`
			ProducerReference struct {
				Address string `xml:"Address"`
			} `xml:"ProducerReference"`
			Message struct {
				PropertyOperation string `xml:"PropertyOperation,attr"`
				UtcTime           string `xml:"UtcTime,attr"`
				Source            struct {
					SimpleItems []SimpleItemXML `xml:"SimpleItem"`
				} `xml:"Source"`
				Key struct {
					SimpleItems []SimpleItemXML `xml:"SimpleItem"`
				} `xml:"Key"`
				Data struct {
					SimpleItems []SimpleItemXML `xml:"SimpleItem"`
				} `xml:"Data"`
			} `xml:"Message"`
		} `xml:"NotificationMessage"`
	}

	req := PullMessages{
		Xmlns:        eventNamespace,
		Timeout:      formatDuration(timeout),
		MessageLimit: messageLimit,
	}

	var resp PullMessagesResponse

	username, password := c.GetCredentials()
	soapClient := soap.NewClient(c.httpClient, username, password)

	if err := soapClient.Call(ctx, subscriptionReference, "", req, &resp); err != nil {
		return nil, fmt.Errorf("PullMessages failed: %w", err)
	}

	messages := make([]NotificationMessage, len(resp.NotificationMessages))
	for i := range resp.NotificationMessages {
		nm := &resp.NotificationMessages[i]
		msg := NotificationMessage{
			Topic:           nm.Topic.Value,
			ProducerAddress: nm.ProducerReference.Address,
		}

		msg.Message.PropertyOperation = nm.Message.PropertyOperation

		if nm.Message.UtcTime != "" {
			if t, err := time.Parse(time.RFC3339, nm.Message.UtcTime); err == nil {
				msg.Message.UtcTime = t
			}
		}

		// Convert source items.
		msg.Message.Source = make([]SimpleItem, len(nm.Message.Source.SimpleItems))
		for j, item := range nm.Message.Source.SimpleItems {
			msg.Message.Source[j] = SimpleItem{Name: item.Name, Value: item.Value}
		}

		// Convert key items.
		msg.Message.Key = make([]SimpleItem, len(nm.Message.Key.SimpleItems))
		for j, item := range nm.Message.Key.SimpleItems {
			msg.Message.Key[j] = SimpleItem{Name: item.Name, Value: item.Value}
		}

		// Convert data items.
		msg.Message.Data = make([]SimpleItem, len(nm.Message.Data.SimpleItems))
		for j, item := range nm.Message.Data.SimpleItems {
			msg.Message.Data[j] = SimpleItem{Name: item.Name, Value: item.Value}
		}

		messages[i] = msg
	}

	return messages, nil
}

// Seek seeks to a specific position in the event stream.
func (c *Client) Seek(ctx context.Context, subscriptionReference string, utcTime time.Time, reverse bool) error {
	if subscriptionReference == "" {
		return ErrInvalidSubscriptionReference
	}

	type Seek struct {
		XMLName xml.Name `xml:"tev:Seek"`
		Xmlns   string   `xml:"xmlns:tev,attr"`
		UtcTime string   `xml:"tev:UtcTime"`
		Reverse bool     `xml:"tev:Reverse,omitempty"`
	}

	type SeekResponse struct {
		XMLName xml.Name `xml:"SeekResponse"`
	}

	req := Seek{
		Xmlns:   eventNamespace,
		UtcTime: utcTime.Format(time.RFC3339),
		Reverse: reverse,
	}

	var resp SeekResponse

	username, password := c.GetCredentials()
	soapClient := soap.NewClient(c.httpClient, username, password)

	if err := soapClient.Call(ctx, subscriptionReference, "", req, &resp); err != nil {
		return fmt.Errorf("Seek failed: %w", err)
	}

	return nil
}

// SetEventSynchronizationPoint instructs the device to send a synchronization point for events.
func (c *Client) SetEventSynchronizationPoint(ctx context.Context, subscriptionReference string) error {
	if subscriptionReference == "" {
		return ErrInvalidSubscriptionReference
	}

	type SetSynchronizationPoint struct {
		XMLName xml.Name `xml:"tev:SetSynchronizationPoint"`
		Xmlns   string   `xml:"xmlns:tev,attr"`
	}

	type SetSynchronizationPointResponse struct {
		XMLName xml.Name `xml:"SetSynchronizationPointResponse"`
	}

	req := SetSynchronizationPoint{
		Xmlns: eventNamespace,
	}

	var resp SetSynchronizationPointResponse

	username, password := c.GetCredentials()
	soapClient := soap.NewClient(c.httpClient, username, password)

	if err := soapClient.Call(ctx, subscriptionReference, "", req, &resp); err != nil {
		return fmt.Errorf("SetSynchronizationPoint failed: %w", err)
	}

	return nil
}

// Unsubscribe terminates a subscription.
func (c *Client) Unsubscribe(ctx context.Context, subscriptionReference string) error {
	if subscriptionReference == "" {
		return ErrInvalidSubscriptionReference
	}

	type Unsubscribe struct {
		XMLName xml.Name `xml:"wsnt:Unsubscribe"`
		Xmlns   string   `xml:"xmlns:wsnt,attr"`
	}

	type UnsubscribeResponse struct {
		XMLName xml.Name `xml:"UnsubscribeResponse"`
	}

	req := Unsubscribe{
		Xmlns: "http://docs.oasis-open.org/wsn/b-2",
	}

	var resp UnsubscribeResponse

	username, password := c.GetCredentials()
	soapClient := soap.NewClient(c.httpClient, username, password)

	if err := soapClient.Call(ctx, subscriptionReference, "", req, &resp); err != nil {
		return fmt.Errorf("Unsubscribe failed: %w", err)
	}

	return nil
}

// RenewSubscription renews a subscription with a new termination time.
func (c *Client) RenewSubscription(
	ctx context.Context,
	subscriptionReference string,
	terminationTime time.Duration,
) (time.Time, time.Time, error) {
	if subscriptionReference == "" {
		return time.Time{}, time.Time{}, ErrInvalidSubscriptionReference
	}

	if terminationTime <= 0 {
		return time.Time{}, time.Time{}, ErrInvalidTerminationTime
	}

	type Renew struct {
		XMLName         xml.Name `xml:"wsnt:Renew"`
		Xmlns           string   `xml:"xmlns:wsnt,attr"`
		TerminationTime string   `xml:"wsnt:TerminationTime"`
	}

	type RenewResponse struct {
		XMLName         xml.Name `xml:"RenewResponse"`
		CurrentTime     string   `xml:"CurrentTime"`
		TerminationTime string   `xml:"TerminationTime"`
	}

	req := Renew{
		Xmlns:           "http://docs.oasis-open.org/wsn/b-2",
		TerminationTime: formatDuration(terminationTime),
	}

	var resp RenewResponse

	username, password := c.GetCredentials()
	soapClient := soap.NewClient(c.httpClient, username, password)

	if err := soapClient.Call(ctx, subscriptionReference, "", req, &resp); err != nil {
		return time.Time{}, time.Time{}, fmt.Errorf("RenewSubscription failed: %w", err)
	}

	var currentTime, newTerminationTime time.Time

	if resp.CurrentTime != "" {
		if t, err := time.Parse(time.RFC3339, resp.CurrentTime); err == nil {
			currentTime = t
		}
	}

	if resp.TerminationTime != "" {
		if t, err := time.Parse(time.RFC3339, resp.TerminationTime); err == nil {
			newTerminationTime = t
		}
	}

	return currentTime, newTerminationTime, nil
}

// GetEventProperties retrieves the event properties of the device.
func (c *Client) GetEventProperties(ctx context.Context) (*EventProperties, error) {
	endpoint := c.getEventEndpoint()

	type GetEventProperties struct {
		XMLName xml.Name `xml:"tev:GetEventProperties"`
		Xmlns   string   `xml:"xmlns:tev,attr"`
	}

	type GetEventPropertiesResponse struct {
		XMLName                         xml.Name `xml:"GetEventPropertiesResponse"`
		TopicNamespaceLocation          []string `xml:"TopicNamespaceLocation"`
		FixedTopicSet                   bool     `xml:"FixedTopicSet"`
		TopicExpressionDialect          []string `xml:"TopicExpressionDialect"`
		MessageContentFilterDialect     []string `xml:"MessageContentFilterDialect"`
		ProducerPropertiesFilterDialect []string `xml:"ProducerPropertiesFilterDialect"`
		MessageContentSchemaLocation    []string `xml:"MessageContentSchemaLocation"`
	}

	req := GetEventProperties{
		Xmlns: eventNamespace,
	}

	var resp GetEventPropertiesResponse

	username, password := c.GetCredentials()
	soapClient := soap.NewClient(c.httpClient, username, password)

	if err := soapClient.Call(ctx, endpoint, "", req, &resp); err != nil {
		return nil, fmt.Errorf("GetEventProperties failed: %w", err)
	}

	properties := &EventProperties{
		TopicNamespaceLocation:           resp.TopicNamespaceLocation,
		FixedTopicSet:                    resp.FixedTopicSet,
		TopicExpressionDialects:          resp.TopicExpressionDialect,
		MessageContentFilterDialects:     resp.MessageContentFilterDialect,
		ProducerPropertiesFilterDialects: resp.ProducerPropertiesFilterDialect,
		MessageContentSchemaLocation:     resp.MessageContentSchemaLocation,
	}

	return properties, nil
}

// AddEventBroker adds an event broker configuration.
func (c *Client) AddEventBroker(ctx context.Context, config *EventBrokerConfig) error {
	if config == nil {
		return ErrEventBrokerConfigNil
	}

	if config.Address == "" {
		return ErrInvalidEventBrokerAddress
	}

	endpoint := c.getEventEndpoint()

	type EventBrokerConfigXML struct {
		Address            string `xml:"tev:Address"`
		TopicPrefix        string `xml:"tev:TopicPrefix,omitempty"`
		UserName           string `xml:"tev:UserName,omitempty"`
		Password           string `xml:"tev:Password,omitempty"`
		CertificateID      string `xml:"tev:CertificateID,omitempty"`
		PublishFilter      string `xml:"tev:PublishFilter,omitempty"`
		QoS                int    `xml:"tev:QoS,omitempty"`
		CertPathValidation bool   `xml:"tev:CertPathValidation,omitempty"`
		MetadataFilter     string `xml:"tev:MetadataFilter,omitempty"`
	}

	type AddEventBroker struct {
		XMLName           xml.Name             `xml:"tev:AddEventBroker"`
		Xmlns             string               `xml:"xmlns:tev,attr"`
		EventBrokerConfig EventBrokerConfigXML `xml:"tev:EventBrokerConfig"`
	}

	type AddEventBrokerResponse struct {
		XMLName xml.Name `xml:"AddEventBrokerResponse"`
	}

	req := AddEventBroker{
		Xmlns: eventNamespace,
		EventBrokerConfig: EventBrokerConfigXML{
			Address:            config.Address,
			TopicPrefix:        config.TopicPrefix,
			UserName:           config.UserName,
			Password:           config.Password,
			CertificateID:      config.CertificateID,
			PublishFilter:      config.PublishFilter,
			QoS:                config.QoS,
			CertPathValidation: config.CertPathValidation,
			MetadataFilter:     config.MetadataFilter,
		},
	}

	var resp AddEventBrokerResponse

	username, password := c.GetCredentials()
	soapClient := soap.NewClient(c.httpClient, username, password)

	if err := soapClient.Call(ctx, endpoint, "", req, &resp); err != nil {
		return fmt.Errorf("AddEventBroker failed: %w", err)
	}

	return nil
}

// DeleteEventBroker deletes an event broker configuration.
func (c *Client) DeleteEventBroker(ctx context.Context, address string) error {
	if address == "" {
		return ErrInvalidEventBrokerAddress
	}

	endpoint := c.getEventEndpoint()

	type DeleteEventBroker struct {
		XMLName xml.Name `xml:"tev:DeleteEventBroker"`
		Xmlns   string   `xml:"xmlns:tev,attr"`
		Address string   `xml:"tev:Address"`
	}

	type DeleteEventBrokerResponse struct {
		XMLName xml.Name `xml:"DeleteEventBrokerResponse"`
	}

	req := DeleteEventBroker{
		Xmlns:   eventNamespace,
		Address: address,
	}

	var resp DeleteEventBrokerResponse

	username, password := c.GetCredentials()
	soapClient := soap.NewClient(c.httpClient, username, password)

	if err := soapClient.Call(ctx, endpoint, "", req, &resp); err != nil {
		return fmt.Errorf("DeleteEventBroker failed: %w", err)
	}

	return nil
}

// GetEventBrokers retrieves all event broker configurations.
func (c *Client) GetEventBrokers(ctx context.Context) ([]*EventBrokerConfig, error) {
	endpoint := c.getEventEndpoint()

	type GetEventBrokers struct {
		XMLName xml.Name `xml:"tev:GetEventBrokers"`
		Xmlns   string   `xml:"xmlns:tev,attr"`
	}

	type GetEventBrokersResponse struct {
		XMLName      xml.Name `xml:"GetEventBrokersResponse"`
		EventBrokers []struct {
			Address            string `xml:"Address"`
			TopicPrefix        string `xml:"TopicPrefix"`
			UserName           string `xml:"UserName"`
			Password           string `xml:"Password"`
			CertificateID      string `xml:"CertificateID"`
			PublishFilter      string `xml:"PublishFilter"`
			QoS                int    `xml:"QoS"`
			Status             string `xml:"Status"`
			CertPathValidation bool   `xml:"CertPathValidation"`
			MetadataFilter     string `xml:"MetadataFilter"`
		} `xml:"EventBroker"`
	}

	req := GetEventBrokers{
		Xmlns: eventNamespace,
	}

	var resp GetEventBrokersResponse

	username, password := c.GetCredentials()
	soapClient := soap.NewClient(c.httpClient, username, password)

	if err := soapClient.Call(ctx, endpoint, "", req, &resp); err != nil {
		return nil, fmt.Errorf("GetEventBrokers failed: %w", err)
	}

	brokers := make([]*EventBrokerConfig, len(resp.EventBrokers))
	for i := range resp.EventBrokers {
		eb := &resp.EventBrokers[i]
		brokers[i] = &EventBrokerConfig{
			Address:            eb.Address,
			TopicPrefix:        eb.TopicPrefix,
			UserName:           eb.UserName,
			Password:           eb.Password,
			CertificateID:      eb.CertificateID,
			PublishFilter:      eb.PublishFilter,
			QoS:                eb.QoS,
			Status:             eb.Status,
			CertPathValidation: eb.CertPathValidation,
			MetadataFilter:     eb.MetadataFilter,
		}
	}

	return brokers, nil
}

// formatDuration formats a duration as an ISO 8601 duration string.
func formatDuration(d time.Duration) string {
	seconds := int(d.Seconds())
	if seconds < 60 { //nolint:mnd // 60 seconds in a minute
		return fmt.Sprintf("PT%dS", seconds)
	}

	minutes := seconds / 60 //nolint:mnd // 60 seconds in a minute
	seconds %= 60

	if seconds == 0 {
		return fmt.Sprintf("PT%dM", minutes)
	}

	return fmt.Sprintf("PT%dM%dS", minutes, seconds)
}

// splitSpaceSeparated splits a space-separated string into a slice.
func splitSpaceSeparated(s string) []string {
	if s == "" {
		return nil
	}

	return strings.Fields(s)
}