/*
 * We begin by creating a simple object, then inspect its intrinsic prototype.
 * Every object, by its nature, links to another object: its prototype.
 * This initial prototype link is known as the [[Prototype]] internal slot.
 * In JavaScript, we access this link using Object.getPrototypeOf() or the non-standard __proto__ accessor.
 */

// 1. Create a simple object using object literal syntax.
const myObject = {
  value: 42
};

console.log("--- Part 1: Initial Object Inspection ---");
console.log("myObject:", myObject);

// 2. Accessing the prototype of `myObject`.
//    Object.getPrototypeOf() is the standard and recommended way.
const myObjectPrototype = Object.getPrototypeOf(myObject);
console.log("Prototype of myObject (via Object.getPrototypeOf()):", myObjectPrototype);

//    The __proto__ accessor is a legacy, non-standard way, but widely supported and useful for demonstration.
//    Avoid direct manipulation of __proto__ in production code for performance and maintainability reasons.
console.log("Prototype of myObject (via __proto__):", myObject.__proto__);

// 3. Confirming the prototype is Object.prototype for plain objects.
//    Plain objects created with {} or new Object() have Object.prototype as their direct prototype.
console.log("Is myObject's prototype === Object.prototype?", myObjectPrototype === Object.prototype);

// 4. Inspecting Object.prototype itself.
//    Object.prototype is the ultimate ancestor for most objects in JavaScript's prototype chain.
//    It contains fundamental methods like toString(), hasOwnProperty(), etc.
console.log("Object.prototype contains a 'toString' method:", typeof Object.prototype.toString);

// 5. The end of the chain: What is Object.prototype's prototype?
//    The prototype chain terminates at 'null'. There is no object beyond Object.prototype's prototype.
console.log("Prototype of Object.prototype:", Object.getPrototypeOf(Object.prototype));
console.log("Is Object.getPrototypeOf(Object.prototype) === null?", Object.getPrototypeOf(Object.prototype) === null);

/*
 * Key takeaway: Every object inherits from a prototype, forming a chain that eventually leads to null.
 * For plain objects, this chain typically starts at the object itself, then points to Object.prototype, then null.
 */

/*
 * We explore how JavaScript resolves property access by traversing the prototype chain.
 * When a property is requested on an object, the engine first checks the object itself.
 * If not found, it proceeds to the object's prototype, and then its prototype's prototype, until it finds the property or reaches null.
 */

// 1. Define a prototype object.
const animalPrototype = {
  breathe() {
    console.log("I am breathing.");
  },
  species: "Unknown"
};

console.log("\n--- Part 2: Forging Inheritance ---");
console.log("animalPrototype:", animalPrototype);

// 2. Create a 'dog' object, linking its prototype to animalPrototype.
//    Object.create() is the most direct way to specify an object's prototype.
const dog = Object.create(animalPrototype);
dog.name = "Buddy";
dog.bark = function() {
  console.log("Woof!");
};

console.log("dog object:", dog);
console.log("dog.__proto__ === animalPrototype?", dog.__proto__ === animalPrototype);

// 3. Demonstrate property lookup on the prototype chain.
//    'bark' is on 'dog' itself.
dog.bark();
//    'breathe' is not on 'dog', so it's found on 'animalPrototype'.
dog.breathe();
//    'species' is not on 'dog', so it's found on 'animalPrototype'.
console.log("Dog's species:", dog.species);

// 4. Demonstrate 'shadowing' properties.
//    Adding 'species' directly to 'dog' will 'shadow' the property on the prototype.
dog.species = "Canine";
console.log("Dog's species after shadowing:", dog.species); // Output: Canine
console.log("animalPrototype.species (unchanged):", animalPrototype.species); // Output: Unknown

// 5. Using hasOwnProperty() to differentiate between own properties and inherited properties.
console.log("dog has its own 'name' property?", dog.hasOwnProperty('name'));      // true
console.log("dog has its own 'bark' property?", dog.hasOwnProperty('bark'));      // true
console.log("dog has its own 'breathe' property?", dog.hasOwnProperty('breathe'));  // false (inherited)
console.log("dog has its own 'species' property?", dog.hasOwnProperty('species'));  // true (after shadowing)

