package discovery

import (
	"strings"
	"sync"
	"time"
)

const (
	DefaultHealthIntervalSec = 10
	DefaultHealthTimeoutSec  = 30
)

type RegistryEntry struct {
	ID              string       `json:"id"`
	InstanceID      string       `bson:"instanceId" json:"instanceId"`
	Service         string       `json:"service"`
	Rail            string       `json:"rail,omitempty"`
	Network         string       `json:"network,omitempty"`
	Operations      []string     `json:"operations,omitempty"`
	Currencies      []string     `json:"currencies,omitempty"`
	Limits          *Limits      `json:"limits,omitempty"`
	InvokeURI       string       `json:"invokeURI,omitempty"`
	RoutingPriority int          `json:"routingPriority,omitempty"`
	Version         string       `json:"version,omitempty"`
	Health          HealthParams `json:"health,omitempty"`
	LastHeartbeat   time.Time    `json:"lastHeartbeat,omitempty"`
	Status          string       `json:"status,omitempty"`
	Healthy         bool         `json:"healthy,omitempty"`
}

type Registry struct {
	mu         sync.RWMutex
	entries    map[string]*RegistryEntry
	byID       map[string]map[string]struct{}
	byInstance map[string]map[string]struct{}
}

type UpdateResult struct {
	Entry         RegistryEntry
	IsNew         bool
	WasHealthy    bool
	BecameHealthy bool
}

func NewRegistry() *Registry {
	return &Registry{
		entries:    map[string]*RegistryEntry{},
		byID:       map[string]map[string]struct{}{},
		byInstance: map[string]map[string]struct{}{},
	}
}

func (r *Registry) UpsertFromAnnouncement(announce Announcement, now time.Time) UpdateResult {
	entry := registryEntryFromAnnouncement(normalizeAnnouncement(announce), now)
	key := registryEntryKey(entry)
	if key == "" {
		return UpdateResult{Entry: entry}
	}

	r.mu.Lock()
	defer r.mu.Unlock()

	existing, ok := r.entries[key]
	wasHealthy := false
	if ok && existing != nil {
		wasHealthy = existing.isHealthyAt(now)
		r.unindexEntry(key, existing)
	}
	entry.Healthy = entry.isHealthyAt(now)
	r.entries[key] = &entry
	r.indexEntry(key, &entry)

	return UpdateResult{
		Entry:         entry,
		IsNew:         !ok,
		WasHealthy:    wasHealthy,
		BecameHealthy: !wasHealthy && entry.Healthy,
	}
}

func (r *Registry) UpsertEntry(entry RegistryEntry, now time.Time) UpdateResult {
	entry = normalizeEntry(entry)
	key := registryEntryKey(entry)
	if key == "" {
		return UpdateResult{Entry: entry}
	}
	if entry.LastHeartbeat.IsZero() {
		entry.LastHeartbeat = now
	}
	if strings.TrimSpace(entry.Status) == "" {
		entry.Status = "ok"
	}

	r.mu.Lock()
	defer r.mu.Unlock()

	existing, ok := r.entries[key]
	wasHealthy := false
	if ok && existing != nil {
		wasHealthy = existing.isHealthyAt(now)
		r.unindexEntry(key, existing)
	}
	entry.Healthy = entry.isHealthyAt(now)
	r.entries[key] = &entry
	r.indexEntry(key, &entry)

	return UpdateResult{
		Entry:         entry,
		IsNew:         !ok,
		WasHealthy:    wasHealthy,
		BecameHealthy: !wasHealthy && entry.Healthy,
	}
}

func (r *Registry) UpdateHeartbeat(id string, instanceID string, status string, ts time.Time, now time.Time) []UpdateResult {
	id = strings.TrimSpace(id)
	instanceID = strings.TrimSpace(instanceID)
	if id == "" && instanceID == "" {
		return nil
	}
	if status == "" {
		status = "ok"
	}
	if ts.IsZero() {
		ts = now
	}

	r.mu.Lock()
	defer r.mu.Unlock()

	keys := keysFromIndex(r.byInstance[instanceID])
	if len(keys) == 0 && id != "" {
		keys = keysFromIndex(r.byID[id])
	}
	if len(keys) == 0 {
		return nil
	}
	results := make([]UpdateResult, 0, len(keys))
	for _, key := range keys {
		entry := r.entries[key]
		if entry == nil {
			continue
		}
		if id != "" && entry.ID != id {
			continue
		}
		if instanceID != "" && entry.InstanceID != instanceID {
			continue
		}
		wasHealthy := entry.isHealthyAt(now)
		entry.Status = status
		entry.LastHeartbeat = ts
		entry.Healthy = entry.isHealthyAt(now)

		results = append(results, UpdateResult{
			Entry:         *entry,
			IsNew:         false,
			WasHealthy:    wasHealthy,
			BecameHealthy: !wasHealthy && entry.Healthy,
		})
	}
	return results
}

