manifest.go

package farp

import (
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"slices"
	"sort"
	"strings"
	"time"
)

// NewManifest creates a new schema manifest with default values.
func NewManifest(serviceName, serviceVersion, instanceID string) *SchemaManifest {
	return &SchemaManifest{
		Version:        ProtocolVersion,
		ServiceName:    serviceName,
		ServiceVersion: serviceVersion,
		InstanceID:     instanceID,
		Schemas:        []SchemaDescriptor{},
		Capabilities:   []string{},
		Endpoints:      SchemaEndpoints{},
		Routing: RoutingConfig{
			Strategy: MountStrategyService, // Default strategy
		},
		Auth:      AuthConfig{},
		Webhook:   WebhookConfig{},
		UpdatedAt: time.Now().Unix(),
	}
}

// AddSchema adds a schema descriptor to the manifest.
func (m *SchemaManifest) AddSchema(descriptor SchemaDescriptor) {
	m.Schemas = append(m.Schemas, descriptor)
}

// AddCapability adds a capability to the manifest.
func (m *SchemaManifest) AddCapability(capability string) {
	// Check if capability already exists
	if slices.Contains(m.Capabilities, capability) {
		return
	}

	m.Capabilities = append(m.Capabilities, capability)
}

// UpdateChecksum recalculates the manifest checksum based on all schema hashes.
func (m *SchemaManifest) UpdateChecksum() error {
	checksum, err := CalculateManifestChecksum(m)
	if err != nil {
		return fmt.Errorf("failed to calculate manifest checksum: %w", err)
	}

	m.Checksum = checksum
	m.UpdatedAt = time.Now().Unix()

	return nil
}

// Validate validates the manifest for correctness.
func (m *SchemaManifest) Validate() error {
	// Check protocol version compatibility
	if !IsCompatible(m.Version) {
		return fmt.Errorf("%w: manifest version %s, protocol version %s",
			ErrIncompatibleVersion, m.Version, ProtocolVersion)
	}

	// Check required fields
	if m.ServiceName == "" {
		return &ValidationError{Field: "service_name", Message: "service name is required"}
	}

	if m.InstanceID == "" {
		return &ValidationError{Field: "instance_id", Message: "instance ID is required"}
	}

	// Validate health endpoint
	if m.Endpoints.Health == "" {
		return &ValidationError{Field: "endpoints.health", Message: "health endpoint is required"}
	}

	// Validate instance metadata if present
	if m.Instance != nil {
		err := ValidateInstanceMetadata(m.Instance)
		if err != nil {
			return fmt.Errorf("invalid instance metadata: %w", err)
		}
	}

	// Validate routing configuration
	err := ValidateRoutingConfig(&m.Routing)
	if err != nil {
		return fmt.Errorf("invalid routing config: %w", err)
	}

	// Validate each schema descriptor
	for i, schema := range m.Schemas {
		err := ValidateSchemaDescriptor(&schema)
		if err != nil {
			return fmt.Errorf("invalid schema at index %d: %w", i, err)
		}
	}

	// Verify checksum if present
	if m.Checksum != "" {
		expectedChecksum, err := CalculateManifestChecksum(m)
		if err != nil {
			return fmt.Errorf("failed to verify checksum: %w", err)
		}

		if m.Checksum != expectedChecksum {
			return fmt.Errorf("%w: expected %s, got %s", ErrChecksumMismatch, expectedChecksum, m.Checksum)
		}
	}

	return nil
}

// ValidateInstanceMetadata validates instance metadata.
func ValidateInstanceMetadata(im *InstanceMetadata) error {
	// Address is required
	if im.Address == "" {
		return &ValidationError{Field: "address", Message: "instance address is required"}
	}

	// Weight should be 0-100
	if im.Weight < 0 || im.Weight > 100 {
		return &ValidationError{Field: "weight", Message: "instance weight must be between 0 and 100"}
	}

	// Validate deployment metadata if present
	if im.Deployment != nil {
		if im.Deployment.DeploymentID == "" {
			return &ValidationError{Field: "deployment.deployment_id", Message: "deployment ID is required"}
		}

		if im.Deployment.TrafficPercent < 0 || im.Deployment.TrafficPercent > 100 {
			return &ValidationError{Field: "deployment.traffic_percent", Message: "traffic percent must be between 0 and 100"}
		}
	}

	return nil
}