// 6. Accessing a property that does not exist on the object or its prototype chain.
console.log("Dog's color (non-existent):", dog.color); // Output: undefined

/*
 * Key takeaway: The prototype chain is JavaScript's primary mechanism for property inheritance.
 * Properties are resolved by traversing this chain upwards until a match is found or the chain ends.
 * Shadowing allows specific instances to override inherited properties.
 * hasOwnProperty() is crucial for distinguishing own properties from inherited ones.
 */

/*
 * We explore the primary methods for engineering prototype chains:
 * 1. Constructor functions with the 'new' keyword: the traditional way.
 * 2. Object.create(): for direct, explicit prototype linking.
 */

console.log("\n--- Part 3: Engineering Prototypes ---");

// Section A: Constructor Functions and 'new'
// ------------------------------------------

// 1. Define a constructor function.
//    The 'prototype' property of a constructor function is what gets assigned as the __proto__
//    of objects created with 'new'.
function Person(name) {
  this.name = name;
}

// 2. Add methods to the constructor's prototype. These methods will be inherited by all instances.
Person.prototype.greet = function() {
  console.log(`Hello, my name is ${this.name}.`);
};

Person.prototype.species = "Homo Sapiens";

console.log("\n--- Using Constructor Functions ---");
console.log("Person.prototype:", Person.prototype);

// 3. Create an instance using the 'new' keyword.
//    'new' does three things:
//    a. Creates a new empty object.
//    b. Sets the new object's [[Prototype]] to Person.prototype.
//    c. Calls the constructor function with 'this' bound to the new object.
//    d. Returns the new object (unless the constructor explicitly returns another object).
const alice = new Person("Alice");

console.log("alice object:", alice);
console.log("alice.__proto__ === Person.prototype?", alice.__proto__ === Person.prototype); // true
alice.greet();
console.log("Alice's species:", alice.species);

// 4. Create another instance to show shared prototype methods.
const bob = new Person("Bob");
bob.greet();
console.log("Bob's species:", bob.species);

// Key point: alice.greet === bob.greet === Person.prototype.greet (reference equality)
console.log("Are greet methods the same function reference?", alice.greet === bob.greet); // true


// Section B: Object.create()
// --------------------------

// 1. Define a base object to serve as a prototype.
const vehicle = {
  drive() {
    console.log("Vroom!");
  },
  wheels: 4
};

console.log("\n--- Using Object.create() ---");
console.log("vehicle prototype:", vehicle);

// 2. Create a 'car' object with 'vehicle' as its prototype.
//    Object.create() explicitly sets the [[Prototype]] of the new object.
const car = Object.create(vehicle);
car.make = "Toyota";
car.model = "Corolla";

console.log("car object:", car);
console.log("car.__proto__ === vehicle?", car.__proto__ === vehicle); // true
car.drive();
console.log("Car wheels:", car.wheels);

// 3. Create a 'motorcycle' object inheriting from 'vehicle', but overriding a property.
const motorcycle = Object.create(vehicle);
motorcycle.make = "Harley-Davidson";
motorcycle.wheels = 2; // Overrides the 'wheels' property from 'vehicle'

console.log("motorcycle object:", motorcycle);
console.log("Motorcycle wheels:", motorcycle.wheels); // Output: 2 (shadowed)
console.log("vehicle.wheels (unchanged):", vehicle.wheels); // Output: 4

/*
 * Key takeaway: Constructor functions with 'new' automatically link instances to Constructor.prototype.
 * Object.create() provides explicit control over the prototype linkage for new objects.
 * Both are powerful tools for building robust inheritance hierarchies.
 */

/*
 * We confront advanced concepts, common pitfalls, and best practices for optimizing prototypal inheritance.
 * Understanding these aspects ensures robust, performant, and maintainable codebases.
 */

