package protocol

import "fmt"

// BuildDescriptor returns a validated descriptor publication with its delivery
// rules.
func BuildDescriptor(deviceID string, metadata Metadata, payload DescriptorPayload) (Publication, error) {
	return buildMessage(Address{
		Kind: Descriptor,
		ID:   deviceID,
	}, metadata, payload)
}

// ParseDescriptor validates its topic, envelope, payload, and delivery
// retention.
func ParseDescriptor(topic string, data []byte, retained bool) (Message[DescriptorPayload], error) {
	message, err := parseMessage[DescriptorPayload](Descriptor, topic, data, retained)
	if err != nil {
		return Message[DescriptorPayload]{}, fmt.Errorf("parse descriptor: %w", err)
	}

	return message, nil
}

// BuildAvailability returns a validated availability publication with its
// delivery rules.
func BuildAvailability(deviceID string, metadata Metadata, payload AvailabilityPayload) (Publication, error) {
	return buildMessage(Address{
		Kind: Availability,
		ID:   deviceID,
	}, metadata, payload)
}

// ParseAvailability validates its topic, envelope, payload, and delivery
// retention.
func ParseAvailability(topic string, data []byte, retained bool) (Message[AvailabilityPayload], error) {
	message, err := parseMessage[AvailabilityPayload](Availability, topic, data, retained)
	if err != nil {
		return Message[AvailabilityPayload]{}, fmt.Errorf("parse availability: %w", err)
	}

	return message, nil
}

// BuildReported returns a validated reported publication with its delivery
// rules.
func BuildReported(deviceID string, capability string, metadata Metadata, payload ValuePayload) (Publication, error) {
	return buildMessage(Address{
		Kind:   Reported,
		ID:     deviceID,
		Target: capability,
	}, metadata, payload)
}

// ParseReported validates its topic, envelope, payload, and delivery retention.
func ParseReported(topic string, data []byte, retained bool) (Message[ValuePayload], error) {
	message, err := parseMessage[ValuePayload](Reported, topic, data, retained)
	if err != nil {
		return Message[ValuePayload]{}, fmt.Errorf("parse reported: %w", err)
	}

	return message, nil
}

// BuildTelemetry returns a validated telemetry publication with its delivery
// rules.
func BuildTelemetry(deviceID string, capability string, metadata Metadata, payload ValuePayload) (Publication, error) {
	return buildMessage(Address{
		Kind:   Telemetry,
		ID:     deviceID,
		Target: capability,
	}, metadata, payload)
}

// ParseTelemetry validates its topic, envelope, payload, and delivery
// retention.
func ParseTelemetry(topic string, data []byte, retained bool) (Message[ValuePayload], error) {
	message, err := parseMessage[ValuePayload](Telemetry, topic, data, retained)
	if err != nil {
		return Message[ValuePayload]{}, fmt.Errorf("parse telemetry: %w", err)
	}

	return message, nil
}

// BuildEvent returns a validated event publication with its delivery rules.
func BuildEvent(deviceID string, event string, metadata Metadata, payload EventPayload) (Publication, error) {
	return buildMessage(Address{
		Kind:   Event,
		ID:     deviceID,
		Target: event,
	}, metadata, payload)
}

// ParseEvent validates its topic, envelope, payload, and delivery retention.
func ParseEvent(topic string, data []byte, retained bool) (Message[EventPayload], error) {
	message, err := parseMessage[EventPayload](Event, topic, data, retained)
	if err != nil {
		return Message[EventPayload]{}, fmt.Errorf("parse event: %w", err)
	}

	return message, nil
}

// BuildCommand returns a validated command publication with its delivery rules.
func BuildCommand(deviceID string, capability string, metadata Metadata, payload ValuePayload) (Publication, error) {
	return buildMessage(Address{
		Kind:   Command,
		ID:     deviceID,
		Target: capability,
	}, metadata, payload)
}

// ParseCommand validates its topic, envelope, payload, and delivery retention.
func ParseCommand(topic string, data []byte, retained bool) (Message[ValuePayload], error) {
	message, err := parseMessage[ValuePayload](Command, topic, data, retained)
	if err != nil {
		return Message[ValuePayload]{}, fmt.Errorf("parse command: %w", err)
	}

	return message, nil
}

// BuildCommandBatch returns a validated command batch publication with its
// delivery rules.
func BuildCommandBatch(deviceID string, metadata Metadata, payload BatchPayload) (Publication, error) {
	return buildMessage(Address{
		Kind: CommandBatch,
		ID:   deviceID,
	}, metadata, payload)
}

// ParseCommandBatch validates its topic, envelope, payload, and delivery
// retention.
func ParseCommandBatch(topic string, data []byte, retained bool) (Message[BatchPayload], error) {
	message, err := parseMessage[BatchPayload](CommandBatch, topic, data, retained)
	if err != nil {
		return Message[BatchPayload]{}, fmt.Errorf("parse command batch: %w", err)
	}

	return message, nil
}

// BuildResult returns a validated result publication with its delivery rules.
func BuildResult(deviceID string, commandID string, metadata Metadata, payload ResultPayload) (Publication, error) {
	return buildMessage(Address{
		Kind:   Result,
		ID:     deviceID,
		Target: commandID,
	}, metadata, payload)
}

// ParseResult validates its topic, envelope, payload, and delivery retention.
func ParseResult(topic string, data []byte, retained bool) (Message[ResultPayload], error) {
	message, err := parseMessage[ResultPayload](Result, topic, data, retained)
	if err != nil {
		return Message[ResultPayload]{}, fmt.Errorf("parse result: %w", err)
	}

	return message, nil
}

// BuildHubStatus returns a validated hub status publication with its delivery
// rules.
func BuildHubStatus(hubID string, metadata Metadata, payload HubStatusPayload) (Publication, error) {
	return buildMessage(Address{
		Kind: HubStatus,
		ID:   hubID,
	}, metadata, payload)
}

// ParseHubStatus validates its topic, envelope, payload, and delivery
// retention.
func ParseHubStatus(topic string, data []byte, retained bool) (Message[HubStatusPayload], error) {
	message, err := parseMessage[HubStatusPayload](HubStatus, topic, data, retained)
	if err != nil {
		return Message[HubStatusPayload]{}, fmt.Errorf("parse hub status: %w", err)
	}

	return message, nil
}