// ValidateRoutingConfig validates routing configuration.
func ValidateRoutingConfig(rc *RoutingConfig) error {
	// Validate mount strategy
	if rc.Strategy != "" && !rc.Strategy.IsValid() {
		return &ValidationError{Field: "routing.strategy", Message: fmt.Sprintf("invalid mount strategy: %s", rc.Strategy)}
	}

	// Custom strategy requires base path
	if rc.Strategy == MountStrategyCustom && rc.BasePath == "" {
		return &ValidationError{Field: "routing.base_path", Message: "base path is required for custom mount strategy"}
	}

	// Subdomain strategy requires subdomain
	if rc.Strategy == MountStrategySubdomain && rc.Subdomain == "" {
		return &ValidationError{Field: "routing.subdomain", Message: "subdomain is required for subdomain mount strategy"}
	}

	// Priority should be 0-100
	if rc.Priority < 0 || rc.Priority > 100 {
		return &ValidationError{Field: "routing.priority", Message: "routing priority must be between 0 and 100"}
	}

	return nil
}

// GetSchema retrieves a schema descriptor by type.
func (m *SchemaManifest) GetSchema(schemaType SchemaType) (*SchemaDescriptor, bool) {
	for i := range m.Schemas {
		if m.Schemas[i].Type == schemaType {
			return &m.Schemas[i], true
		}
	}

	return nil, false
}

// HasCapability checks if the manifest includes a specific capability.
func (m *SchemaManifest) HasCapability(capability string) bool {
	return slices.Contains(m.Capabilities, capability)
}

// Clone creates a deep copy of the manifest.
func (m *SchemaManifest) Clone() *SchemaManifest {
	clone := &SchemaManifest{
		Version:        m.Version,
		ServiceName:    m.ServiceName,
		ServiceVersion: m.ServiceVersion,
		InstanceID:     m.InstanceID,
		Schemas:        make([]SchemaDescriptor, len(m.Schemas)),
		Capabilities:   make([]string, len(m.Capabilities)),
		Endpoints:      m.Endpoints,
		Routing:        m.Routing,
		UpdatedAt:      m.UpdatedAt,
		Checksum:       m.Checksum,
		RoutesChecksum: m.RoutesChecksum,
	}

	copy(clone.Schemas, m.Schemas)
	copy(clone.Capabilities, m.Capabilities)

	if len(m.RouteTable) > 0 {
		clone.RouteTable = make([]RouteDescriptor, len(m.RouteTable))
		copy(clone.RouteTable, m.RouteTable)
	}

	return clone
}

// ToJSON serializes the manifest to JSON.
func (m *SchemaManifest) ToJSON() ([]byte, error) {
	return json.Marshal(m)
}

// ToPrettyJSON serializes the manifest to pretty-printed JSON.
func (m *SchemaManifest) ToPrettyJSON() ([]byte, error) {
	return json.MarshalIndent(m, "", "  ")
}

// FromJSON deserializes a manifest from JSON.
func FromJSON(data []byte) (*SchemaManifest, error) {
	var manifest SchemaManifest

	err := json.Unmarshal(data, &manifest)
	if err != nil {
		return nil, fmt.Errorf("%w: %w", ErrInvalidManifest, err)
	}

	return &manifest, nil
}

// ValidateSchemaDescriptor validates a schema descriptor.
func ValidateSchemaDescriptor(sd *SchemaDescriptor) error {
	// Check schema type
	if !sd.Type.IsValid() {
		return fmt.Errorf("%w: %s", ErrUnsupportedType, sd.Type)
	}

	// Check spec version
	if sd.SpecVersion == "" {
		return &ValidationError{Field: "spec_version", Message: "spec version is required"}
	}

	// Validate location
	err := sd.Location.Validate()
	if err != nil {
		return err
	}

	// For inline schemas, InlineSchema must be present
	if sd.Location.Type == LocationTypeInline && sd.InlineSchema == nil {
		return &ValidationError{Field: "inline_schema", Message: "inline schema is required for inline location type"}
	}

	// Check hash
	if sd.Hash == "" {
		return &ValidationError{Field: "hash", Message: "schema hash is required"}
	}

	// Validate hash format (should be 64 hex characters for SHA256)
	if len(sd.Hash) != 64 {
		return &ValidationError{Field: "hash", Message: "invalid hash format (expected 64 hex characters)"}
	}

	// Check content type
	if sd.ContentType == "" {
		return &ValidationError{Field: "content_type", Message: "content type is required"}
	}

	return nil
}

