// Package domainevents implements Redis Stream-backed auxiliary user-domain
// event publishers.
package domainevents

import (
	"context"
	"errors"
	"fmt"
	"strconv"
	"strings"
	"time"

	"galaxy/user/internal/ports"

	"github.com/redis/go-redis/v9"
	"go.opentelemetry.io/otel/trace"
)

// Config configures one Redis-backed user domain-event publisher. The
// connection is supplied externally by the runtime so multiple publishers
// can share one *redis.Client; this struct now carries only stream-shape
// parameters.
type Config struct {
	// Stream identifies the Redis Stream key used for domain events.
	Stream string

	// StreamMaxLen bounds the stream with approximate trimming via
	// `XADD MAXLEN ~`.
	StreamMaxLen int64

	// OperationTimeout bounds each Redis round trip performed by the adapter.
	OperationTimeout time.Duration
}

// Publisher publishes auxiliary user-domain events into one Redis Stream.
type Publisher struct {
	client           *redis.Client
	stream           string
	streamMaxLen     int64
	operationTimeout time.Duration
}

// New constructs a Redis-backed domain-event publisher backed by the
// supplied client. The publisher does not own the client; the runtime is
// responsible for closing it.
func New(client *redis.Client, cfg Config) (*Publisher, error) {
	switch {
	case client == nil:
		return nil, errors.New("new redis domain-event publisher: redis client must not be nil")
	case strings.TrimSpace(cfg.Stream) == "":
		return nil, errors.New("new redis domain-event publisher: stream must not be empty")
	case cfg.StreamMaxLen <= 0:
		return nil, errors.New("new redis domain-event publisher: stream max len must be positive")
	case cfg.OperationTimeout <= 0:
		return nil, errors.New("new redis domain-event publisher: operation timeout must be positive")
	}

	return &Publisher{
		client:           client,
		stream:           cfg.Stream,
		streamMaxLen:     cfg.StreamMaxLen,
		operationTimeout: cfg.OperationTimeout,
	}, nil
}

// Close is a no-op: the client is owned by the runtime, not the publisher.
// The accessor remains for API symmetry with the previous Redis adapter so
// runtime cleanup chains do not need to special-case this surface.
func (publisher *Publisher) Close() error {
	return nil
}

// Ping verifies that the configured Redis backend is reachable within the
// adapter operation timeout budget.
func (publisher *Publisher) Ping(ctx context.Context) error {
	operationCtx, cancel, err := publisher.operationContext(ctx, "ping redis domain-event publisher")
	if err != nil {
		return err
	}
	defer cancel()

	if err := publisher.client.Ping(operationCtx).Err(); err != nil {
		return fmt.Errorf("ping redis domain-event publisher: %w", err)
	}

	return nil
}

// PublishProfileChanged publishes one committed profile-change event.
func (publisher *Publisher) PublishProfileChanged(ctx context.Context, event ports.ProfileChangedEvent) error {
	if err := event.Validate(); err != nil {
		return fmt.Errorf("publish profile changed event: %w", err)
	}

	values := buildEnvelope(ports.ProfileChangedEventType, event.UserID.String(), event.OccurredAt, event.Source.String(), traceIDFromContext(ctx, event.TraceID))
	values["operation"] = string(event.Operation)
	values["user_name"] = event.UserName.String()
	if !event.DisplayName.IsZero() {
		values["display_name"] = event.DisplayName.String()
	}

	return publisher.publish(ctx, "publish profile changed event", values)
}

// PublishSettingsChanged publishes one committed settings-change event.
func (publisher *Publisher) PublishSettingsChanged(ctx context.Context, event ports.SettingsChangedEvent) error {
	if err := event.Validate(); err != nil {
		return fmt.Errorf("publish settings changed event: %w", err)
	}

	values := buildEnvelope(ports.SettingsChangedEventType, event.UserID.String(), event.OccurredAt, event.Source.String(), traceIDFromContext(ctx, event.TraceID))
	values["operation"] = string(event.Operation)
	values["preferred_language"] = event.PreferredLanguage.String()
	values["time_zone"] = event.TimeZone.String()

	return publisher.publish(ctx, "publish settings changed event", values)
}

// PublishEntitlementChanged publishes one committed entitlement-change event.
func (publisher *Publisher) PublishEntitlementChanged(ctx context.Context, event ports.EntitlementChangedEvent) error {
	if err := event.Validate(); err != nil {
		return fmt.Errorf("publish entitlement changed event: %w", err)
	}

	values := buildEnvelope(ports.EntitlementChangedEventType, event.UserID.String(), event.OccurredAt, event.Source.String(), traceIDFromContext(ctx, event.TraceID))
	values["operation"] = string(event.Operation)
	values["plan_code"] = string(event.PlanCode)
	values["is_paid"] = strconv.FormatBool(event.IsPaid)
	values["starts_at_ms"] = strconv.FormatInt(event.StartsAt.UTC().UnixMilli(), 10)
	values["reason_code"] = event.ReasonCode.String()
	values["actor_type"] = event.Actor.Type.String()
	values["updated_at_ms"] = strconv.FormatInt(event.UpdatedAt.UTC().UnixMilli(), 10)
	if !event.Actor.ID.IsZero() {
		values["actor_id"] = event.Actor.ID.String()
	}
	if event.EndsAt != nil {
		values["ends_at_ms"] = strconv.FormatInt(event.EndsAt.UTC().UnixMilli(), 10)
	}

	return publisher.publish(ctx, "publish entitlement changed event", values)
}

