nostr.go

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"net/url"
	"regexp"
	"strconv"
	"strings"
	"time"

	"github.com/nbd-wtf/go-nostr"
	"github.com/sirupsen/logrus"
)

type ProfileMetadata struct {
	Name                  string `json:"name"`
	DisplayName           string `json:"display_name,omitempty"`
	DeprecatedDisplayName string `json:"displayName,omitempty"`
}

type NostrMessage struct {
	Content string
	Nick    string
}

type NostrEventWithRelay struct {
	Event    *nostr.Event
	RelayURL string
}

// normalizeRelayURL normalizes a relay URL to prevent duplicates
// Removes trailing slashes and ensures consistent formatting
func normalizeRelayURL(relayURL string) string {
	// Parse the URL to handle it properly
	u, err := url.Parse(relayURL)
	if err != nil {
		// If parsing fails, just return the original URL
		return relayURL
	}

	// Remove trailing slash from path
	u.Path = strings.TrimSuffix(u.Path, "/")

	// Reconstruct the URL
	normalized := strings.ToLower(u.String())

	return normalized
}

func NostrMessageFromEvent(ev *nostr.Event, relays *NostrRelays) (*NostrMessage, error) {
	if ev.Kind == nostr.KindZap {
		text, err := processZapEvent(ev, relays)
		if err != nil {
			return nil, err
		}

		return &NostrMessage{Content: text, Nick: "system"}, nil
	}

	return &NostrMessage{
		Content: ev.Content,
		Nick:    getNickWithFallback(relays, ev.PubKey),
	}, nil
}

// parseBolt11Amount extracts the amount in millisats from a bolt11 invoice
func parseBolt11Amount(bolt11 string) (int64, error) {
	re := regexp.MustCompile(`^lnbc(\d+)(\w)1`)
	matches := re.FindStringSubmatch(bolt11)

	if matches == nil {
		return 0, fmt.Errorf("invalid bolt11 invoice format")
	}

	// Parse the amount with its multiplier
	// All amounts are converted to millisats for consistency
	multiplier := int64(1)

	amount, err := strconv.ParseInt(matches[1], 10, 64)
	if err != nil {
		return 0, fmt.Errorf("failed to parse amount: %w", err)
	}

	switch matches[2] {
	case "m": // milli = 0.001 bitcoin = 100,000 sats = 100,000,000 millisats
		multiplier = 100000000
	case "u": // micro = 0.000001 bitcoin = 100 sats = 100,000 millisats
		multiplier = 100000
	case "n": // nano = 0.000000001 bitcoin = 0.1 sats = 100 millisats
		multiplier = 100
	case "p": // pico = 0.000000000001 bitcoin = 0.0001 sats = 0.1 millisats
		// For pico, we need to divide by 10 to convert to millisats
		return amount / 10, nil // pico to millisats conversion (10 pico = 1 millisat)
	default:
		// No unit means the amount is in bitcoin base units
		// 1 bitcoin = 100,000,000 sats = 100,000,000,000 millisats
		multiplier = 100000000000
	}

	return amount * multiplier, nil
}

// getNickWithFallback gets a nick and ensures it's not "system"
func getNickWithFallback(relays *NostrRelays, pubkey string) string {
	nick := relays.GetNick(pubkey, time.Second)
	if nick == "system" {
		return "not system"
	}
	return nick
}

// formatZapMessage creates a zap message text with optional content
func formatZapMessage(nick string, amount int64, unit string, content string) string {
	text := fmt.Sprintf("⚡ %s zapped %d %s", nick, amount, unit)
	if content != "" {
		text += " saying: " + content
	}
	return text
}

// processZapEvent processes a zap event and returns the formatted message
func processZapEvent(ev *nostr.Event, relays *NostrRelays) (string, error) {
	description := ev.Tags.Find("description").Value()
	if description == "" {
		return "", fmt.Errorf("no description found")
	}

	var zapRequest nostr.Event
	if err := json.Unmarshal([]byte(description), &zapRequest); err != nil {
		return "", fmt.Errorf("failed to unmarshal zap request: %w", err)
	}

	bolt11 := ev.Tags.Find("bolt11").Value()
	if bolt11 == "" {
		return "", fmt.Errorf("no bolt11 invoice found in zap receipt")
	}

	amountMillisats, err := parseBolt11Amount(bolt11)
	if err != nil {
		return "", fmt.Errorf("failed to parse bolt11 amount: %w", err)
	}

	nick := getNickWithFallback(relays, zapRequest.PubKey)

	// Handle sub-sat amounts
	amountSats := amountMillisats / 1000
	if amountSats == 0 && amountMillisats > 0 {
		return formatZapMessage(nick, amountMillisats, "millisats", zapRequest.Content), nil
	}
	return formatZapMessage(nick, amountSats, "sats", zapRequest.Content), nil
}