// CalculateManifestChecksum calculates the SHA256 checksum of a manifest
// by combining all schema hashes in a deterministic order.
func CalculateManifestChecksum(manifest *SchemaManifest) (string, error) {
	if len(manifest.Schemas) == 0 {
		// Empty manifest has empty checksum
		return "", nil
	}

	// Sort schemas by type for deterministic hashing
	sortedSchemas := make([]SchemaDescriptor, len(manifest.Schemas))
	copy(sortedSchemas, manifest.Schemas)
	sort.Slice(sortedSchemas, func(i, j int) bool {
		return sortedSchemas[i].Type < sortedSchemas[j].Type
	})

	// Concatenate all schema hashes
	var (
		combined      string
		combinedSb278 strings.Builder
	)

	for _, schema := range sortedSchemas {
		combinedSb278.WriteString(schema.Hash)
	}

	combined += combinedSb278.String()

	// Calculate SHA256 of combined hashes
	hash := sha256.Sum256([]byte(combined))

	return hex.EncodeToString(hash[:]), nil
}

// CalculateSchemaChecksum calculates the SHA256 checksum of a schema.
func CalculateSchemaChecksum(schema any) (string, error) {
	// Serialize to canonical JSON (map keys are sorted by json.Marshal)
	data, err := json.Marshal(schema)
	if err != nil {
		return "", fmt.Errorf("failed to serialize schema: %w", err)
	}

	// Calculate SHA256
	hash := sha256.Sum256(data)

	return hex.EncodeToString(hash[:]), nil
}

// UpdateRoutesChecksum recalculates the routes checksum based on the route table
// and routing configuration. Services SHOULD call this after building their route table.
func (m *SchemaManifest) UpdateRoutesChecksum() error {
	checksum, err := CalculateRoutesChecksum(m)
	if err != nil {
		return fmt.Errorf("failed to calculate routes checksum: %w", err)
	}

	m.RoutesChecksum = checksum

	return nil
}

// CalculateRoutesChecksum calculates a SHA256 hash of the route-affecting fields:
// routing config (strategy, base_path, subdomain, rewrite, strip_prefix) and
// sorted route table entries (path + methods + protocol).
// This hash is used by gateways to detect whether route remounting is needed.
func CalculateRoutesChecksum(manifest *SchemaManifest) (string, error) {
	// Build canonical representation of route-affecting fields
	type routeEntry struct {
		Path     string   `json:"path"`
		Methods  []string `json:"methods,omitempty"`
		Protocol string   `json:"protocol"`
	}

	type routeCanonical struct {
		Strategy    string        `json:"strategy"`
		BasePath    string        `json:"base_path"`
		Subdomain   string        `json:"subdomain"`
		Rewrite     []PathRewrite `json:"rewrite"`
		StripPrefix bool          `json:"strip_prefix"`
		Routes      []routeEntry  `json:"routes"`
		Health      string        `json:"health"`
		GraphQL     string        `json:"graphql"`
		OpenAPI     string        `json:"openapi"`
		AsyncAPI    string        `json:"asyncapi"`
	}

	// Sort route table entries for deterministic hashing
	sortedRoutes := make([]routeEntry, len(manifest.RouteTable))
	for i, r := range manifest.RouteTable {
		// Sort methods within each route for determinism
		methods := make([]string, len(r.Methods))
		copy(methods, r.Methods)
		sort.Strings(methods)

		sortedRoutes[i] = routeEntry{
			Path:     r.Path,
			Methods:  methods,
			Protocol: r.Protocol,
		}
	}

	sort.Slice(sortedRoutes, func(i, j int) bool {
		if sortedRoutes[i].Path != sortedRoutes[j].Path {
			return sortedRoutes[i].Path < sortedRoutes[j].Path
		}

		return sortedRoutes[i].Protocol < sortedRoutes[j].Protocol
	})

	canonical := routeCanonical{
		Strategy:    string(manifest.Routing.Strategy),
		BasePath:    manifest.Routing.BasePath,
		Subdomain:   manifest.Routing.Subdomain,
		Rewrite:     manifest.Routing.Rewrite,
		StripPrefix: manifest.Routing.StripPrefix,
		Routes:      sortedRoutes,
		Health:      manifest.Endpoints.Health,
		GraphQL:     manifest.Endpoints.GraphQL,
		OpenAPI:     manifest.Endpoints.OpenAPI,
		AsyncAPI:    manifest.Endpoints.AsyncAPI,
	}

	data, err := json.Marshal(canonical)
	if err != nil {
		return "", fmt.Errorf("failed to serialize route canonical form: %w", err)
	}

	hash := sha256.Sum256(data)

	return hex.EncodeToString(hash[:]), nil
}

