UUID Generation

/**
 * Collection of utilities for generating Universally Unique Identifiers
 * Implementation is native-backed for optimal performance
 */
interface UUID {
  /**
   * Generates a random UUID v4 string
   * @returns Randomly generated UUID string
   */
  v4(): string;
  
  /**
   * Generates a UUID v5 based on name and namespace
   * Always produces the same result for the same inputs
   * @param name - String value to generate UUID from
   * @param namespace - Namespace UUID string or 16-byte array
   * @returns Deterministic UUID string based on inputs
   */
  v5(name: string, namespace: string | number[]): string;
  
  /**
   * Standard namespaces for UUID v5 generation
   */
  namespace: typeof Uuidv5Namespace;
}

const uuid: UUID;

import { uuid } from "expo-modules-core";

// Generate random UUIDs
const randomId1 = uuid.v4(); // e.g., "f47ac10b-58cc-4372-a567-0e02b2c3d479"
const randomId2 = uuid.v4(); // e.g., "6ba7b810-9dad-11d1-80b4-00c04fd430c8"

console.log("Random UUID:", randomId1);
console.log("Another random UUID:", randomId2);

// Generate deterministic UUIDs
const userId = "john.doe@example.com";
const deterministicId1 = uuid.v5(userId, uuid.namespace.dns);
const deterministicId2 = uuid.v5(userId, uuid.namespace.dns);

console.log("Deterministic UUID 1:", deterministicId1);
console.log("Deterministic UUID 2:", deterministicId2);
console.log("Are they equal?", deterministicId1 === deterministicId2); // true

// Different namespaces produce different UUIDs
const urlBasedId = uuid.v5("https://example.com/user/123", uuid.namespace.url);
const dnsBasedId = uuid.v5("example.com", uuid.namespace.dns);

console.log("URL-based UUID:", urlBasedId);
console.log("DNS-based UUID:", dnsBasedId);

/**
 * Default namespaces for UUID v5 defined in RFC 4122
 */
enum Uuidv5Namespace {
  /** DNS namespace - for domain names */
  dns = '6ba7b810-9dad-11d1-80b4-00c04fd430c8',
  /** URL namespace - for URLs */
  url = '6ba7b811-9dad-11d1-80b4-00c04fd430c8', 
  /** OID namespace - for ISO OIDs */
  oid = '6ba7b812-9dad-11d1-80b4-00c04fd430c8',
  /** X.500 namespace - for X.500 DNs */
  x500 = '6ba7b814-9dad-11d1-80b4-00c04fd430c8',
}

import { uuid, Uuidv5Namespace } from "expo-modules-core";

// Use predefined namespaces
const domains = ["example.com", "google.com", "github.com"];
const domainUuids = domains.map(domain => ({
  domain,
  uuid: uuid.v5(domain, Uuidv5Namespace.dns)
}));

console.log("Domain UUIDs:", domainUuids);
// Each domain will always produce the same UUID

// URL-based UUIDs
const urls = [
  "https://api.example.com/users/123",
  "https://api.example.com/posts/456", 
  "https://cdn.example.com/images/789.jpg"
];

const urlUuids = urls.map(url => ({
  url,
  uuid: uuid.v5(url, Uuidv5Namespace.url)
}));

console.log("URL UUIDs:", urlUuids);

// X.500 Distinguished Names  
const distinguishedNames = [
  "CN=John Doe,OU=Engineering,O=ExampleCorp,C=US",
  "CN=Jane Smith,OU=Marketing,O=ExampleCorp,C=US"
];

const dnUuids = distinguishedNames.map(dn => ({
  dn,
  uuid: uuid.v5(dn, Uuidv5Namespace.x500)
}));

console.log("Distinguished Name UUIDs:", dnUuids);

import { uuid } from "expo-modules-core";

// Create a custom namespace UUID for your application
const APP_NAMESPACE = "550e8400-e29b-41d4-a716-446655440000";

// Generate UUIDs for application-specific entities
function generateUserUuid(email: string): string {
  return uuid.v5(email, APP_NAMESPACE);
}

function generateSessionUuid(userId: string, timestamp: number): string {
  return uuid.v5(`${userId}:${timestamp}`, APP_NAMESPACE);
}

function generateResourceUuid(type: string, id: string): string {
  return uuid.v5(`${type}:${id}`, APP_NAMESPACE);
}

// Usage
const userEmail = "alice@example.com";
const userId = generateUserUuid(userEmail);
const sessionId = generateSessionUuid(userId, Date.now());
const documentId = generateResourceUuid("document", "readme.md");

console.log("User UUID:", userId);
console.log("Session UUID:", sessionId);
console.log("Document UUID:", documentId);

// Using byte array namespace
const customNamespaceBytes = [
  0x55, 0x0e, 0x84, 0x00, 0xe2, 0x9b, 0x41, 0xd4,
  0xa7, 0x16, 0x44, 0x66, 0x55, 0x44, 0x00, 0x00
];

