/*
 * Pre-ES6 Constructor Function - The Prototype Foundation
 * This demonstrates the underlying mechanism that ES6 classes simplify.
 */

// 1. Define a constructor function to act as a blueprint for objects.
function Animal(name, species) {
    this.name = name; // Properties are directly assigned to the instance.
    this.species = species;
}

// 2. Add methods to the constructor's prototype to ensure they are shared
//    across all instances, optimizing memory usage.
Animal.prototype.introduce = function() {
    return `Hello, my name is ${this.name} and I am a ${this.species}.`;
};

Animal.prototype.makeSound = function() {
    console.log(`The ${this.species} makes a sound.`);
};

// 3. Instantiate objects using the 'new' keyword.
const lion = new Animal("Leo", "lion");
const tiger = new Animal("Tigra", "tiger");

// 4. Invoke methods on the created instances.
console.log(lion.introduce()); // Expected Output: Hello, my name is Leo and I am a lion.
lion.makeSound();           // Expected Output: The lion makes a sound.
console.log(tiger.introduce()); // Expected Output: Hello, my name is Tigra and I am a tiger.

// 5. Verify the prototype chain: Instances inherit from the constructor's prototype.
console.log(Object.getPrototypeOf(lion) === Animal.prototype); // Expected Output: true
console.log(lion instanceof Animal);                         // Expected Output: true

/*
 * ES6 Class Declaration - Syntactic Sugar in Action
 * This illustrates how the 'class' keyword simplifies object blueprinting
 * compared to the pre-ES6 constructor functions.
 */

// 1. Declare a class using the 'class' keyword.
class Vehicle {
    // 2. Define the 'constructor' method: this special method is called
    //    automatically when a new instance of the class is created.
    constructor(make, model, year) {
        // 'this' refers to the newly created instance.
        this.make = make;
        this.model = model;
        this.year = year;
    }

    // 3. Define instance methods directly within the class body.
    //    These methods are automatically added to the class's prototype.
    getDetails() {
        return `${this.year} ${this.make} ${this.model}`;
    }

    startEngine() {
        console.log(`${this.model}'s engine starting...`);
    }
}

// 4. Instantiate an object from the class using the 'new' keyword.
const myCar = new Vehicle("Toyota", "Camry", 2023);
const anotherCar = new Vehicle("Honda", "Civic", 2022);

// 5. Invoke methods on the created instances.
console.log(myCar.getDetails());     // Expected Output: 2023 Toyota Camry
myCar.startEngine();                 // Expected Output: Camry's engine starting...
console.log(anotherCar.getDetails()); // Expected Output: 2022 Honda Civic

// 6. Verify that the prototype relationship persists, demonstrating the 'sugar'.
console.log(Object.getPrototypeOf(myCar) === Vehicle.prototype); // Expected Output: true

/*
 * Class with Static Methods - Utility Functions
 * Static methods are associated with the class itself, not with its instances.
 * They are ideal for utility functions, factory methods, or properties that
 * don't require instance-specific data.
 */

// 1. Define a class.
class MathOperations {
    // 2. Define a static property (ES2022 proposal) - accessible directly on the class.
    static PI = 3.14159;

    // 3. Define a static method using the 'static' keyword.
    //    This method operates on inputs, not on instance data.
    static add(a, b) {
        return a + b;
    }

    // 4. Another static method demonstrating internal class reference.
    static calculateCircleArea(radius) {
        // 'this' inside a static method refers to the class constructor itself.
        return this.PI * radius * radius;
    }

    // 5. A static factory method: a common use case for creating instances
    //    or returning utility objects based on specific criteria.
    static createSimpleCalculator() {
        console.log("Creating a conceptual MathOperations utility object.");
        return {
            sum: (a, b) => MathOperations.add(a, b), // Referencing other static methods
            area: (r) => MathOperations.calculateCircleArea(r)
        };
    }

    // 6. An instance method (for contrast) - requires an instance to be called.
    subtract(a, b) {
        return a - b;
    }
}

// 7. Call static methods directly on the class name.
console.log("Static Addition:", MathOperations.add(10, 5)); // Expected Output: Static Addition: 15
console.log("Static Circle Area:", MathOperations.calculateCircleArea(5)); // Expected Output: Static Circle Area: 78.53975

