tiny-forge/internal/api/dns.go

package api

import (
	"fmt"
	"log/slog"
	"net/http"
	"strings"

	"github.com/alexei/tinyforge/internal/crypto"
	"github.com/alexei/tinyforge/internal/dns"
	"github.com/alexei/tinyforge/internal/store"
	"github.com/go-chi/chi/v5"
)

// dnsTargetIP returns the IP to use for DNS A records.
// Prefers PublicIP (the proxy/NPM host), falls back to ServerIP.
func dnsTargetIP(settings store.Settings) string {
	if settings.PublicIP != "" {
		return settings.PublicIP
	}
	return dnsTargetIP(settings)
}

// dnsRecordView is the response format for DNS records with consumer context.
type dnsRecordView struct {
	FQDN         string `json:"fqdn"`
	Type         string `json:"type"`
	Content      string `json:"content"`
	ConsumerType string `json:"consumer_type"`
	ConsumerName string `json:"consumer_name"`
	ConsumerID   string `json:"consumer_id"`
	Status       string `json:"status"` // "synced", "orphaned", "missing"
}

// listDNSRecords handles GET /api/dns/records.
// In managed DNS mode: merges local dns_records with actual Cloudflare records to compute sync status.
// In wildcard mode: shows all expected FQDNs from active consumers (informational, no sync status).
func (s *Server) listDNSRecords(w http.ResponseWriter, r *http.Request) {
	settings, err := s.store.GetSettings()
	if err != nil {
		respondError(w, http.StatusInternalServerError, "failed to get settings: "+err.Error())
		return
	}

	consumerNames := s.buildConsumerNameMap()

	// In wildcard mode, show expected records from consumers without sync status.
	if settings.WildcardDNS {
		expectedFQDNs, err := s.computeExpectedFQDNs(settings)
		if err != nil {
			respondError(w, http.StatusInternalServerError, "failed to compute expected records: "+err.Error())
			return
		}
		var views []dnsRecordView
		for fqdn, consumer := range expectedFQDNs {
			parts := strings.SplitN(consumer, ":", 2)
			consumerType, consumerID := parts[0], ""
			if len(parts) > 1 {
				consumerID = parts[1]
			}
			name := consumerNames[consumer]
			if name == "" {
				name = consumerID
			}
			views = append(views, dnsRecordView{
				FQDN:         fqdn,
				Type:         "A",
				Content:      dnsTargetIP(settings),
				ConsumerType: consumerType,
				ConsumerName: name,
				ConsumerID:   consumerID,
				Status:       "wildcard",
			})
		}
		if views == nil {
			views = []dnsRecordView{}
		}
		respondJSON(w, http.StatusOK, views)
		return
	}

	// Managed DNS mode: full sync status computation.

	// Get local tracked records.
	localRecords, err := s.store.ListDNSRecords()
	if err != nil {
		respondError(w, http.StatusInternalServerError, "failed to list local records: "+err.Error())
		return
	}

	// Try to get actual records from the DNS provider.
	var providerRecords []dns.Record
	provider := s.getOrCreateDNSProvider(settings)
	if provider != nil {
		providerRecords, err = provider.ListRecords(r.Context())
		if err != nil {
			slog.Warn("dns records: failed to list provider records", "error", err)
			// Continue with local-only view.
		}
	}

	// Build a map of provider records by FQDN.
	providerByFQDN := make(map[string]dns.Record, len(providerRecords))
	for _, rec := range providerRecords {
		providerByFQDN[rec.FQDN] = rec
	}

	// Build a set of local FQDNs.
	localFQDNs := make(map[string]bool, len(localRecords))
	for _, rec := range localRecords {
		localFQDNs[rec.FQDN] = true
	}

	var views []dnsRecordView

	// Process local records: check if they exist in provider.
	for _, local := range localRecords {
		status := "missing"
		content := dnsTargetIP(settings)
		if pRec, ok := providerByFQDN[local.FQDN]; ok {
			status = "synced"
			content = pRec.Content
		}

		name := consumerNames[local.ConsumerType+":"+local.ConsumerID]
		if name == "" {
			name = local.ConsumerID
		}

		views = append(views, dnsRecordView{
			FQDN:         local.FQDN,
			Type:         "A",
			Content:      content,
			ConsumerType: local.ConsumerType,
			ConsumerName: name,
			ConsumerID:   local.ConsumerID,
			Status:       status,
		})
	}

	// Find orphaned records: in provider but not in local tracking.
	for _, pRec := range providerRecords {
		if !localFQDNs[pRec.FQDN] {
			views = append(views, dnsRecordView{
				FQDN:         pRec.FQDN,
				Type:         pRec.Type,
				Content:      pRec.Content,
				ConsumerType: "",
				ConsumerName: "",
				ConsumerID:   "",
				Status:       "orphaned",
			})
		}
	}

	if views == nil {
		views = []dnsRecordView{}
	}

	respondJSON(w, http.StatusOK, views)
}