const byteBasedUuid = uuid.v5("test-data", customNamespaceBytes);
console.log("Byte-based UUID:", byteBasedUuid);

import { uuid } from "expo-modules-core";

// UUID validation (basic pattern matching)
function isValidUuid(str: string): boolean {
  const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
  return uuidRegex.test(str);
}

// Extract UUID version
function getUuidVersion(uuidStr: string): number | null {
  if (!isValidUuid(uuidStr)) return null;
  return parseInt(uuidStr.charAt(14), 16);
}

// UUID generation with validation
function generateValidatedUuid(): string {
  const id = uuid.v4();
  if (!isValidUuid(id)) {
    throw new Error("Generated invalid UUID");
  }
  return id;
}

// Batch UUID generation
function generateUuidBatch(count: number, type: 'v4' | 'v5' = 'v4', name?: string): string[] {
  const uuids: string[] = [];
  
  for (let i = 0; i < count; i++) {
    if (type === 'v4') {
      uuids.push(uuid.v4());
    } else if (type === 'v5' && name) {
      // Add index to make each UUID unique
      uuids.push(uuid.v5(`${name}:${i}`, uuid.namespace.dns));
    }
  }
  
  return uuids;
}

// Usage
const singleUuid = generateValidatedUuid();
console.log("Validated UUID:", singleUuid);
console.log("UUID version:", getUuidVersion(singleUuid)); // 4

// Generate batch of random UUIDs
const randomBatch = generateUuidBatch(5, 'v4');
console.log("Random UUID batch:", randomBatch);

// Generate batch of deterministic UUIDs
const deterministicBatch = generateUuidBatch(5, 'v5', 'user-session');
console.log("Deterministic UUID batch:", deterministicBatch);

import { uuid } from "expo-modules-core";

// ✅ Good: Use v4 for unique identifiers
function createUniqueId(): string {
  return uuid.v4();
}

// ✅ Good: Use v5 for reproducible identifiers
function createReproducibleId(data: string, context: string): string {
  return uuid.v5(`${context}:${data}`, uuid.namespace.dns);
}

// ✅ Good: Cache namespace UUIDs
const NAMESPACE_CACHE = new Map<string, string>();

function getCachedNamespaceId(namespace: string): string {
  if (!NAMESPACE_CACHE.has(namespace)) {
    NAMESPACE_CACHE.set(namespace, uuid.v5(namespace, uuid.namespace.dns));
  }
  return NAMESPACE_CACHE.get(namespace)!;
}

// ✅ Good: Batch operations when possible
class UuidManager {
  private static batchGenerate(count: number): string[] {
    return Array.from({ length: count }, () => uuid.v4());
  }
  
  static generateIds(count: number): string[] {
    if (count <= 0) return [];
    if (count === 1) return [uuid.v4()];
    return this.batchGenerate(count);
  }
}

// ❌ Bad: Generating UUIDs in loops without caching
function badExample() {
  const items = ['a', 'b', 'c', 'd', 'e'];
  return items.map(item => {
    // Recalculates namespace each time
    return uuid.v5(item, uuid.v5('my-namespace', uuid.namespace.dns));
  });
}

// ✅ Good: Pre-calculate namespace
function goodExample() {
  const items = ['a', 'b', 'c', 'd', 'e'];
  const myNamespace = uuid.v5('my-namespace', uuid.namespace.dns);
  
  return items.map(item => uuid.v5(item, myNamespace));
}

// Application-specific UUID patterns
class ApplicationIds {
  private static readonly USER_NAMESPACE = uuid.v5('users', uuid.namespace.dns);
  private static readonly SESSION_NAMESPACE = uuid.v5('sessions', uuid.namespace.dns);
  
  static generateUserId(email: string): string {
    return uuid.v5(email.toLowerCase(), this.USER_NAMESPACE);
  }
  
  static generateSessionId(): string {
    // Combine deterministic and random elements
    const timestamp = Date.now().toString();
    const random = uuid.v4();
    return uuid.v5(`${timestamp}:${random}`, this.SESSION_NAMESPACE);
  }
  
  static generateRequestId(): string {
    // Always random for unique request tracking
    return uuid.v4();
  }
}

// Usage
const userId = ApplicationIds.generateUserId("user@example.com");
const sessionId = ApplicationIds.generateSessionId();
const requestId = ApplicationIds.generateRequestId();

console.log("Generated IDs:", { userId, sessionId, requestId });

/**
 * UUID utility interface
 */
interface UUID {
  v4(): string;
  v5(name: string, namespace: string | number[]): string;
  namespace: typeof Uuidv5Namespace;
}

/**
 * Standard UUID v5 namespace enumeration
 */
enum Uuidv5Namespace {
  dns = '6ba7b810-9dad-11d1-80b4-00c04fd430c8',
  url = '6ba7b811-9dad-11d1-80b4-00c04fd430c8',
  oid = '6ba7b812-9dad-11d1-80b4-00c04fd430c8',
  x500 = '6ba7b814-9dad-11d1-80b4-00c04fd430c8'
}