type NostrRelay struct {
	url           string
	relay         *nostr.Relay
	failures      int
	nextAttempt   time.Time
	maxRetries    int
	retryDelay    time.Duration
	logger        *logrus.Logger
	lastEventTime nostr.Timestamp
}

func NewNostrRelay(ctx context.Context, url string, maxRetries int, retryDelay time.Duration, logger *logrus.Logger) *NostrRelay {
	logger.Infof("relay %s: connecting", url)
	relay, err := nostr.RelayConnect(ctx, url)
	if err != nil {
		logger.Errorf("relay %s: failed to connect to relay: %v", url, err)
		return nil
	}

	return &NostrRelay{
		url:         url,
		relay:       relay,
		failures:    0,
		nextAttempt: time.Now(),
		maxRetries:  maxRetries,
		retryDelay:  retryDelay,
		logger:      logger,
	}
}

func (r *NostrRelay) Reconnect(ctx context.Context) error {
	r.logger.Infof("relay %s: reconnecting", r.url)
	r.relay.Close()
	newRelay, err := nostr.RelayConnect(ctx, r.url)
	if err != nil {
		return err
	}
	r.relay = newRelay
	return nil
}

func (r *NostrRelay) GetNick(ctx context.Context, npub string, timeout time.Duration) (string, error) {
	filters := nostr.Filters{{
		Kinds:   []int{nostr.KindProfileMetadata},
		Authors: []string{npub},
		Limit:   1,
	}}

	timeoutCtx, cancel := context.WithTimeout(ctx, timeout)
	defer cancel()

	sub, err := r.relay.Subscribe(timeoutCtx, filters)
	if err != nil {
		r.logger.Errorf("relay %s: failed to subscribe to profile metadata: %v", r.url, err)
		return "", err
	}
	defer sub.Close()

	for ev := range sub.Events {
		var pm ProfileMetadata
		if err := json.Unmarshal([]byte(ev.Content), &pm); err != nil {
			r.logger.Errorf("relay %s: failed to unmarshal profile metadata: %v", r.url, err)
			continue
		}

		// Return first non-empty display name
		for _, name := range []string{pm.DisplayName, pm.DeprecatedDisplayName, pm.Name} {
			if name != "" {
				r.logger.Infof("relay %s: got nick %s", r.url, name)
				return name, nil
			}
		}
	}

	r.logger.Infof("relay %s: no nick found", r.url)
	return "", nil
}

func (r *NostrRelay) GetWriteRelays(ctx context.Context, npub string, timeout time.Duration) ([]string, error) {
	filters := nostr.Filters{{
		Kinds:   []int{10002}, // NIP-65 relay list metadata
		Authors: []string{npub},
		Limit:   1,
	}}

	timeoutCtx, cancel := context.WithTimeout(ctx, timeout)
	defer cancel()

	sub, err := r.relay.Subscribe(timeoutCtx, filters)
	if err != nil {
		r.logger.Errorf("relay %s: failed to subscribe to relay list metadata: %v", r.url, err)
		return nil, err
	}
	defer sub.Close()

	for ev := range sub.Events {
		return parseWriteRelays(ev), nil
	}

	r.logger.Infof("relay %s: no relay list metadata found", r.url)
	return nil, nil
}

func parseWriteRelays(ev *nostr.Event) []string {
	writeRelays := make([]string, 0)
	seen := make(map[string]bool)

	for _, tag := range ev.Tags {
		if len(tag) < 2 || tag[0] != "r" {
			continue // not a relay tag
		}

		if len(tag) >= 3 && tag[2] != "write" {
			continue // not a write relay
		}

		relayURL := tag[1]
		if !seen[relayURL] {
			writeRelays = append(writeRelays, relayURL)
			seen[relayURL] = true
		}
	}

	return writeRelays
}

func (r *NostrRelay) StreamEvents(ctx context.Context, filters nostr.Filters, events chan *NostrEventWithRelay) {
	r.logger.Infof("relay %s: streaming events with filters %v", r.url, filters)
	sub, err := r.relay.Subscribe(ctx, filters)
	if err != nil {
		r.logger.Errorf("relay %s: failed to subscribe to events: %v", r.url, err)
		return
	}
	defer sub.Close()

	for {
		select {
		case <-ctx.Done():
			r.logger.Debugf("relay %s: context done", r.url)
			return
		case ev, ok := <-sub.Events:
			if !ok {
				r.logger.Debugf("relay %s: channel closed", r.url)
				return
			}
			if ev != nil {
				r.logger.Debugf("relay %s: event received: %v", r.url, ev)

				events <- &NostrEventWithRelay{
					Event:    ev,
					RelayURL: r.url,
				}

				r.UpdateLastEventTime(ev.CreatedAt)
			}
		}
	}
}