console.log("\n--- Part 4: Advanced Prototypal Mastery ---");

// Pitfall 1: Mutable Prototypes and Shared References
// --------------------------------------------------
// Modifying a prototype affects ALL objects that inherit from it.
// Be cautious when prototype properties are objects or arrays, as they become shared references.

function BugReport(title) {
  this.title = title;
}

// The 'comments' array is a shared reference across all BugReport instances.
BugReport.prototype.comments = [];
BugReport.prototype.addComment = function(comment) {
  this.comments.push(comment);
};

console.log("\n--- Shared Reference Pitfall ---");
const bug1 = new BugReport("Login Failure");
const bug2 = new BugReport("UI Glitch");

bug1.addComment("User reported issue.");
console.log("bug1 comments:", bug1.comments); // Output: [ 'User reported issue.' ]
console.log("bug2 comments (unexpected shared reference):", bug2.comments); // Output: [ 'User reported issue.' ]

// Correct approach: Initialize mutable properties within the constructor to ensure instance-specific data.
function CorrectBugReport(title) {
  this.title = title;
  this.comments = []; // Each instance gets its own array.
}

CorrectBugReport.prototype.addComment = function(comment) {
  this.comments.push(comment);
};

const bug3 = new CorrectBugReport("Performance Drop");
const bug4 = new CorrectBugReport("API Error");

bug3.addComment("Observed during load testing.");
console.log("bug3 comments (correct):", bug3.comments);
console.log("bug4 comments (correct, isolated):", bug4.comments); // Output: []


// Pitfall 2: Performance Implications of Deep Chains
// -------------------------------------------------
// While generally optimized, extremely deep prototype chains can slightly impact property lookup time.
// Prefer shallower hierarchies where logical, or cache frequently accessed properties.


// Best Practice: Modern Classes as Syntactic Sugar
// ------------------------------------------------
// ES6 'class' syntax provides a cleaner way to write constructor functions and prototype methods.
// It's entirely built on top of the prototypal inheritance model we've discussed.

class Animal {
  constructor(name) {
    this.name = name;
  }

  speak() {
    console.log(`${this.name} makes a sound.`);
  }
}

class Dog extends Animal {
  constructor(name, breed) {
    super(name);
    this.breed = breed;
  }

  speak() {
    console.log(`${this.name} (${this.breed}) barks!`);
  }

  fetch() {
    console.log(`${this.name} fetches the ball.`);
  }
}

console.log("\n--- ES6 Class Inheritance (Prototypal under the hood) ---");
const sparky = new Dog("Sparky", "Golden Retriever");
sparky.speak();  // Output: Sparky (Golden Retriever) barks!
sparky.fetch();

console.log("sparky.__proto__ === Dog.prototype?", sparky.__proto__ === Dog.prototype); // true
console.log("Dog.prototype.__proto__ === Animal.prototype?", Dog.prototype.__proto__ === Animal.prototype); // true
console.log("Animal.prototype.__proto__ === Object.prototype?", Animal.prototype.__proto__ === Object.prototype); // true


// Cautionary Note: Object.setPrototypeOf()
// ---------------------------------------
// While it allows dynamic modification of an object's prototype, it is generally discouraged
// for performance reasons and potential for breaking optimizations in JS engines.
// Use it only when absolutely necessary and understand the performance implications.

const oldObject = { a: 1 };
const newPrototype = { b: 2 };

console.log("\n--- Object.setPrototypeOf() (use with caution!) ---");
console.log("oldObject before setPrototypeOf:", Object.getPrototypeOf(oldObject));
Object.setPrototypeOf(oldObject, newPrototype);
console.log("oldObject after setPrototypeOf:", Object.getPrototypeOf(oldObject));
console.log("oldObject.b:", oldObject.b); // Output: 2

/*
 * Key takeaway: Be vigilant with mutable prototype properties (objects/arrays).
 * Modern 'class' syntax simplifies prototype-based inheritance.
 * Object.setPrototypeOf() is a powerful but potentially problematic tool; exercise extreme caution.
 */