plugin.go

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"sync"
	"time"

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

type NostrPlugin struct {
	config             *Config
	logger             *logrus.Logger
	matterbridgeClient *MatterbridgeClient
	rooms              map[string]*NostrRoom
	publicKeyHex       string
	privateKeyHex      string
	watchNpubHex       string
	stopChan           chan struct{}
	wg                 sync.WaitGroup
	mu                 sync.RWMutex
	relays             *NostrRelays
}

type NostrRoom struct {
	addr string
	ctx  context.Context
	stop context.CancelFunc
}

func NewNostrPlugin(config *Config, logger *logrus.Logger) *NostrPlugin {
	return &NostrPlugin{
		config:             config,
		logger:             logger,
		matterbridgeClient: NewMatterbridgeClient(config.MatterbridgeURL, config.APIToken, logger),
		rooms:              make(map[string]*NostrRoom),
		stopChan:           make(chan struct{}),
		relays:             NewNostrRelays(context.Background(), config.DefaultRelays, config.MaxRetryAttempts, time.Duration(config.RetryTimeoutMinutes)*time.Minute, logger),
	}
}

func (p *NostrPlugin) Start() error {
	if err := p.setupNostrKeys(); err != nil {
		return fmt.Errorf("failed to setup Nostr keys: %w", err)
	}

	if err := p.setupWatchNpub(); err != nil {
		return fmt.Errorf("failed to setup watch npub: %w", err)
	}

	// Discover and connect to NIP-65 write relays
	if err := p.connectToNIP65WriteRelays(); err != nil {
		p.logger.Warnf("Failed to connect to NIP-65 write relays: %v", err)
		// Continue execution even if NIP-65 discovery fails
	}

	p.wg.Add(1)
	go p.discoverLiveEvents()

	// Start Matterbridge client with message handler
	p.matterbridgeClient.Start(p.handleMatterbridgeMessage)

	return nil
}

func (p *NostrPlugin) Stop() {
	p.logger.Info("Stopping Nostr relays...")
	p.relays.Close()

	p.logger.Info("Stopping Matterbridge client...")
	p.matterbridgeClient.Stop()

	p.logger.Info("Closing stop channel...")
	close(p.stopChan)

	p.logger.Info("Waiting for goroutines to finish...")
	p.wg.Wait()

	p.logger.Info("Stopping rooms...")
	p.mu.Lock()
	defer p.mu.Unlock()

	for _, room := range p.rooms {
		room.stop()
	}
}

func (p *NostrPlugin) setupNostrKeys() error {
	prefix, pubHex, err := nip19.Decode(p.config.PublicKey)
	if err != nil || prefix != "npub" {
		return fmt.Errorf("invalid public key format: %w", err)
	}
	p.publicKeyHex = pubHex.(string)

	prefix, secHex, err := nip19.Decode(p.config.PrivateKey)
	if err != nil || prefix != "nsec" {
		return fmt.Errorf("invalid private key format: %w", err)
	}
	p.privateKeyHex = secHex.(string)

	p.logger.Debugf("Initialized with pubkey: %s", p.publicKeyHex)
	return nil
}

func (p *NostrPlugin) setupWatchNpub() error {
	prefix, pubHex, err := nip19.Decode(p.config.WatchNpub)
	if err != nil || prefix != "npub" {
		return fmt.Errorf("invalid watch npub format: %w", err)
	}
	p.watchNpubHex = pubHex.(string)

	p.logger.Infof("Auto-discovery enabled for npub: %s", p.config.WatchNpub)
	return nil
}

func (p *NostrPlugin) connectToNIP65WriteRelays() error {
	p.logger.Info("Discovering NIP-65 write relays for watched npub...")

	// Fetch NIP-65 write relays for the watched npub
	writeRelays := p.relays.GetWriteRelays(p.watchNpubHex, 10*time.Second)
	if writeRelays == nil {
		return fmt.Errorf("no NIP-65 relay list found for watched npub")
	}

	if len(writeRelays) == 0 {
		p.logger.Info("No write relays specified in NIP-65 metadata")
		return nil
	}

	p.logger.Infof("Found %d write relays in NIP-65 metadata", len(writeRelays))

	// Simply add the write relays to our existing relay pool
	for _, relay := range writeRelays {
		p.relays.AddRelay(relay)
	}

	return nil
}

