/*
 * We allocate memory when we declare variables, functions, or objects.
 * The JavaScript engine automatically performs this allocation.
 */

// 1. Memory Allocation: Creating objects and variables
let user = {
    name: 'Ada Lovelace',
    age: 20,
    email: 'ada.lovelace@example.com'
};

let greeting = 'Hello, ' + user.name + '!';

console.log(greeting);

// 2. Memory Usage: Accessing properties or variables
function introduceUser(obj) {
    console.log(`User's name is ${obj.name} and email is ${obj.email}`);
}

introduceUser(user);

/*
 * 3. Memory Deallocation (Implicit in JS):
 * We dereference objects, making them unreachable. The Garbage Collector
 * then identifies and reclaims this memory automatically.
 */

// Making the 'user' object unreachable by overwriting the reference.
// The original object is now eligible for garbage collection.
user = null;

// Making 'greeting' unreachable if not used elsewhere.
greeting = undefined;

// The JavaScript engine decides when to run the GC.
// We cannot directly force GC in standard JS environments, but we engineer for it.

console.log("User and greeting references have been nullified. Memory is now eligible for reclamation.");

/*
 * The Mark Phase identifies all 'reachable' objects within the application's memory graph.
 * Reachable objects are those accessible from a set of 'roots'.
 */

// 1. Define Root Objects:
// These are objects guaranteed to be active and not collected.
// Examples: Global object (window/globalThis), variables on the current call stack.

let globalData = "This is global data"; // Part of the global scope, a root by extension

function processOrders() {
    let orderId = 'XYZ789'; // On the call stack, a temporary root
    let customer = {
        id: 101,
        name: 'Grace Hopper'
    };

    let productList = [
        { name: 'Laptop', price: 1200 },
        { name: 'Mouse', price: 25 }
    ];

    customer.orders = productList; // customer references productList
    productList.forEach(p => p.owner = customer); // Each product references customer (circular!)

    console.log(`Processing order ${orderId} for ${customer.name}.`);

    // 2. Mark Phase Logic (Conceptual):
    // The GC starts from 'root' objects (globalData, orderId, customer, productList inside this function).
    // It traverses the object graph, marking everything it can reach.
    // In this example:
    // - globalData is reachable.
    // - orderId is reachable (on stack).
    // - customer is reachable (on stack).
    // - productList is reachable (from customer).
    // - Laptop and Mouse objects are reachable (from productList).
    // - The circular references between customer and productList's items are handled;
    //   both are marked as reachable because they originate from a root (the function's scope).
}

processOrders();

// After processOrders() completes, its local variables (orderId, customer, productList)
// are no longer on the call stack. They become unreachable *unless* something outside
// the function scope still references them.

// Example of an object becoming unreachable after function execution:
function createDisposableObject() {
    let tempObject = { value: 'temporary' };
    return 'done';
}

let status = createDisposableObject();
// tempObject is no longer reachable from any root once createDisposableObject returns.
console.log("Disposable object's memory is now potentially reclaimable.");

/*
 * The Sweep Phase executes after marking, reclaiming memory from objects
 * that were not marked as reachable.
 */

let activeUsers = [];

function createUser(name) {
    let user = { name: name, id: Date.now() };
    activeUsers.push(user);
    return user;
}

// Create some users, keeping them 'active' via the activeUsers array (a root)
let user1 = createUser('Alice');
let user2 = createUser('Bob');

console.log("Initial active users:", activeUsers.map(u => u.name));

// Now, let's simulate some objects becoming unreachable.
// If user2 is no longer needed, we might remove its reference from activeUsers.
activeUsers = activeUsers.filter(u => u.id !== user2.id);

// If 'user2' variable itself is not referenced elsewhere,
// the object it pointed to is now unreachable from any root.
user2 = null;

console.log("Active users after removal:", activeUsers.map(u => u.name));

/*
 * Conceptual Sweep:
 * When the GC runs its sweep phase, it will iterate through the memory heap.
 * - Objects referenced by 'activeUsers' (e.g., user1) will be marked as reachable in the Mark Phase.
 * - The original object that 'user2' pointed to, now nullified and removed from 'activeUsers',
 *   will not be marked as reachable by the Mark Phase.
 * - During the Sweep Phase, the GC identifies this unmarked object and reclaims its memory.
 *   This memory then becomes available for new allocations.
 */

// We cannot explicitly trigger the sweep, but understanding the process helps.
console.log("The object previously referenced by 'user2' is now eligible for reclamation during the next GC cycle.");

/*
 * Engineering GC-Friendly Code means actively preventing memory leaks
 * and structuring our applications to minimize GC overhead.
 */

// 1. Common Memory Leak: Forgotten Timer/Interval
let leakyIntervalId;

function startLeakyTask() {
    let counter = 0;
    leakyIntervalId = setInterval(() => {
        counter++; // Closure keeps 'counter' alive
        console.log(`Leaky task running: ${counter}`);
        // If we navigate away or destroy the component,
        // this interval continues to run, holding references.
    }, 1000);
    console.log("Leaky interval started. ID: ", leakyIntervalId);
}

// To fix: Always clear intervals/timeouts when no longer needed.
function stopLeakyTask() {
    if (leakyIntervalId) {
        clearInterval(leakyIntervalId);
        console.log("Leaky interval stopped.");
    }
}

// Example usage:
// startLeakyTask();
// setTimeout(stopLeakyTask, 5000); // Stop after 5 seconds to prevent continuous leak


// 2. Common Memory Leak: Detached DOM Nodes
// We must ensure that references to DOM nodes are released when the nodes are removed.
const container = document.createElement('div');
container.id = 'dom-container';
document.body.appendChild(container);

let globalDomRef = document.getElementById('dom-container'); // Strong reference

function removeDomNode() {
    if (globalDomRef && globalDomRef.parentNode) {
        globalDomRef.parentNode.removeChild(globalDomRef);
        console.log("DOM node removed from document.");
        // The node is removed, but 'globalDomRef' still holds a reference.
        // If 'globalDomRef' is not cleared, the node and its subtree are leaked.
        globalDomRef = null; // CRUCIAL: Release the reference
        console.log("Global DOM reference nullified.");
    }
}

// To demonstrate, uncomment these lines in a browser environment:
// removeDomNode();


// 3. Excessive Closures:
// Be mindful when creating many closures that capture large scopes.
function createHeavyClosure(largeArray) {
    return function() {
        console.log(`Array size: ${largeArray.length}`);
        // 'largeArray' is captured by the closure and stays in memory
        // as long as the returned function is referenced.
    };
}

const hugeData = new Array(1000000).fill('item');
let processor = createHeavyClosure(hugeData); // 'hugeData' is now potentially kept alive indefinitely

// To allow 'hugeData' to be collected, 'processor' must eventually be dereferenced:
// processor = null;
// console.log("Processor closure released.");

console.log("Memory leak prevention strategies implemented.");