Advanced Data Types, Memory Management, and Type Safety

// Advanced Data Types and Type Safety Demonstration
import { isType, validateSchema } from './type-utils.js';

class DataTypeAnalyzer {
  constructor() {
    this.typeRegistry = new Map();
    this.memoryUsage = new Map();
    this.initializeTypeRegistry();
  }

  initializeTypeRegistry() {
    // Register type validators
    this.typeRegistry.set('string', value => typeof value === 'string');
    this.typeRegistry.set('number', value => typeof value === 'number' && !isNaN(value));
    this.typeRegistry.set('boolean', value => typeof value === 'boolean');
    this.typeRegistry.set('object', value => typeof value === 'object' && value !== null);
    this.typeRegistry.set('array', value => Array.isArray(value));
    this.typeRegistry.set('function', value => typeof value === 'function');
    this.typeRegistry.set('symbol', value => typeof value === 'symbol');
    this.typeRegistry.set('bigint', value => typeof value === 'bigint');
  }

  analyzeValue(value, label = 'value') {
    const analysis = {
      type: typeof value,
      isPrimitive: this.isPrimitive(value),
      isMutable: this.isMutable(value),
      memorySize: this.estimateMemorySize(value),
      validation: this.validateValue(value),
      stringified: this.safeStringify(value)
    };

    console.log(`\n📊 Analysis of ${label}:`, analysis);
    return analysis;
  }

  isPrimitive(value) {
    return value !== null && 
           (typeof value === 'string' || 
            typeof value === 'number' || 
            typeof value === 'boolean' || 
            typeof value === 'symbol' || 
            typeof value === 'bigint' || 
            typeof value === 'undefined');
  }

  isMutable(value) {
    return !this.isPrimitive(value) && value !== null;
  }

  estimateMemorySize(value) {
    if (this.isPrimitive(value)) {
      return this.getPrimitiveSize(value);
    }
    
    if (Array.isArray(value)) {
      return this.getArraySize(value);
    }
    
    if (typeof value === 'object') {
      return this.getObjectSize(value);
    }
    
    return 'Unknown';
  }

  getPrimitiveSize(value) {
    switch (typeof value) {
      case 'string': return value.length * 2; // UTF-16
      case 'number': return 8; // 64-bit float
      case 'boolean': return 1;
      case 'symbol': return 8; // Approximation
      case 'bigint': return 8; // Approximation
      default: return 0;
    }
  }

  getArraySize(array) {
    let size = 0;
    for (const item of array) {
      size += this.getPrimitiveSize(item);
    }
    return size + array.length * 8; // Array overhead
  }

  getObjectSize(obj) {
    let size = 0;
    for (const [key, value] of Object.entries(obj)) {
      size += key.length * 2; // Key size
      size += this.getPrimitiveSize(value);
    }
    return size;
  }

  validateValue(value) {
    const validations = [];
    
    // Type validation
    const type = typeof value;
    validations.push({ type: 'type', valid: true, value: type });
    
    // Null check
    validations.push({ type: 'null', valid: value !== null, value: value === null });
    
    // Undefined check
    validations.push({ type: 'undefined', valid: value !== undefined, value: value === undefined });
    
    // Array check
    if (Array.isArray(value)) {
      validations.push({ type: 'array', valid: true, length: value.length });
    }
    
    // Object check
    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
      validations.push({ type: 'object', valid: true, keys: Object.keys(value).length });
    }
    
    return validations;
  }

  safeStringify(value) {
    try {
      return JSON.stringify(value, null, 2);
    } catch (error) {
      return `[Circular or non-serializable: ${error.message}]`;
    }
  }

  demonstrateMemoryLeaks() {
    console.log('\n⚠️  Memory Leak Demonstration:');
    
    // Example 1: Event listener memory leak
    const button = document.createElement('button');
    button.textContent = 'Click me';
    
    // Bad: Anonymous function creates closure
    button.addEventListener('click', () => {
      console.log('Button clicked');
    });
    
    // Good: Named function for removal
    const handleClick = () => console.log('Button clicked');
    button.addEventListener('click', handleClick);
    // button.removeEventListener('click', handleClick); // Proper cleanup
    
    // Example 2: Closure memory leak
    const createLeakyFunction = () => {
      const largeData = new Array(1000000).fill('data');
      return () => {
        console.log('Accessing large data:', largeData.length);
      };
    };
    
    const leakyFunction = createLeakyFunction();
    // largeData is kept in memory even after createLeakyFunction returns
    
    console.log('Memory leak examples created. In production, ensure proper cleanup.');
  }

  demonstrateTypeSafety() {
    console.log('\n🛡️  Type Safety Demonstration:');
    
    // Runtime type checking
    const validateUser = (user) => {
      const schema = {
        name: 'string',
        age: 'number',
        email: 'string',
        isActive: 'boolean'
      };
      
      for (const [key, expectedType] of Object.entries(schema)) {
        const actualType = typeof user[key];
        if (actualType !== expectedType) {
          throw new TypeError(
            `Expected ${key} to be ${expectedType}, got ${actualType}`
          );
        }
      }
      
      return true;
    };
    
    try {
      const validUser = {
        name: 'John Doe',
        age: 30,
        email: 'john@example.com',
        isActive: true
      };
      
      validateUser(validUser);
      console.log('✅ Valid user passed validation');
      
      const invalidUser = {
        name: 'Jane Doe',
        age: '25', // Should be number
        email: 'jane@example.com',
        isActive: true
      };
      
      validateUser(invalidUser);
    } catch (error) {
      console.log('❌ Validation failed:', error.message);
    }
  }
}

// Usage demonstration
const analyzer = new DataTypeAnalyzer();

// Analyze different data types
const testValues = [
  'Hello, World!',
  42,
  true,
  null,
  undefined,
  Symbol('test'),
  123n,
  [1, 2, 3, 4, 5],
  { name: 'John', age: 30 },
  () => console.log('function'),
  new Date(),
  new Map([['key', 'value']]),
  new Set([1, 2, 3])
];

testValues.forEach((value, index) => {
  analyzer.analyzeValue(value, `testValue${index + 1}`);
});

// Demonstrate memory management
analyzer.demonstrateMemoryLeaks();

// Demonstrate type safety
analyzer.demonstrateTypeSafety();

// Modern JavaScript best practices
console.log('\n📚 Modern JavaScript Best Practices:');

// 1. Use const by default
const API_BASE_URL = 'https://api.example.com';
const DEFAULT_TIMEOUT = 5000;

// 2. Use let when reassignment is needed
let retryCount = 0;
const maxRetries = 3;

// 3. Destructuring for cleaner code
const user = { name: 'Alice', age: 25, email: 'alice@example.com' };
const { name, age, email } = user;

// 4. Template literals for string interpolation
const greeting = `Hello, ${name}! You are ${age} years old.`;

// 5. Arrow functions for concise syntax
const multiply = (a, b) => a * b;

// 6. Default parameters
const createUser = (name, age = 18, email = '') => ({ name, age, email });

// 7. Rest and spread operators
const sum = (...numbers) => numbers.reduce((acc, num) => acc + num, 0);
const userCopy = { ...user, age: 26 };

console.log('Best practices demonstrated successfully!');