func (r *NostrRelay) Publish(ctx context.Context, event nostr.Event) error {
	// Check cooldown
	if time.Now().Before(r.nextAttempt) {
		r.logger.Infof("relay %s: in cooldown", r.url)
		return fmt.Errorf("relay in cooldown")
	}

	err := r.relay.Publish(ctx, event)
	if err == nil {
		r.logger.Infof("relay %s: published event: %v", r.url, event)
		r.failures = 0
		return nil
	}

	// Try reconnect and publish again
	if reconnectErr := r.Reconnect(ctx); reconnectErr == nil {
		if err = r.relay.Publish(ctx, event); err == nil {
			r.logger.Infof("relay %s: republished event: %v", r.url, event)
			r.failures = 0
			return nil
		}
	}

	// Handle failure
	r.failures++
	if r.failures >= r.maxRetries {
		r.logger.Infof("relay %s: max retries exceeded", r.url)
		r.nextAttempt = time.Now().Add(r.retryDelay)
	}

	return err
}

func (r *NostrRelay) Close() {
	r.logger.Infof("relay %s: closing", r.url)
	r.relay.Close()
}

// UpdateLastEventTime updates the last event timestamp for this relay
func (r *NostrRelay) UpdateLastEventTime(timestamp nostr.Timestamp) {
	if timestamp > r.lastEventTime {
		r.lastEventTime = timestamp
	}
}

// UpdateFiltersForReconnect updates the given filters to use this relay's last event time
func (r *NostrRelay) UpdateFiltersForReconnect(filters *nostr.Filters) {
	lastTime := r.lastEventTime

	if lastTime == 0 {
		// If no events received yet, use current time to avoid getting old events
		lastTime = nostr.Timestamp(time.Now().Unix())
		r.logger.Debugf("relay %s: no previous events, using current time for reconnect: %d", r.url, lastTime)
	} else {
		r.logger.Debugf("relay %s: updating filters with last event time: %d", r.url, lastTime)
	}

	// Update all filters to use the latest timestamp
	for i := range *filters {
		(*filters)[i].Since = &lastTime
	}
}

type NostrRelays struct {
	relays     []*NostrRelay
	logger     *logrus.Logger
	maxRetries int
	retryDelay time.Duration
	ctx        context.Context
	cancel     context.CancelFunc
}

func NewNostrRelays(ctx context.Context, urls []string, maxRetries int, retryDelay time.Duration, logger *logrus.Logger) *NostrRelays {
	ctx, cancel := context.WithCancel(ctx)
	relays := make([]*NostrRelay, 0, len(urls))

	for _, url := range urls {
		url = normalizeRelayURL(url)

		if relay := NewNostrRelay(ctx, url, maxRetries, retryDelay, logger); relay != nil {
			relays = append(relays, relay)
			logger.Infof("Connected to relay: %s", url)
		} else {
			logger.Warnf("Failed to connect to relay: %s", url)
		}
	}

	return &NostrRelays{
		relays:     relays,
		maxRetries: maxRetries,
		retryDelay: retryDelay,
		logger:     logger,
		ctx:        ctx,
		cancel:     cancel,
	}
}

func (r *NostrRelays) AddRelay(url string) {
	url = normalizeRelayURL(url)

	for _, existingRelay := range r.relays {
		if url == existingRelay.url {
			r.logger.Debugf("Already connected to relay: %s", url)
			return
		}
	}

	if relay := NewNostrRelay(r.ctx, url, r.maxRetries, r.retryDelay, r.logger); relay != nil {
		r.relays = append(r.relays, relay)
		r.logger.Infof("Connected to relay: %s", url)
	} else {
		r.logger.Warnf("Failed to connect to relay: %s", url)
	}
}

func (r *NostrRelays) GetNick(npub string, timeout time.Duration) string {
	for _, relay := range r.relays {
		if nick, err := relay.GetNick(r.ctx, npub, timeout); err == nil && nick != "" {
			return nick
		}
	}
	return "unknown"
}

func (r *NostrRelays) GetWriteRelays(npub string, timeout time.Duration) []string {
	for _, relay := range r.relays {
		if writeRelays, err := relay.GetWriteRelays(r.ctx, npub, timeout); err == nil && writeRelays != nil {
			r.logger.Infof("Found NIP-65 relay list for %s: %d write relays", npub, len(writeRelays))
			return writeRelays
		}
	}
	r.logger.Warnf("No NIP-65 relay list found for %s", npub)
	return nil
}