// deleteDNSRecord handles DELETE /api/dns/records/{fqdn}.
func (s *Server) deleteDNSRecord(w http.ResponseWriter, r *http.Request) {
	fqdn := chi.URLParam(r, "fqdn")
	if fqdn == "" {
		respondError(w, http.StatusBadRequest, "fqdn is required")
		return
	}

	settings, err := s.store.GetSettings()
	if err != nil {
		respondError(w, http.StatusInternalServerError, "failed to get settings: "+err.Error())
		return
	}

	provider := s.getOrCreateDNSProvider(settings)
	if provider != nil {
		if err := provider.DeleteRecord(r.Context(), fqdn); err != nil {
			respondError(w, http.StatusBadGateway, "failed to delete DNS record: "+err.Error())
			return
		}
	}

	// Remove local tracking.
	if err := s.store.DeleteDNSRecord(fqdn); err != nil {
		slog.Warn("delete dns tracking record", "fqdn", fqdn, "error", err)
	}

	respondJSON(w, http.StatusOK, map[string]string{"status": "deleted"})
}

// buildConsumerNameMap builds a lookup of "type:id" -> display name for DNS
// consumers. Sourced from the containers index now that legacy project/stage
// tables are gone — the workload's name + the container's role + tag is what
// operators see in the UI.
func (s *Server) buildConsumerNameMap() map[string]string {
	names := make(map[string]string)
	containers, err := s.store.ListContainers(store.ContainerFilter{})
	if err != nil {
		return names
	}
	workloadNames := make(map[string]string)
	for _, c := range containers {
		wname, ok := workloadNames[c.WorkloadID]
		if !ok {
			if w, err := s.store.GetWorkloadByID(c.WorkloadID); err == nil {
				wname = w.Name
			}
			workloadNames[c.WorkloadID] = wname
		}
		label := wname
		if c.Role != "" {
			label = label + "/" + c.Role
		}
		if c.ImageTag != "" {
			label = label + ":" + c.ImageTag
		}
		names["instance:"+c.ID] = label
	}
	return names
}

// getOrCreateDNSProvider returns the server's DNS provider, or creates a temporary one from settings.
func (s *Server) getOrCreateDNSProvider(settings store.Settings) dns.Provider {
	if p := s.getDNSProviderLocked(); p != nil {
		return p
	}

	if settings.WildcardDNS || settings.DNSProvider == "" || settings.CloudflareAPIToken == "" {
		return nil
	}

	token, err := crypto.Decrypt(s.encKey, settings.CloudflareAPIToken)
	if err != nil {
		slog.Warn("dns: failed to decrypt token for provider creation", "error", err)
		return nil
	}

	provider, err := dns.NewProvider(settings.DNSProvider, dns.Config{
		Token:  token,
		ZoneID: settings.CloudflareZoneID,
	})
	if err != nil {
		slog.Warn("dns: failed to create provider", "error", err)
		return nil
	}
	return provider
}