// 8. Use the static factory method.
const calculator = MathOperations.createSimpleCalculator();
console.log("Calculator Sum:", calculator.sum(7, 3)); // Expected Output: Calculator Sum: 10

// 9. Access a static property.
console.log("Value of PI:", MathOperations.PI); // Expected Output: Value of PI: 3.14159

// 10. To call an instance method, you first need an instance.
const myMath = new MathOperations();
console.log("Instance Subtraction:", myMath.subtract(10, 4)); // Expected Output: Instance Subtraction: 6

// 11. Attempting to call an instance method on the class itself will result in an error.
// console.log(MathOperations.subtract(5, 2)); // TypeError: MathOperations.subtract is not a function

/*
 * Class Inheritance with 'extends' and 'super'
 * This demonstrates how to create a class hierarchy, allowing a child class
 * to inherit and extend functionality from a parent class.
 */

// 1. Define the Parent Class (Base Class).
class Person {
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }

    greet() {
        return `Hello, my name is ${this.name}.`;
    }

    introduceSelf() {
        return `I am ${this.name}, and I am ${this.age} years old.`;
    }
}

// 2. Define the Child Class (Derived Class) using the 'extends' keyword.
//    Developer inherits properties and methods from Person.
class Developer extends Person {
    constructor(name, age, primaryLanguage, yearsOfExperience) {
        // 3. Crucially, call 'super()' before using 'this' in the child constructor.
        //    'super()' invokes the parent class's constructor.
        super(name, age);
        // 4. Add new properties specific to the Developer class.
        this.primaryLanguage = primaryLanguage;
        this.yearsOfExperience = yearsOfExperience;
    }

    // 5. Define new methods specific to the Developer class.
    code() {
        return `${this.name} is coding in ${this.primaryLanguage}.`;
    }

    // 6. Override a parent method, and optionally use 'super.method()' to
    //    call the parent's version and extend its behavior.
    greet() {
        const parentGreeting = super.greet(); // Call parent's greet method
        return `${parentGreeting} I am a ${this.primaryLanguage} developer with ${this.yearsOfExperience} years of experience.`;
    }

    // 7. Demonstrate another method specific to the child class.
    mentorJunior() {
        console.log(`${this.name} is mentoring a junior developer in ${this.primaryLanguage}.`);
    }
}

// 8. Instantiate objects from both parent and child classes.
const alice = new Person("Alice", 30);
const bob = new Developer("Bob", 25, "JavaScript", 3);

// 9. Invoke methods and observe inheritance.
console.log(alice.greet());        // Expected Output: Hello, my name is Alice.
console.log(alice.introduceSelf()); // Expected Output: I am Alice, and I am 30 years old.

console.log(bob.greet());          // Expected Output: Hello, my name is Bob. I am a JavaScript developer with 3 years of experience.
console.log(bob.code());           // Expected Output: Bob is coding in JavaScript.
bob.mentorJunior();                // Expected Output: Bob is mentoring a junior developer in JavaScript.
console.log(bob.introduceSelf());  // Expected Output: I am Bob, and I am 25 years old. (Inherited from Person)

// 10. Verify the inheritance chain using 'instanceof'.
console.log(bob instanceof Developer); // Expected Output: true
console.log(bob instanceof Person);    // Expected Output: true
console.log(alice instanceof Developer); // Expected Output: false

/*
 * Advanced Nuances: Composition over Inheritance, Private Fields, and 'this' Binding
 * This section explores more advanced concepts for robust class design and usage.
 */

// 1. Composition over Inheritance: Favoring 'has-a' relationships over deep 'is-a' hierarchies.
//    Example: A UserProcessor 'has-a' Logger and 'has-a' Authenticator.

class Logger {
    log(message) {
        console.log(`[LOG] ${message}`);
    }
}

class Authenticator {
    authenticate(username, password) {
        if (username === "admin" && password === "securepass") {
            this.log("Authentication successful."); // 'this' context here refers to Authenticator
            return true;
        }
        this.log("Authentication failed for user: " + username + ".");
        return false;
    }
    // Composed objects might also have their own dependencies or methods
    log(msg) { new Logger().log(msg); } // Example of Authenticator using a Logger internally
}