func (r *Registry) Delete(key string) bool {
	key = strings.TrimSpace(key)
	if key == "" {
		return false
	}
	r.mu.Lock()
	defer r.mu.Unlock()
	entry, ok := r.entries[key]
	if !ok {
		return false
	}
	delete(r.entries, key)
	r.unindexEntry(key, entry)
	return true
}

func (r *Registry) List(now time.Time, onlyHealthy bool) []RegistryEntry {
	r.mu.Lock()
	defer r.mu.Unlock()

	result := make([]RegistryEntry, 0, len(r.entries))
	for _, entry := range r.entries {
		if entry == nil {
			continue
		}
		entry.Healthy = entry.isHealthyAt(now)
		if onlyHealthy && !entry.Healthy {
			continue
		}
		cp := *entry
		result = append(result, cp)
	}
	return result
}

func registryEntryFromAnnouncement(announce Announcement, now time.Time) RegistryEntry {
	status := "ok"
	return RegistryEntry{
		ID:              strings.TrimSpace(announce.ID),
		InstanceID:      strings.TrimSpace(announce.InstanceID),
		Service:         strings.TrimSpace(announce.Service),
		Rail:            strings.ToUpper(strings.TrimSpace(announce.Rail)),
		Network:         strings.ToUpper(strings.TrimSpace(announce.Network)),
		Operations:      cloneStrings(announce.Operations),
		Currencies:      cloneStrings(announce.Currencies),
		Limits:          cloneLimits(announce.Limits),
		InvokeURI:       strings.TrimSpace(announce.InvokeURI),
		RoutingPriority: announce.RoutingPriority,
		Version:         strings.TrimSpace(announce.Version),
		Health:          normalizeHealth(announce.Health),
		LastHeartbeat:   now,
		Status:          status,
	}
}

func normalizeEntry(entry RegistryEntry) RegistryEntry {
	entry.ID = strings.TrimSpace(entry.ID)
	entry.InstanceID = strings.TrimSpace(entry.InstanceID)
	if entry.InstanceID == "" {
		entry.InstanceID = entry.ID
	}
	entry.Service = strings.TrimSpace(entry.Service)
	entry.Rail = strings.ToUpper(strings.TrimSpace(entry.Rail))
	entry.Network = strings.ToUpper(strings.TrimSpace(entry.Network))
	entry.Operations = normalizeStrings(entry.Operations, false)
	entry.Currencies = normalizeStrings(entry.Currencies, true)
	entry.InvokeURI = strings.TrimSpace(entry.InvokeURI)
	entry.Version = strings.TrimSpace(entry.Version)
	entry.Status = strings.TrimSpace(entry.Status)
	entry.Health = normalizeHealth(entry.Health)
	if entry.Limits != nil {
		entry.Limits = normalizeLimits(*entry.Limits)
	}
	return entry
}

func normalizeAnnouncement(announce Announcement) Announcement {
	announce.ID = strings.TrimSpace(announce.ID)
	announce.InstanceID = strings.TrimSpace(announce.InstanceID)
	if announce.InstanceID == "" {
		announce.InstanceID = announce.ID
	}
	announce.Service = strings.TrimSpace(announce.Service)
	announce.Rail = strings.ToUpper(strings.TrimSpace(announce.Rail))
	announce.Network = strings.ToUpper(strings.TrimSpace(announce.Network))
	announce.Operations = normalizeStrings(announce.Operations, false)
	announce.Currencies = normalizeStrings(announce.Currencies, true)
	announce.InvokeURI = strings.TrimSpace(announce.InvokeURI)
	announce.Version = strings.TrimSpace(announce.Version)
	announce.Health = normalizeHealth(announce.Health)
	if announce.Limits != nil {
		announce.Limits = normalizeLimits(*announce.Limits)
	}
	return announce
}