func (p *NostrPlugin) createNaddr(ev *nostr.Event, relayURL string, liveEvent nip53.LiveEvent) (string, error) {
	relaysForNaddr := liveEvent.Relays

	if len(relaysForNaddr) == 0 {
		// Default to the relay where this event was received from
		relaysForNaddr = []string{relayURL}
	}

	return nip19.EncodeEntity(ev.PubKey, ev.Kind, liveEvent.Identifier, relaysForNaddr)
}

func (p *NostrPlugin) discoverLiveEvents() {
	defer p.wg.Done()
	p.logger.Debug("Discovering live events...")

	events := p.relays.StreamLiveEvents(p.watchNpubHex)
	seenEvents := make(map[string]nostr.Timestamp)

	for evWithRelay := range events {
		if evWithRelay == nil || evWithRelay.Event == nil {
			continue
		}

		ev := evWithRelay.Event
		relayURL := evWithRelay.RelayURL

		liveEvent := nip53.ParseLiveEvent(*ev)

		naddr, err := p.createNaddr(ev, relayURL, liveEvent)
		if err != nil {
			p.logger.Warnf("Failed to make naddr for event %s: %v", ev.ID, err)
			continue
		}

		addr := fmt.Sprintf("%v:%v:%v", ev.Kind, ev.PubKey, liveEvent.Identifier)

		p.logger.Infof("discoverLiveEvents: found %s %s %s on %s (created: %v)", naddr, addr, liveEvent.Status, relayURL, ev.CreatedAt.Time())

		if existing, exists := seenEvents[addr]; exists && ev.CreatedAt <= existing {
			p.logger.Infof("discoverLiveEvents: ignoring older event %s on %s (created: %v <= %v)", addr, relayURL, ev.CreatedAt.Time(), existing.Time())
			continue
		}

		if liveEvent.Status == "live" {
			if p.joinLiveEvent(addr, naddr) {
				p.logger.Infof("Joined live event: %s (status: %s)", liveEvent.Title, liveEvent.Status)
				p.sendJoinEventToMatterbridge(naddr, liveEvent, relayURL)
			} else {
				p.logger.Debugf("Already joined live event: %s", liveEvent.Title)
			}
		} else {
			if p.leaveLiveEvent(addr) {
				p.logger.Infof("Left live event: %s (status: %s)", liveEvent.Title, liveEvent.Status)
				p.sendLeaveEventToMatterbridge(naddr, liveEvent, relayURL)
			} else {
				p.logger.Debugf("Not in live event to leave: %s (status: %s)", liveEvent.Title, liveEvent.Status)
			}
		}

		seenEvents[addr] = ev.CreatedAt
	}
}

func (p *NostrPlugin) joinLiveEvent(addr string, naddr string) bool {
	p.mu.Lock()
	defer p.mu.Unlock()

	if _, exists := p.rooms[addr]; exists {
		p.logger.Debugf("joinLiveEvent: room %s already exists", addr)
		return false
	}

	ctx, cancel := context.WithCancel(context.Background())
	p.rooms[addr] = &NostrRoom{
		addr: addr,
		ctx:  ctx,
		stop: cancel,
	}

	p.wg.Add(1)
	go p.streamingMessages(p.rooms[addr])

	return true
}

func (p *NostrPlugin) leaveLiveEvent(addr string) bool {
	p.mu.Lock()
	defer p.mu.Unlock()

	room, exists := p.rooms[addr]
	if !exists {
		return false
	}

	room.stop()
	delete(p.rooms, addr)

	return true
}

func (p *NostrPlugin) streamingMessages(room *NostrRoom) {
	defer p.wg.Done()
	p.logger.Infof("streamMessages: starting for %s", room.addr)

	events := p.relays.StreamLiveChatMessages(room.addr)

	for {
		select {
		case <-room.ctx.Done():
			p.logger.Debugf("streamMessages: %s: context done", room.addr)
			return
		case <-p.stopChan:
			p.logger.Debugf("streamMessages: %s: stop channel", room.addr)
			return
		case evWithRelay := <-events:
			if evWithRelay == nil || evWithRelay.Event == nil || evWithRelay.Event.PubKey == p.publicKeyHex {
				p.logger.Debugf("streamMessages: %s: skipping event", room.addr)
				continue
			}

			err := p.sendNostrEventToMatterbridge(evWithRelay.Event)
			if err != nil {
				p.logger.Errorf("streamMessages: %s: failed to handle event: %v", room.addr, err)
			}
		}
	}
}