// ManifestDiff represents the difference between two manifests.
type ManifestDiff struct {
	// SchemasAdded are schemas present in new but not in old
	SchemasAdded []SchemaDescriptor

	// SchemasRemoved are schemas present in old but not in new
	SchemasRemoved []SchemaDescriptor

	// SchemasChanged are schemas present in both but with different hashes
	SchemasChanged []SchemaChangeDiff

	// CapabilitiesAdded are new capabilities
	CapabilitiesAdded []string

	// CapabilitiesRemoved are removed capabilities
	CapabilitiesRemoved []string

	// EndpointsChanged indicates if endpoints changed
	EndpointsChanged bool

	// RoutingChanged indicates if routing configuration changed
	RoutingChanged bool

	// RoutesChecksumChanged indicates the route table hash changed.
	// Gateway implementations SHOULD use this to decide whether to remount routes.
	RoutesChecksumChanged bool
}

// SchemaChangeDiff represents a changed schema.
type SchemaChangeDiff struct {
	Type    SchemaType
	OldHash string
	NewHash string
}

// HasChanges returns true if there are any changes.
func (d *ManifestDiff) HasChanges() bool {
	return len(d.SchemasAdded) > 0 ||
		len(d.SchemasRemoved) > 0 ||
		len(d.SchemasChanged) > 0 ||
		len(d.CapabilitiesAdded) > 0 ||
		len(d.CapabilitiesRemoved) > 0 ||
		d.EndpointsChanged ||
		d.RoutingChanged ||
		d.RoutesChecksumChanged
}

// HasRouteChanges returns true only if route-affecting changes were detected.
// Gateway implementations SHOULD use this to decide whether to remount routes.
// This prevents unnecessary route remounts that cause intermittent 404s.
func (d *ManifestDiff) HasRouteChanges() bool {
	return len(d.SchemasAdded) > 0 ||
		len(d.SchemasRemoved) > 0 ||
		d.RoutingChanged ||
		d.RoutesChecksumChanged
}

// DiffManifests compares two manifests and returns the differences.
func DiffManifests(old, newManifest *SchemaManifest) *ManifestDiff {
	diff := &ManifestDiff{}

	// Build maps for easier comparison
	oldSchemas := make(map[SchemaType]SchemaDescriptor)
	for _, s := range old.Schemas {
		oldSchemas[s.Type] = s
	}

	newSchemas := make(map[SchemaType]SchemaDescriptor)
	for _, s := range newManifest.Schemas {
		newSchemas[s.Type] = s
	}

	// Find added and changed schemas
	for schemaType, newSchema := range newSchemas {
		if oldSchema, exists := oldSchemas[schemaType]; exists {
			// Schema exists in both, check if changed
			if oldSchema.Hash != newSchema.Hash {
				diff.SchemasChanged = append(diff.SchemasChanged, SchemaChangeDiff{
					Type:    schemaType,
					OldHash: oldSchema.Hash,
					NewHash: newSchema.Hash,
				})
			}
		} else {
			// Schema is new
			diff.SchemasAdded = append(diff.SchemasAdded, newSchema)
		}
	}

	// Find removed schemas
	for schemaType, oldSchema := range oldSchemas {
		if _, exists := newSchemas[schemaType]; !exists {
			diff.SchemasRemoved = append(diff.SchemasRemoved, oldSchema)
		}
	}

	// Compare capabilities
	oldCaps := make(map[string]bool)
	for _, c := range old.Capabilities {
		oldCaps[c] = true
	}

	newCaps := make(map[string]bool)
	for _, c := range newManifest.Capabilities {
		newCaps[c] = true
	}

	for cap := range newCaps {
		if !oldCaps[cap] {
			diff.CapabilitiesAdded = append(diff.CapabilitiesAdded, cap)
		}
	}

	for cap := range oldCaps {
		if !newCaps[cap] {
			diff.CapabilitiesRemoved = append(diff.CapabilitiesRemoved, cap)
		}
	}

	// Compare endpoints (simple comparison)
	if old.Endpoints != newManifest.Endpoints {
		diff.EndpointsChanged = true
	}

	// Compare routing configuration
	if old.Routing.Strategy != newManifest.Routing.Strategy ||
		old.Routing.BasePath != newManifest.Routing.BasePath ||
		old.Routing.Subdomain != newManifest.Routing.Subdomain ||
		old.Routing.StripPrefix != newManifest.Routing.StripPrefix ||
		old.Routing.Priority != newManifest.Routing.Priority {
		diff.RoutingChanged = true
	}

	// Compare routes checksum (fast path for route change detection)
	if old.RoutesChecksum != newManifest.RoutesChecksum {
		diff.RoutesChecksumChanged = true
	}

	return diff
}