at-container-registry/pkg/appview/storage/profile.go

package storage

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"log/slog"
	"sync"
	"time"

	"atcr.io/pkg/atproto"
)

// ProfileRKey is always "self" per lexicon
const ProfileRKey = "self"

// Global map to track in-flight profile migrations (DID -> true)
// Used to prevent duplicate migration goroutines
var migrationLocks sync.Map

// EnsureProfile checks if a user's profile exists and creates it if needed
// This should be called during authentication (OAuth exchange or token service)
// If defaultHoldDID is provided, creates profile with that default (or empty if not provided)
// Expected format: "did:web:hold01.atcr.io"
// Normalizes URLs to DIDs for consistency (for backward compatibility)
func EnsureProfile(ctx context.Context, client *atproto.Client, defaultHoldDID string) error {
	// Check if profile already exists
	profile, err := client.GetRecord(ctx, atproto.SailorProfileCollection, ProfileRKey)
	if err == nil && profile != nil {
		// Profile exists, nothing to do
		return nil
	}

	// Normalize to DID if it's a URL (or pass through if already a DID)
	// This ensures we store DIDs consistently in new profiles
	normalizedDID := ""
	if defaultHoldDID != "" {
		resolved, err := atproto.ResolveHoldDID(ctx, defaultHoldDID)
		if err != nil {
			slog.Warn("Failed to resolve hold DID for new profile", "component", "profile", "defaultHold", defaultHoldDID, "error", err)
		} else {
			normalizedDID = resolved
		}
	}

	// Profile doesn't exist - create it
	newProfile := atproto.NewSailorProfileRecord(normalizedDID)

	_, err = client.PutRecord(ctx, atproto.SailorProfileCollection, ProfileRKey, newProfile)
	if err != nil {
		return fmt.Errorf("failed to create sailor profile: %w", err)
	}

	slog.Debug("Created sailor profile", "component", "profile", "default_hold", normalizedDID)
	return nil
}

// GetProfile retrieves the user's profile from their PDS
// Returns nil if profile doesn't exist
// Automatically migrates old URL-based defaultHold values to DIDs
func GetProfile(ctx context.Context, client *atproto.Client) (*atproto.SailorProfileRecord, error) {
	record, err := client.GetRecord(ctx, atproto.SailorProfileCollection, ProfileRKey)
	if err != nil {
		// Check if it's a 404 (profile doesn't exist)
		if errors.Is(err, atproto.ErrRecordNotFound) {
			return nil, nil
		}
		return nil, fmt.Errorf("failed to get profile: %w", err)
	}

	// Parse the profile record
	var profile atproto.SailorProfileRecord
	if err := json.Unmarshal(record.Value, &profile); err != nil {
		return nil, fmt.Errorf("failed to parse profile: %w", err)
	}

	// Migrate old URL-based defaultHold to DID format
	// This ensures backward compatibility with profiles created before DID migration
	if profile.DefaultHold != "" && !atproto.IsDID(profile.DefaultHold) {
		// Convert URL to DID by querying /.well-known/atproto-did
		migratedDID, resolveErr := atproto.ResolveHoldDID(ctx, profile.DefaultHold)
		if resolveErr != nil {
			slog.Warn("Failed to resolve hold DID during profile migration", "component", "profile", "defaultHold", profile.DefaultHold, "error", resolveErr)
		} else {
			profile.DefaultHold = migratedDID

			// Persist the migration to PDS in a background goroutine
			// Use a lock to ensure only one goroutine migrates this DID
			did := client.DID()
			if _, loaded := migrationLocks.LoadOrStore(did, true); !loaded {
				// We got the lock - launch goroutine to persist the migration
				go func() {
					// Clean up lock when done (after a short delay to batch requests)
					defer func() {
						time.Sleep(1 * time.Second)
						migrationLocks.Delete(did)
					}()

					// Create a new context with timeout for the background operation
					bgCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
					defer cancel()

					// Update the profile on the PDS
					profile.UpdatedAt = time.Now()
					if err := UpdateProfile(bgCtx, client, &profile); err != nil {
						slog.Warn("Failed to persist URL-to-DID migration", "component", "profile", "did", did, "error", err)
					} else {
						slog.Debug("Persisted defaultHold migration to DID", "component", "profile", "migrated_did", migratedDID, "did", did)
					}
				}()
			}
		}
	}

	return &profile, nil
}

// UpdateProfile updates the user's profile
// Normalizes defaultHold to DID format before saving
func UpdateProfile(ctx context.Context, client *atproto.Client, profile *atproto.SailorProfileRecord) error {
	// Normalize defaultHold to DID if it's a URL
	// This ensures we always store DIDs, even if user provides a URL
	if profile.DefaultHold != "" && !atproto.IsDID(profile.DefaultHold) {
		if resolved, err := atproto.ResolveHoldDID(ctx, profile.DefaultHold); err != nil {
			slog.Warn("Failed to resolve hold DID during profile update", "component", "profile", "defaultHold", profile.DefaultHold, "error", err)
		} else {
			profile.DefaultHold = resolved
			slog.Debug("Normalized defaultHold to DID", "component", "profile", "default_hold", profile.DefaultHold)
		}
	}

	_, err := client.PutRecord(ctx, atproto.SailorProfileCollection, ProfileRKey, profile)
	if err != nil {
		return fmt.Errorf("failed to update profile: %w", err)
	}
	return nil
}