/*
  Demonstrates how a strong reference prevents an object from being garbage collected.
  We create an object and store it in an array, simulating a common scenario where
  data might be held longer than intended.
*/

const cache = []; // This array holds strong references

function createBigObject(id) {
  const data = new Array(1000000).fill({ id: id, value: Math.random() });
  return { id, data };
}

function addStrongReference(id) {
  const obj = createBigObject(id);
  cache.push(obj); // Strong reference: 'obj' cannot be GC'd while 'cache' references it
  console.log(`Object with ID ${id} added to cache. Cache size: ${cache.length}`);
}

function checkCacheAndClearReferences() {
  console.log('--- Checking cache references ---');
  // In a real scenario, we'd need to explicitly remove objects from 'cache'
  // for them to be eligible for GC, if no other strong references exist.
  // Otherwise, they will persist, leading to a memory leak.

  // To simulate clearing, one might do:
  // cache.splice(0, cache.length); // This would clear all references
  // But for demonstration, we show objects persisting.
}

addStrongReference(1);
addStrongReference(2);

// Even if 'createBigObject(1)' and 'createBigObject(2)' are no longer directly used,
// the objects they created persist in the 'cache' array.
// This is a foundational understanding for recognizing memory leaks caused by strong references.

console.log('Cache contents after additions:');
console.log(cache.map(o => o.id));

// We must explicitly manage 'cache' to release memory for these objects.
// Without such management, these objects represent a memory leak.

/*
  Illustrates the use of WeakMap to associate data with objects
  without preventing those objects from being garbage collected.

  We simulate a scenario where we attach metadata to objects that might
  be ephemeral (e.g., DOM elements, component instances).
*/

// 1. Initialize a WeakMap
const objectMetadata = new WeakMap();

// 2. Define a function to create an object that might be garbage collected
function createEphemeralObject(id) {
  const obj = { id: id, timestamp: Date.now() };
  // Simulate a complex object with some data
  obj.data = new Array(10000).fill(id);
  return obj;
}

// 3. Create objects and associate metadata using WeakMap
let user1 = createEphemeralObject(1);
let user2 = createEphemeralObject(2);
let user3 = createEphemeralObject(3);

objectMetadata.set(user1, { lastAccess: Date.now(), permissions: ['read', 'write'] });
objectMetadata.set(user2, { lastAccess: Date.now(), permissions: ['read'] });

console.log(`Metadata for user1:`, objectMetadata.get(user1));
console.log(`Metadata for user2:`, objectMetadata.get(user2));
console.log(`Has user3 metadata?`, objectMetadata.has(user3)); // Should be false initially

// 4. Demonstrate WeakMap's 'weak' nature:
// When 'user1' and 'user2' lose all their strong references, they become eligible for GC.
// Crucially, the WeakMap's entries for 'user1' and 'user2' will also be removed automatically.

console.log('\n--- Releasing strong references for user1 and user2 ---');
user1 = null; // Remove strong reference to user1
user2 = null; // Remove strong reference to user2

// 5. Trigger GC (cannot be forced in JS, but we simulate a delay for demonstration)
// In a real environment, GC would run eventually.
// After GC, WeakMap entries for user1 and user2 will be gone.
setTimeout(() => {
  console.log('\n--- After potential garbage collection ---');
  // We cannot reliably check if GC has run or if entries are immediately removed,
  // but conceptually, objectMetadata.has(user1) would be false if user1 was collected.

  // We can only check for remaining *strong* references if user1/user2 were reassigned
  // to something else but the original object still existed somewhere.
  // Since we set them to null, they are effectively dereferenced.

  // A common use case: private data for objects
  class MyClass {
    constructor() {
      privateData.set(this, { secret: 'top_secret_info' });
    }
    getSecret() {
      return privateData.get(this).secret;
    }
  }

  const privateData = new WeakMap(); // Private data storage
  let instance = new MyClass();
  console.log(`Instance secret: ${instance.getSecret()}`);

  console.log('\n--- Releasing instance reference ---');
  instance = null; // Instance is now eligible for GC

  // The privateData entry for 'instance' will also be garbage collected automatically.
  // This prevents memory leaks if 'MyClass' instances are created and discarded frequently.

}, 100); // Small delay to allow JS engine background processes

/*
  Demonstrates the use of WeakSet to manage a collection of objects
  without preventing those objects from being garbage collected.

  We simulate tracking active instances or elements that should be automatically
  removed from the set when they are no longer strongly referenced elsewhere.
*/

// 1. Initialize a WeakSet
const activeElements = new WeakSet();

// 2. Define a function to create an element (e.g., a DOM element simulation)
function createDomElement(id) {
  const element = { id: `element-${id}`, status: 'active' };
  console.log(`Created element: ${element.id}`);
  return element;
}

// 3. Create some elements and add them to the WeakSet
let elementA = createDomElement('A');
let elementB = createDomElement('B');
let elementC = createDomElement('C');

activeElements.add(elementA);
activeElements.add(elementB);