// syncDNSRecords handles POST /api/dns/sync.
func (s *Server) syncDNSRecords(w http.ResponseWriter, r *http.Request) {
	settings, err := s.store.GetSettings()
	if err != nil {
		respondError(w, http.StatusInternalServerError, "failed to get settings: "+err.Error())
		return
	}

	if settings.WildcardDNS {
		respondError(w, http.StatusBadRequest, "DNS sync is disabled in wildcard mode")
		return
	}

	provider := s.getOrCreateDNSProvider(settings)
	if provider == nil {
		respondError(w, http.StatusBadRequest, "DNS provider not configured")
		return
	}

	// Compute expected FQDNs from active consumers.
	expectedFQDNs, err := s.computeExpectedFQDNs(settings)
	if err != nil {
		respondError(w, http.StatusInternalServerError, "failed to compute expected records: "+err.Error())
		return
	}

	// Get actual provider records.
	providerRecords, err := provider.ListRecords(r.Context())
	if err != nil {
		respondError(w, http.StatusBadGateway, "failed to list DNS records: "+err.Error())
		return
	}

	providerByFQDN := make(map[string]dns.Record, len(providerRecords))
	for _, rec := range providerRecords {
		providerByFQDN[rec.FQDN] = rec
	}

	// Get local tracking records.
	localRecords, err := s.store.ListDNSRecords()
	if err != nil {
		respondError(w, http.StatusInternalServerError, "failed to list local records: "+err.Error())
		return
	}
	localByFQDN := make(map[string]bool, len(localRecords))
	for _, rec := range localRecords {
		localByFQDN[rec.FQDN] = true
	}

	created := 0
	deleted := 0
	alreadySynced := 0

	// Create missing records.
	for fqdn, consumer := range expectedFQDNs {
		if _, exists := providerByFQDN[fqdn]; exists {
			alreadySynced++
			continue
		}

		recordID, err := provider.EnsureRecord(r.Context(), fqdn, dnsTargetIP(settings))
		if err != nil {
			slog.Warn("dns sync: failed to create record", "fqdn", fqdn, "error", err)
			continue
		}

		// Track locally.
		parts := strings.SplitN(consumer, ":", 2)
		consumerType, consumerID := parts[0], ""
		if len(parts) > 1 {
			consumerID = parts[1]
		}
		if _, err := s.store.CreateDNSRecord(store.DNSRecord{
			FQDN:             fqdn,
			ProviderRecordID: recordID,
			ConsumerType:     consumerType,
			ConsumerID:       consumerID,
		}); err != nil {
			s.store.UpdateDNSRecordProviderID(fqdn, recordID)
		}
		created++
	}

	// Delete orphaned records (in provider + tracked locally, but no active consumer).
	for _, local := range localRecords {
		if _, expected := expectedFQDNs[local.FQDN]; !expected {
			if err := provider.DeleteRecord(r.Context(), local.FQDN); err != nil {
				slog.Warn("dns sync: failed to delete orphaned record", "fqdn", local.FQDN, "error", err)
				continue
			}
			s.store.DeleteDNSRecord(local.FQDN)
			deleted++
		}
	}

	respondJSON(w, http.StatusOK, map[string]int{
		"created":        created,
		"deleted":        deleted,
		"already_synced": alreadySynced,
	})
}

// computeExpectedFQDNs returns a map of FQDN -> "consumerType:consumerID"
// for every running container that has a proxy route configured. Sourced
// directly from the containers index — the workload-first cutover dropped
// the per-stage enable_proxy toggle in favour of "if a proxy route ID
// exists, the workload wanted a route."
func (s *Server) computeExpectedFQDNs(settings store.Settings) (map[string]string, error) {
	expected := make(map[string]string)
	containers, err := s.store.ListContainers(store.ContainerFilter{})
	if err != nil {
		return nil, fmt.Errorf("list containers: %w", err)
	}
	for _, c := range containers {
		if c.Subdomain == "" || c.State != "running" {
			continue
		}
		if c.NpmProxyID == 0 && c.ProxyRouteID == "" {
			continue
		}
		fqdn := c.Subdomain + "." + settings.Domain
		expected[fqdn] = "instance:" + c.ID
	}
	return expected, nil
}