// PublishSanctionChanged publishes one committed sanction-change event.
func (publisher *Publisher) PublishSanctionChanged(ctx context.Context, event ports.SanctionChangedEvent) error {
	if err := event.Validate(); err != nil {
		return fmt.Errorf("publish sanction changed event: %w", err)
	}

	values := buildEnvelope(ports.SanctionChangedEventType, event.UserID.String(), event.OccurredAt, event.Source.String(), traceIDFromContext(ctx, event.TraceID))
	values["operation"] = string(event.Operation)
	values["sanction_code"] = string(event.SanctionCode)
	values["scope"] = event.Scope.String()
	values["reason_code"] = event.ReasonCode.String()
	values["actor_type"] = event.Actor.Type.String()
	values["applied_at_ms"] = strconv.FormatInt(event.AppliedAt.UTC().UnixMilli(), 10)
	if !event.Actor.ID.IsZero() {
		values["actor_id"] = event.Actor.ID.String()
	}
	if event.ExpiresAt != nil {
		values["expires_at_ms"] = strconv.FormatInt(event.ExpiresAt.UTC().UnixMilli(), 10)
	}
	if event.RemovedAt != nil {
		values["removed_at_ms"] = strconv.FormatInt(event.RemovedAt.UTC().UnixMilli(), 10)
	}

	return publisher.publish(ctx, "publish sanction changed event", values)
}

// PublishLimitChanged publishes one committed limit-change event.
func (publisher *Publisher) PublishLimitChanged(ctx context.Context, event ports.LimitChangedEvent) error {
	if err := event.Validate(); err != nil {
		return fmt.Errorf("publish limit changed event: %w", err)
	}

	values := buildEnvelope(ports.LimitChangedEventType, event.UserID.String(), event.OccurredAt, event.Source.String(), traceIDFromContext(ctx, event.TraceID))
	values["operation"] = string(event.Operation)
	values["limit_code"] = string(event.LimitCode)
	values["reason_code"] = event.ReasonCode.String()
	values["actor_type"] = event.Actor.Type.String()
	values["applied_at_ms"] = strconv.FormatInt(event.AppliedAt.UTC().UnixMilli(), 10)
	if event.Value != nil {
		values["value"] = strconv.Itoa(*event.Value)
	}
	if !event.Actor.ID.IsZero() {
		values["actor_id"] = event.Actor.ID.String()
	}
	if event.ExpiresAt != nil {
		values["expires_at_ms"] = strconv.FormatInt(event.ExpiresAt.UTC().UnixMilli(), 10)
	}
	if event.RemovedAt != nil {
		values["removed_at_ms"] = strconv.FormatInt(event.RemovedAt.UTC().UnixMilli(), 10)
	}

	return publisher.publish(ctx, "publish limit changed event", values)
}

// PublishDeclaredCountryChanged publishes one committed declared-country change
// event.
func (publisher *Publisher) PublishDeclaredCountryChanged(ctx context.Context, event ports.DeclaredCountryChangedEvent) error {
	if err := event.Validate(); err != nil {
		return fmt.Errorf("publish declared-country changed event: %w", err)
	}

	values := buildEnvelope(
		ports.DeclaredCountryChangedEventType,
		event.UserID.String(),
		event.UpdatedAt,
		event.Source.String(),
		traceIDFromContext(ctx, event.TraceID),
	)
	values["declared_country"] = event.DeclaredCountry.String()
	values["updated_at_ms"] = strconv.FormatInt(event.UpdatedAt.UTC().UnixMilli(), 10)

	return publisher.publish(ctx, "publish declared-country changed event", values)
}

func (publisher *Publisher) publish(ctx context.Context, operation string, values map[string]any) error {
	operationCtx, cancel, err := publisher.operationContext(ctx, operation)
	if err != nil {
		return err
	}
	defer cancel()

	if err := publisher.client.XAdd(operationCtx, &redis.XAddArgs{
		Stream: publisher.stream,
		MaxLen: publisher.streamMaxLen,
		Approx: true,
		Values: values,
	}).Err(); err != nil {
		return fmt.Errorf("%s: %w", operation, err)
	}

	return nil
}

func (publisher *Publisher) operationContext(ctx context.Context, operation string) (context.Context, context.CancelFunc, error) {
	if publisher == nil || publisher.client == nil {
		return nil, nil, fmt.Errorf("%s: nil publisher", operation)
	}
	if ctx == nil {
		return nil, nil, fmt.Errorf("%s: nil context", operation)
	}

	operationCtx, cancel := context.WithTimeout(ctx, publisher.operationTimeout)
	return operationCtx, cancel, nil
}

func buildEnvelope(eventType string, userID string, occurredAt time.Time, source string, traceID string) map[string]any {
	values := map[string]any{
		"event_type":     eventType,
		"user_id":        userID,
		"occurred_at_ms": strconv.FormatInt(occurredAt.UTC().UnixMilli(), 10),
		"source":         source,
	}
	if traceID != "" {
		values["trace_id"] = traceID
	}

	return values
}

func traceIDFromContext(ctx context.Context, fallback string) string {
	if strings.TrimSpace(fallback) != "" {
		return fallback
	}
	if ctx == nil {
		return ""
	}

	spanContext := trace.SpanContextFromContext(ctx)
	if !spanContext.IsValid() {
		return ""
	}

	return spanContext.TraceID().String()
}

var (
	_ interface{ Close() error }               = (*Publisher)(nil)
	_ interface{ Ping(context.Context) error } = (*Publisher)(nil)
	_ ports.ProfileChangedPublisher            = (*Publisher)(nil)
	_ ports.SettingsChangedPublisher           = (*Publisher)(nil)
	_ ports.EntitlementChangedPublisher        = (*Publisher)(nil)
	_ ports.SanctionChangedPublisher           = (*Publisher)(nil)
	_ ports.LimitChangedPublisher              = (*Publisher)(nil)
	_ ports.DeclaredCountryChangedPublisher    = (*Publisher)(nil)
)