console.log(`Has elementA in set? ${activeElements.has(elementA)}`); // true
console.log(`Has elementB in set? ${activeElements.has(elementB)}`); // true
console.log(`Has elementC in set? ${activeElements.has(elementC)}`); // false

// 4. Remove a strong reference to elementA
console.log('\n--- Releasing strong reference to elementA ---');
elementA = null; // elementA is now eligible for GC

// 5. Simulate garbage collection after a delay.
// If elementA is collected, it will automatically be removed from activeElements.
// We cannot explicitly verify removal directly through iteration, as WeakSet is not iterable.
setTimeout(() => {
  console.log('\n--- After potential garbage collection ---');
  // After GC, the entry for elementA would be removed from activeElements.
  // We can't use .size or iteration to confirm this directly for WeakSet.

  // Example: Tracking event listeners for specific objects
  const registeredListeners = new WeakSet();

  class Button {
    constructor(id) {
      this.id = id;
      this.clickHandler = () => console.log(`Button ${this.id} clicked!`);
    }
    register() {
      if (!registeredListeners.has(this)) {
        // In a real DOM scenario, we would add the listener to the actual DOM element.
        // For simulation, we just mark it as registered.
        registeredListeners.add(this);
        console.log(`Button ${this.id} registered.`);
      }
    }
    unregister() {
      // In a real DOM scenario, we would remove the listener from the actual DOM element.
      registeredListeners.delete(this);
      console.log(`Button ${this.id} unregistered.`);
    }
  }

  let button1 = new Button('Submit');
  let button2 = new Button('Cancel');

  button1.register();
  button2.register();

  console.log(`Is button1 registered? ${registeredListeners.has(button1)}`); // true

  console.log('\n--- Releasing strong reference to button1 ---');
  button1 = null; // Button1 instance is now eligible for GC

  // If button1 gets garbage collected, it is automatically removed from registeredListeners.
  // This prevents memory leaks from lingering references to defunct objects in our tracking set.

}, 100); // Small delay to allow JS engine background processes

/*
  Demonstrates advanced scenarios and best practices for using WeakMap and WeakSet
  together, or in more complex application patterns, to build robust, leak-free systems.

  Scenario: A simple component lifecycle management system that tracks active components
  and associates internal data with them, ensuring cleanup upon component unmounting/disposal.
*/

// Use WeakMap for private data associated with component instances.
const componentPrivateData = new WeakMap();

// Use WeakSet to track currently mounted/active component instances.
const activeComponents = new WeakSet();

class MyComponent {
  constructor(id) {
    this.id = id;
    // Store private, internal state that should be cleaned up with the component
    componentPrivateData.set(this, { 
      state: { count: 0, messages: [] },
      cleanupHooks: [] // e.g., references to interval IDs, event handlers
    });
    console.log(`Component ${this.id} created.`);
  }

  mount() {
    activeComponents.add(this); // Track this component as active
    const data = componentPrivateData.get(this);
    data.cleanupHooks.push(setInterval(() => {
      data.state.count++;
      // console.log(`Component ${this.id}: Count is ${data.state.count}`);
    }, 1000)); // Simulate a recurring task
    console.log(`Component ${this.id} mounted.`);
  }

  unmount() {
    activeComponents.delete(this); // Remove from active tracking
    const data = componentPrivateData.get(this);
    if (data) {
      data.cleanupHooks.forEach(clearInterval); // Clear any intervals/timers
      data.cleanupHooks = []; // Reset hooks
    }
    console.log(`Component ${this.id} unmounted.`);
  }

  getState() {
    return componentPrivateData.get(this)?.state;
  }
}

console.log('--- Initializing Components ---');
let comp1 = new MyComponent('A');
let comp2 = new MyComponent('B');

console.log('\n--- Mounting Components ---');
comp1.mount();
comp2.mount();

console.log(`Is comp1 active? ${activeComponents.has(comp1)}`); // true
console.log(`Comp1 state:`, comp1.getState());

setTimeout(() => {
  console.log('\n--- Unmounting Component A ---');
  comp1.unmount();
  // After unmount, if comp1 loses all strong references, its private data and the component itself
  // will be eligible for GC, and removed from componentPrivateData and activeComponents.
  comp1 = null; // Release strong reference

  console.log(`Is comp1 active? ${activeComponents.has(comp1)} (should be false for null)`); // false because comp1 is now null

  // To demonstrate the weak behavior, we need to consider 'comp2' still active
  console.log(`Is comp2 active? ${activeComponents.has(comp2)}`); // true

  // After some time, comp2 will also lose its strong reference
  setTimeout(() => {
    console.log('\n--- Releasing strong reference to Component B ---');
    comp2.unmount(); // Unmount to clean up internal hooks
    comp2 = null; // Release strong reference

    console.log(`Is comp2 active? ${activeComponents.has(comp2)} (should be false for null)`);

    console.log('\n--- Final check after all references released (simulated GC) ---');
    // At this point, no component instances should be strongly referenced.
    // Their private data and active tracking entries will be automatically cleaned up by GC.

  }, 2000);

}, 2000);