// sendSystemMessageToMatterbridge sends a system message to Matterbridge
func (p *NostrPlugin) sendSystemMessageToMatterbridge(text string) error {
	mbMsg := MatterbridgeMessage{
		Text:     text,
		Username: "system",
		Gateway:  p.config.Gateway,
	}

	if err := p.matterbridgeClient.SendMessage(mbMsg); err != nil {
		p.logger.Errorf("Failed to send message to Matterbridge: %v", err)
		return err
	}
	return nil
}

func (p *NostrPlugin) sendJoinEventToMatterbridge(naddr string, liveEvent nip53.LiveEvent, relayURL string) error {
	text := "Joined " + liveEvent.Title + " (via " + relayURL + "): https://nostrudel.ninja/streams/" + naddr
	return p.sendSystemMessageToMatterbridge(text)
}

func (p *NostrPlugin) sendLeaveEventToMatterbridge(naddr string, liveEvent nip53.LiveEvent, relayURL string) error {
	text := "Left " + liveEvent.Title + " (via " + relayURL + "): https://nostrudel.ninja/streams/" + naddr
	return p.sendSystemMessageToMatterbridge(text)
}

func (p *NostrPlugin) sendNostrEventToMatterbridge(ev *nostr.Event) error {
	msg, err := NostrMessageFromEvent(ev, p.relays)
	if err != nil {
		p.logger.Errorf("sendNostrEventToMatterbridge: %s: failed to get message from event: %v", ev.ID, err)
		return err
	}

	mbMsg := MatterbridgeMessage{
		Text:     msg.Content,
		Username: msg.Nick,
		Gateway:  p.config.Gateway,
	}

	p.logger.Infof("sendNostrEventToMatterbridge: sending message to Matterbridge: %s", ev.ID)

	if err := p.matterbridgeClient.SendMessage(mbMsg); err != nil {
		p.logger.Errorf("sendNostrEventToMatterbridge: %s: failed to send message to Matterbridge: %v", ev.ID, err)
		return err
	}

	return nil
}

// handleMatterbridgeMessage handles messages received from Matterbridge
func (p *NostrPlugin) handleMatterbridgeMessage(msg MatterbridgeMessage) error {
	rooms := p.getActiveRooms()
	if len(rooms) == 0 {
		p.logger.Debugf("handleMatterbridgeMessage: no active rooms, skipping message")
		return nil
	}

	js, _ := json.Marshal(msg)
	p.logger.Infof("handleMatterbridgeMessage: sending message to %d active rooms: %s", len(rooms), string(js))

	for naddr, room := range rooms {
		p.logger.Debugf("handleMatterbridgeMessage: sending to room %s %s", room.addr, naddr)
		if err := p.sendMatterbridgeMessageToNostr(msg, room); err != nil {
			p.logger.Errorf("handleMatterbridgeMessage: failed to send message to Nostr room %s %s: %v", room.addr, naddr, err)
		}
	}

	return nil
}

// getActiveRooms returns a copy of the active rooms map
func (p *NostrPlugin) getActiveRooms() map[string]*NostrRoom {
	p.mu.RLock()
	defer p.mu.RUnlock()

	rooms := make(map[string]*NostrRoom, len(p.rooms))
	for k, v := range p.rooms {
		rooms[k] = v
		p.logger.Debugf("getActiveRooms: found active room %s (%s)", k, v.addr)
	}
	p.logger.Debugf("getActiveRooms: returning %d rooms", len(rooms))
	return rooms
}

func (p *NostrPlugin) sendMatterbridgeMessageToNostr(msg MatterbridgeMessage, room *NostrRoom) error {
	event := nostr.Event{
		PubKey:    p.publicKeyHex,
		CreatedAt: nostr.Now(),
		Kind:      nostr.KindLiveChatMessage,
		Tags:      nostr.Tags{{"a", room.addr}},
		Content:   msg.Username + ": " + msg.Text,
	}

	if err := event.Sign(p.privateKeyHex); err != nil {
		return fmt.Errorf("failed to sign event: %w", err)
	}

	published := p.relays.Publish(event)
	if published == 0 {
		return fmt.Errorf("failed to publish event to any relay")
	}

	return nil
}