class UserProcessor {
    constructor() {
        this.logger = new Logger(); // Composition: UserProcessor 'has a' Logger
        this.authenticator = new Authenticator(); // Composition: UserProcessor 'has an' Authenticator
    }

    processUser(username, password) {
        this.logger.log(`Attempting to process user: ${username}`);
        if (this.authenticator.authenticate(username, password)) {
            this.logger.log(`User ${username} processed successfully.`);
            return true;
        }
        this.logger.log(`Failed to process user: ${username}.`);
        return false;
    }
}

const userProcessor = new UserProcessor();
userProcessor.processUser("admin", "securepass"); // Expected: LOG, Authentication successful., LOG, User admin processed successfully.
userProcessor.processUser("guest", "wrong");    // Expected: LOG, Authentication failed for user: guest., LOG, Failed to process user: guest..


// 2. Private Class Fields (ES2022+): True encapsulation for class members.
//    Prefix with '#' to define private fields, only accessible from within the class.

class BankAccount {
    #balance; // Private field, cannot be accessed from outside the class
    #accountNumber; // Another private field

    constructor(initialBalance, accountNumber) {
        if (initialBalance < 0) throw new Error("Initial balance cannot be negative.");
        this.#balance = initialBalance;
        this.#accountNumber = accountNumber;
        this.#logCreation(); // Call a private method
    }

    #logCreation() { // Private method
        this.deposit(0); // Calling a public method from a private one
        new Logger().log(`Account #${this.#accountNumber} created with balance ${this.#balance}.`);
    }

    deposit(amount) {
        if (amount > 0) {
            this.#balance += amount;
            new Logger().log(`Account #${this.#accountNumber}: Deposited ${amount}. New balance: ${this.#balance}`);
        } else {
            new Logger().log(`Account #${this.#accountNumber}: Invalid deposit amount.`);
        }
    }

    withdraw(amount) {
        if (amount > 0 && amount <= this.#balance) {
            this.#balance -= amount;
            new Logger().log(`Account #${this.#accountNumber}: Withdrew ${amount}. New balance: ${this.#balance}`);
        } else {
            new Logger().log(`Account #${this.#accountNumber}: Insufficient funds or invalid amount for withdrawal of ${amount}.`);
        }
    }

    getAccountInfo() {
        // Public method can access private fields from within the class.
        return `Account Number: ${this.#accountNumber}, Current Balance: ${this.#balance}`;
    }
}

console.log('\n--- Bank Account Example ---');
const mySavings = new BankAccount(500, '12345');
mySavings.deposit(150);
mySavings.withdraw(75);
console.log(mySavings.getAccountInfo()); // Expected: Account Number: 12345, Current Balance: 575

// Attempting to access private fields directly will cause a SyntaxError or be undefined.
// console.log(mySavings.#balance); // SyntaxError: Private field '#balance' must be declared in an enclosing class
// console.log(mySavings.balance); // undefined (if #balance was the only way to store it)


// 3. 'this' Binding Nuances: Be mindful when passing class methods as callbacks.

class Button {
    constructor(label) {
        this.label = label;
        this.clicks = 0;
    }

    // Method with 'this' context
    handleClick() {
        this.clicks++;
        console.log(`${this.label} clicked! Total clicks: ${this.clicks}`);
    }

    // Method with 'this' context bound in constructor (best practice for callbacks)
    handleBoundClick = () => {
        this.clicks++;
        console.log(`${this.label} (bound) clicked! Total clicks: ${this.clicks}`);
    };
}

console.log('\n--- 'this' Binding Example ---');
const myButton = new Button("Submit");

// Problem: If handleClick is passed directly as a callback, 'this' context is lost.
const detachedClick = myButton.handleClick;
// detachedClick(); // TypeError: Cannot read properties of undefined (reading 'clicks') - 'this' is undefined or global object

// Solution 1: Use .bind() when passing the method
const boundClick = myButton.handleClick.bind(myButton);
boundClick(); // Expected: Submit clicked! Total clicks: 1
boundClick(); // Expected: Submit clicked! Total clicks: 2

// Solution 2: Use arrow function as a class property (binds 'this' lexically).
myButton.handleBoundClick(); // Expected: Submit (bound) clicked! Total clicks: 1