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 != "" {
		normalizedDID = atproto.ResolveHoldDIDFromURL(defaultHoldDID)
	}

	// 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 transparently
		migratedDID := atproto.ResolveHoldDIDFromURL(profile.DefaultHold)
		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
				ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
				defer cancel()

				// Update the profile on the PDS
				profile.UpdatedAt = time.Now()
				if err := UpdateProfile(ctx, 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) {
		profile.DefaultHold = atproto.ResolveHoldDIDFromURL(profile.DefaultHold)
		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
}