func normalizeHealth(h HealthParams) HealthParams {
	if h.IntervalSec <= 0 {
		h.IntervalSec = DefaultHealthIntervalSec
	}
	if h.TimeoutSec <= 0 {
		h.TimeoutSec = DefaultHealthTimeoutSec
	}
	if h.TimeoutSec < h.IntervalSec {
		h.TimeoutSec = h.IntervalSec * 2
	}
	return h
}

func normalizeLimits(l Limits) *Limits {
	res := l
	if len(res.VolumeLimit) == 0 {
		res.VolumeLimit = nil
	}
	if len(res.VelocityLimit) == 0 {
		res.VelocityLimit = nil
	}
	return &res
}

func cloneLimits(src *Limits) *Limits {
	if src == nil {
		return nil
	}
	dst := *src
	if src.VolumeLimit != nil {
		dst.VolumeLimit = map[string]string{}
		for key, value := range src.VolumeLimit {
			if strings.TrimSpace(key) == "" {
				continue
			}
			dst.VolumeLimit[strings.TrimSpace(key)] = strings.TrimSpace(value)
		}
	}
	if src.VelocityLimit != nil {
		dst.VelocityLimit = map[string]int{}
		for key, value := range src.VelocityLimit {
			if strings.TrimSpace(key) == "" {
				continue
			}
			dst.VelocityLimit[strings.TrimSpace(key)] = value
		}
	}
	return &dst
}

func normalizeStrings(values []string, upper bool) []string {
	if len(values) == 0 {
		return nil
	}
	seen := map[string]bool{}
	result := make([]string, 0, len(values))
	for _, value := range values {
		clean := strings.TrimSpace(value)
		if clean == "" {
			continue
		}
		if upper {
			clean = strings.ToUpper(clean)
		}
		if seen[clean] {
			continue
		}
		seen[clean] = true
		result = append(result, clean)
	}
	if len(result) == 0 {
		return nil
	}
	return result
}

func cloneStrings(values []string) []string {
	if len(values) == 0 {
		return nil
	}
	out := make([]string, len(values))
	copy(out, values)
	return out
}

func (r *Registry) indexEntry(key string, entry *RegistryEntry) {
	if r == nil || entry == nil || key == "" {
		return
	}
	if entry.ID != "" {
		addIndex(r.byID, entry.ID, key)
	}
	if entry.InstanceID != "" {
		addIndex(r.byInstance, entry.InstanceID, key)
	}
}

func (r *Registry) unindexEntry(key string, entry *RegistryEntry) {
	if r == nil || entry == nil || key == "" {
		return
	}
	if entry.ID != "" {
		removeIndex(r.byID, entry.ID, key)
	}
	if entry.InstanceID != "" {
		removeIndex(r.byInstance, entry.InstanceID, key)
	}
}

func addIndex(index map[string]map[string]struct{}, id string, key string) {
	if id == "" || key == "" {
		return
	}
	set := index[id]
	if set == nil {
		set = map[string]struct{}{}
		index[id] = set
	}
	set[key] = struct{}{}
}

func removeIndex(index map[string]map[string]struct{}, id string, key string) {
	if id == "" || key == "" {
		return
	}
	set := index[id]
	if set == nil {
		return
	}
	delete(set, key)
	if len(set) == 0 {
		delete(index, id)
	}
}

func keysFromIndex(index map[string]struct{}) []string {
	if len(index) == 0 {
		return nil
	}
	keys := make([]string, 0, len(index))
	for key := range index {
		keys = append(keys, key)
	}
	return keys
}

func (e *RegistryEntry) isHealthyAt(now time.Time) bool {
	if e == nil {
		return false
	}
	status := strings.ToLower(strings.TrimSpace(e.Status))
	if status != "" && status != "ok" {
		return false
	}
	if e.LastHeartbeat.IsZero() {
		return false
	}
	timeout := time.Duration(e.Health.TimeoutSec) * time.Second
	if timeout <= 0 {
		timeout = time.Duration(DefaultHealthTimeoutSec) * time.Second
	}
	return now.Sub(e.LastHeartbeat) <= timeout
}