func (r *NostrRelays) StreamEvents(filters nostr.Filters) chan *NostrEventWithRelay {
	rawEvents := make(chan *NostrEventWithRelay, 100)
	deduplicatedEvents := make(chan *NostrEventWithRelay, 100)

	// Start streaming from all relays
	for _, relay := range r.relays {
		if relay == nil {
			continue
		}

		go func(relay *NostrRelay) {
			currentFilters := make(nostr.Filters, len(filters))
			copy(currentFilters, filters)
			reconnectDelay := 5 * time.Second
			maxReconnectDelay := 60 * time.Second

			for r.ctx.Err() == nil {
				relay.StreamEvents(r.ctx, currentFilters, rawEvents)

				if r.ctx.Err() != nil {
					break
				}

				// Only reconnect if the connection was lost unexpectedly
				// StreamEvents returns when the subscription channel closes
				r.logger.Infof("relay %s: connection lost, attempting to reconnect after %v", relay.url, reconnectDelay)

				select {
				case <-r.ctx.Done():
					return
				case <-time.After(reconnectDelay):
				}

				if err := relay.Reconnect(r.ctx); err != nil {
					r.logger.Errorf("relay %s: failed to reconnect: %v", relay.url, err)

					// Exponential backoff on reconnection failures
					reconnectDelay *= 2

					if reconnectDelay > maxReconnectDelay {
						reconnectDelay = maxReconnectDelay
					}

					continue
				}

				// Reset reconnect delay on successful connection
				reconnectDelay = 5 * time.Second

				// Update filters with latest event timestamp to avoid duplicates
				relay.UpdateFiltersForReconnect(&currentFilters)
			}
		}(relay)
	}

	// Handle deduplication and timestamp tracking
	go r.deduplicateEventsWithRelay(rawEvents, deduplicatedEvents)

	return deduplicatedEvents
}

// clearHalfMap removes half the entries from a map for memory management
func (r *NostrRelays) clearHalfMap(handled map[string]*NostrEventWithRelay) {
	count := 0
	target := len(handled) / 2
	for id := range handled {
		delete(handled, id)
		count++
		if count >= target {
			break
		}
	}
}

func (r *NostrRelays) deduplicateEventsWithRelay(rawEvents, deduplicatedEvents chan *NostrEventWithRelay) {
	defer close(deduplicatedEvents)
	handled := make(map[string]*NostrEventWithRelay)

	for {
		select {
		case <-r.ctx.Done():
			r.logger.Debugf("StreamEvents: context done")
			return
		case ev, ok := <-rawEvents:
			if !ok {
				r.logger.Debugf("StreamEvents: channel closed")
				return
			}

			if ev == nil || ev.Event == nil {
				r.logger.Debugf("StreamEvents: skipping nil event")
				continue
			}

			// If we've already seen this event, keep the first one (first relay wins)
			if _, exists := handled[ev.Event.ID]; exists {
				r.logger.Debugf("StreamEvents: skipping duplicate event: %v", ev.Event.ID)
				continue
			}

			handled[ev.Event.ID] = ev
			r.logger.Debugf("StreamEvents: handled event: %v from relay: %s", ev.Event.ID, ev.RelayURL)

			select {
			case deduplicatedEvents <- ev:
				r.logger.Debugf("StreamEvents: deduplicated event: %v from relay: %s", ev.Event.ID, ev.RelayURL)
			case <-r.ctx.Done():
				r.logger.Debugf("StreamEvents: context done")
				return
			}

			// Simple cleanup when map gets too large
			if len(handled) > 1000 {
				r.logger.Debugf("StreamEvents: handled map too large, clearing half the entries")
				r.clearHalfMap(handled)
			}
		}
	}
}

func (r *NostrRelays) StreamLiveEvents(npub string) chan *NostrEventWithRelay {
	ts := time.Now().Add(-24 * time.Hour)
	since := nostr.Timestamp(ts.Unix())

	// Query for live events from the watched npub
	filters := nostr.Filters{{
		Kinds:   []int{nostr.KindLiveEvent},
		Authors: []string{npub},
		Since:   &since, // Look back 24 hours
	}}

	return r.StreamEvents(filters)
}

func (r *NostrRelays) StreamLiveChatMessages(addr string) chan *NostrEventWithRelay {
	timestamp := nostr.Timestamp(time.Now().Unix())

	filters := nostr.Filters{{
		Kinds: []int{nostr.KindLiveChatMessage, nostr.KindZap},
		Tags:  nostr.TagMap{"a": {addr}},
		Since: &timestamp,
	}}

	return r.StreamEvents(filters)
}

func (r *NostrRelays) Publish(event nostr.Event) int {
	r.logger.Infof("Publishing event to %d relays", len(r.relays))
	published := 0

	for _, relay := range r.relays {
		if err := relay.Publish(r.ctx, event); err == nil {
			published++
		} else {
			r.logger.Warnf("Failed to publish to %s: %v", relay.url, err)
		}
	}

	return published
}

func (r *NostrRelays) Close() {
	for _, relay := range r.relays {
		relay.Close()
	}
	r.cancel()
}