package state

import (
	"fmt"

	"gitea.maximumdirect.net/eric/distributor/internal/bundle"
	"gitea.maximumdirect.net/eric/distributor/internal/storage"
)

const (
	OutputKindSource    = "source"
	OutputKindGenerated = "generated"
)

func Validate(s DistributorState) error {
	if s.SchemaVersion != SchemaVersion {
		return fmt.Errorf("state schema_version must be %d", SchemaVersion)
	}
	if s.PipelineID == "" {
		return fmt.Errorf("state pipeline_id is required")
	}
	if s.DestinationID == "" {
		return fmt.Errorf("state destination_id is required")
	}
	if s.PublishedAt.IsZero() {
		return fmt.Errorf("state published_at is required")
	}
	if err := validateEmbeddedManifest(s.Source.Manifest); err != nil {
		return fmt.Errorf("state source.manifest: %w", err)
	}
	if s.Outputs == nil {
		return fmt.Errorf("state outputs is required")
	}
	seen := make(map[string]struct{}, len(s.Outputs))
	for index, output := range s.Outputs {
		if err := validateOutput(index, output); err != nil {
			return err
		}
		if _, exists := seen[output.Path]; exists {
			return fmt.Errorf("state outputs[%d].path duplicates %q", index, output.Path)
		}
		seen[output.Path] = struct{}{}
	}
	return nil
}

func validateEmbeddedManifest(manifest bundle.Manifest) error {
	if manifest.SchemaVersion != 1 {
		return fmt.Errorf("schema_version must be 1")
	}
	if manifest.ID == "" {
		return fmt.Errorf("id is required")
	}
	if err := bundle.ValidateDigest(manifest.Digest); err != nil {
		return fmt.Errorf("digest: %w", err)
	}
	if manifest.Created.IsZero() {
		return fmt.Errorf("created is required")
	}
	if len(manifest.Files) == 0 {
		return fmt.Errorf("files is required")
	}
	seen := make(map[string]struct{}, len(manifest.Files))
	for index, file := range manifest.Files {
		if err := bundle.ValidateSourcePath(file.Path); err != nil {
			return fmt.Errorf("files[%d].path: %w", index, err)
		}
		if err := bundle.ValidateDigest(file.SHA256); err != nil {
			return fmt.Errorf("files[%d].sha256: %w", index, err)
		}
		if file.Size < 0 {
			return fmt.Errorf("files[%d].size must be non-negative", index)
		}
		if _, exists := seen[file.Path]; exists {
			return fmt.Errorf("files[%d].path duplicates %q", index, file.Path)
		}
		seen[file.Path] = struct{}{}
	}
	if actual := bundle.BundleDigest(manifest.Files); actual != manifest.Digest {
		return fmt.Errorf("digest mismatch: got %s want %s", actual, manifest.Digest)
	}
	return nil
}

func validateOutput(index int, output OutputFile) error {
	if err := storage.ValidatePath(output.Path); err != nil {
		return fmt.Errorf("state outputs[%d].path: %w", index, err)
	}
	switch output.Kind {
	case OutputKindSource, OutputKindGenerated:
	default:
		return fmt.Errorf("state outputs[%d].kind must be source or generated", index)
	}
	if err := storage.ValidatePath(output.SourcePath); err != nil {
		return fmt.Errorf("state outputs[%d].source_path: %w", index, err)
	}
	if output.Kind == OutputKindGenerated && output.Transform == "" {
		return fmt.Errorf("state outputs[%d].transform is required for generated output", index)
	}
	if err := bundle.ValidateDigest(output.SHA256); err != nil {
		return fmt.Errorf("state outputs[%d].sha256: %w", index, err)
	}
	if output.Size < 0 {
		return fmt.Errorf("state outputs[%d].size must be non-negative", index)
	}
	return nil
}