package noop

import (
	"context"
	"fmt"

	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
	"gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline"
)

const Key = "noop"

var _ contracts.Normalizer = (*Normalizer)(nil)

type Normalizer struct{}

func New() *Normalizer {
	return &Normalizer{}
}

func (n *Normalizer) Key() string {
	return Key
}

func (n *Normalizer) ReferenceSlots() []contracts.ReferenceSlot {
	return nil
}

func (n *Normalizer) Normalize(ctx context.Context, req contracts.NormalizeRequest) (contracts.NormalizeResult, error) {
	if n == nil {
		return contracts.NormalizeResult{}, normalizerErrorf("normalizer must not be nil")
	}
	if ctx == nil {
		return contracts.NormalizeResult{}, normalizerErrorf("context must not be nil")
	}
	if err := ctx.Err(); err != nil {
		return contracts.NormalizeResult{}, normalizerErrorf("context error before normalize: %w", err)
	}
	return contracts.NormalizeResult{
		Output: contracts.NormalizeOutput{
			LaneID:        req.LaneID,
			NormalizerKey: Key,
			SourceID:      req.MergeOutput.SourceID,
			Schema:        req.MergeOutput.Schema,
			Payload:       cloneRawPayload(req.MergeOutput.Payload),
		},
	}, nil
}

func ModuleSpec() pipeline.ModuleSpec {
	return pipeline.ModuleSpec{
		Key:      Key,
		Stage:    pipeline.StageNormalize,
		Requires: []string{"merged"},
		Provides: []string{"normalized"},
	}
}

func Register(registry *pipeline.NormalizerRegistry) error {
	return registry.RegisterWithSpec(ModuleSpec(), func() (contracts.Normalizer, error) {
		return New(), nil
	})
}

func cloneRawPayload(payload contracts.RawPayload) contracts.RawPayload {
	return contracts.RawPayload{
		Content:   append([]byte(nil), payload.Content...),
		MediaType: payload.MediaType,
		Metadata:  cloneMetadata(payload.Metadata),
		Warnings:  append([]contracts.Warning(nil), payload.Warnings...),
	}
}

func cloneMetadata(metadata map[string]any) map[string]any {
	if len(metadata) == 0 {
		return nil
	}
	out := make(map[string]any, len(metadata))
	for key, value := range metadata {
		out[key] = value
	}
	return out
}

func normalizerErrorf(format string, args ...any) error {
	return fmt.Errorf("noop normalizer: "+format, args...)
}