/*
 * The Fragile Base Class Problem: An Inheritance Pitfall
 * Modifying 'Vehicle' can unintentionally break 'Car' or 'Truck'.
 * This demonstrates tight coupling and lack of flexibility inherent in deep inheritance.
 */

// Base Class
class Vehicle {
    constructor(make, model) {
        this.make = make;
        this.model = model;
        this.engineStatus = 'off';
    }

    startEngine() {
        this.engineStatus = 'on';
        console.log(`${this.make} ${this.model}'s engine is now ${this.engineStatus}.`);
    }

    stopEngine() {
        this.engineStatus = 'off';
        console.log(`${this.make} ${this.model}'s engine is now ${this.engineStatus}.`);
    }

    // Imagine adding a new method here, e.g., 'checkFuelLevel()'
    // This might require all subclasses to adapt, even if irrelevant.
}

// Derived Class 1
class Car extends Vehicle {
    constructor(make, model, doors) {
        super(make, model);
        this.doors = doors;
    }

    honk() {
        console.log('Beep beep!');
    }

    // Problem: If Vehicle.startEngine changes its signature, Car breaks.
    // Or if Vehicle adds a method with the same name as one in Car.
}

// Derived Class 2
class Truck extends Vehicle {
    constructor(make, model, payloadCapacity) {
        super(make, model);
        this.payloadCapacity = payloadCapacity;
    }

    haul() {
        console.log(`Hauling ${this.payloadCapacity} tons.`);
    }
}

const myCar = new Car('Toyota', 'Camry', 4);
myCar.startEngine(); // Output: Toyota Camry's engine is now on.
myCar.honk();        // Output: Beep beep!

const myTruck = new Truck('Ford', 'F-150', 2);
myTruck.startEngine(); // Output: Ford F-150's engine is now on.
myTruck.haul();        // Output: Hauling 2 tons.


/*
 * Contrast with a compositional approach using functions/objects for 'Engine' functionality.
 * This allows 'Car' and 'Truck' to combine 'Engine' behavior without rigid inheritance.
 */

// A reusable piece of behavior: The engine functionality
const canManageEngine = (obj) => ({
    engineStatus: 'off',
    startEngine() {
        this.engineStatus = 'on';
        console.log(`${obj.make} ${obj.model}'s engine is now ${this.engineStatus}.`);
    },
    stopEngine() {
        this.engineStatus = 'off';
        console.log(`${obj.make} ${obj.model}'s engine is now ${this.engineStatus}.`);
    }
});

// Factory function for creating a Car with engine management
const createCar = (make, model, doors) => {
    const car = { make, model, doors };
    return Object.assign(car, canManageEngine(car), {
        honk: () => console.log('Beep beep!')
    });
};

// Factory function for creating a Truck with engine management
const createTruck = (make, model, payloadCapacity) => {
    const truck = { make, model, payloadCapacity };
    return Object.assign(truck, canManageEngine(truck), {
        haul: () => console.log(`Hauling ${payloadCapacity} tons.`)
    });
};

const compCar = createCar('Honda', 'Civic', 4);
compCar.startEngine(); // Output: Honda Civic's engine is now on.
compCar.honk();        // Output: Beep beep!

const compTruck = createTruck('Chevy', 'Silverado', 3);
compTruck.startEngine(); // Output: Chevy Silverado's engine is now on.
compTruck.haul();        // Output: Hauling 3 tons.

// Advantage: If 'canManageEngine' changes, only that specific function needs modification.
// 'createCar' and 'createTruck' remain unaffected unless they explicitly use the changed part.
// We can also combine 'canManageEngine' with *any* object, not just those inheriting from 'Vehicle'.

/*
 * Forging Modular Systems with Mixins and Factory Functions
 * This example demonstrates combining distinct behaviors using composition,
 * allowing granular control over an object's capabilities.
 */

// Mixin 1: Behavior for logging messages
const canLog = (state) => ({
    log: (message) => console.log(`[LOG - ${state.name}]: ${message}`)
});

// Mixin 2: Behavior for saving data
const canSave = (state) => ({
    save: (data) => {
        console.log(`[SAVE - ${state.name}]: Saving data: ${JSON.stringify(data)}`);
        // In a real application, this would interact with a database or API.
        state.lastSavedData = data; // Store some state
    }
});

// Mixin 3: Behavior for sending notifications
const canNotify = (state) => ({
    notify: (user, message) => console.log(`[NOTIFY - ${state.name}]: Sending to ${user}: ${message}`)
});

// Factory Function 1: Creates a 'UserSession' object by composing behaviors
const createUserSession = (id, name) => {
    const state = { id, name };
    return Object.assign(state, canLog(state), canSave(state));
};

// Activate UserSession and demonstrate composed behaviors
const session1 = createUserSession('usr_001', 'Alice');
session1.log('User logged in.');
session1.save({ activity: 'browsing', timestamp: new Date() });
console.log(session1.lastSavedData); // Access state modified by mixin


// Factory Function 2: Creates an 'AdminPanel' object with different behaviors
const createAdminPanel = (panelName, adminUser) => {
    const state = { name: panelName, adminUser };
    return Object.assign(state, canLog(state), canNotify(state));
};

// Activate AdminPanel and demonstrate its unique set of behaviors
const adminPanel = createAdminPanel('SystemDashboard', 'Bob');
adminPanel.log('Admin accessed dashboard.');
adminPanel.notify('DevTeam', 'High CPU usage detected!');


// Factory Function 3: A 'ReportingService' that only logs and saves
const createReportingService = (serviceName) => {
    const state = { name: serviceName };
    return Object.assign(state, canLog(state), canSave(state));
};

const reportService = createReportingService('DailyReports');
reportService.log('Generating daily report...');
reportService.save({ reportsGenerated: 10, status: 'completed' });

/*
 * Key benefits demonstrated:
 * - Reusability: 'canLog' and 'canSave' are reused across different object types.
 * - Flexibility: Objects are built with only the necessary behaviors.
 * - Maintainability: Each behavior is self-contained and can be modified independently.
 * - No inheritance hierarchy: No 'AdminPanel extends UserSession' complexities.
 */

/*
 * Activating Functional Composition: Combining Pure Functions for Complex Logic
 * This example demonstrates how smaller, focused functions can be composed
 * to build complex data transformations in a declarative and robust manner.
 */

// Pure function: Adds a salutation to a name
const addSalutation = (name) => `Hello, ${name}`;

// Pure function: Capitalizes the first letter of each word
const capitalizeWords = (str) => str.split(' ')
    .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
    .join(' ');

// Pure function: Adds an exclamation mark
const addExclamation = (str) => `${str}!`

// Pure function: Trims whitespace
const trimWhitespace = (str) => str.trim();

// A basic 'compose' utility function (right-to-left execution)
// Can be found in libraries like Ramda or Redux if not implemented manually.
const compose = (...fns) => (x) => fns.reduceRight((v, f) => f(v), x);

// A basic 'pipe' utility function (left-to-right execution)
const pipe = (...fns) => (x) => fns.reduce((v, f) => f(v), x);


// Example 1: Composing functions to process a name (right-to-left)
const formatGreeting = compose(addExclamation, capitalizeWords, addSalutation, trimWhitespace);

console.log(formatGreeting('   john doe   ')); // Output: Hello, John Doe!
console.log(formatGreeting('   jane smith   ')); // Output: Hello, Jane Smith!


// Example 2: Pipelining data transformation (left-to-right)
const processUserData = pipe(
    (user) => ({ ...user, name: user.name.toUpperCase() }), // Uppercase name
    (user) => ({ ...user, age: user.age + 1 }),            // Increment age
    (user) => ({ ...user, status: 'processed' })           // Add status
);

const rawUser = { name: 'alice', age: 29 };
const processedUser = processUserData(rawUser);
console.log(processedUser); // Output: { name: 'ALICE', age: 30, status: 'processed' }


/*
 * Currying example: Creating specialized functions from generic ones
 */

// Generic 'add' function
const add = (a, b) => a + b;

// Curried version of 'add'
const curriedAdd = (a) => (b) => a + b;

const addFive = curriedAdd(5); // Specialized function: always adds 5
console.log(addFive(10));      // Output: 15
console.log(addFive(20));      // Output: 25

const addTen = curriedAdd(10); // Another specialized function
console.log(addTen(3));        // Output: 13

/*
 * Benefits:
 * - Declarative: Describes *what* to do, not *how*.
 * - Reusable: Small functions are easily combined in different ways.
 * - Testable: Pure functions are easy to test in isolation.
 * - Predictable: No side effects, given the same input, always the same output.
 */

/*
 * Strategizing Scalable Architectures: Advanced Composition with a 'Builder' pattern
 * This example demonstrates building a complex object step-by-step using composition,
 * allowing for highly configurable and extensible object creation.
 */

// Component 1: Basic user characteristics
const createUserState = (id, name) => ({ id, name, type: 'user' });

// Component 2: Adds authentication capabilities
const authenticateUser = (state) => ({
    ...state,
    isAuthenticated: false,
    login: () => { state.isAuthenticated = true; console.log(`${state.name} logged in.`); },
    logout: () => { state.isAuthenticated = false; console.log(`${state.name} logged out.`); }
});

// Component 3: Adds authorization capabilities (e.g., roles)
const authorizeUser = (state, roles = []) => ({
    ...state,
    roles: roles,
    hasRole: (role) => state.roles.includes(role)
});

// Component 4: Adds logging capabilities (reusing canLog from previous example)
const canLog = (state) => ({
    log: (message) => console.log(`[LOG - ${state.name}]: ${message}`)
});


// Advanced Composition: The UserBuilder Factory Function
// This factory uses an internal state and methods to progressively build a user object.
const UserBuilder = (id, name) => {
    let user = createUserState(id, name);

    return {
        withAuthentication() {
            user = authenticateUser(user);
            return this; // Allows method chaining
        },
        withAuthorization(roles) {
            user = authorizeUser(user, roles);
            return this;
        },
        withLogging() {
            user = canLog(user);
            return this;
        },
        build() {
            return user; // Returns the final composed object
        }
    };
};

// Example 1: Building a standard authenticated user
const standardUser = UserBuilder('usr_002', 'Charlie')
    .withAuthentication()
    .withLogging()
    .build();

standardUser.login();           // Output: Charlie logged in.
standardUser.log('Accessed dashboard.'); // Output: [LOG - Charlie]: Accessed dashboard.
console.log(standardUser.isAuthenticated); // Output: true


// Example 2: Building an administrator user with auth, roles, and logging
const adminUser = UserBuilder('adm_001', 'Diana')
    .withAuthentication()
    .withAuthorization(['admin', 'editor'])
    .withLogging()
    .build();

adminUser.login();              // Output: Diana logged in.
adminUser.log('Performed critical operation.'); // Output: [LOG - Diana]: Performed critical operation.
console.log(adminUser.hasRole('admin'));     // Output: true
console.log(adminUser.hasRole('viewer'));    // Output: false


// Example 3: A simple, non-authenticated user (only base state)
const guestUser = UserBuilder('gst_001', 'Eve')
    .build();

// guestUser does not have login/logout methods, which is expected.
// guestUser.login(); // This would throw an error, correctly indicating missing functionality.
console.log(guestUser.name); // Output: Eve
console.log(guestUser.type); // Output: user

/*
 * This 'UserBuilder' pattern demonstrates:
 * - Granular control over object capabilities.
 * - Clear separation of concerns: each 'withX' method adds a specific feature.
 * - Extensibility: New features can be added as new 'withY' methods easily.
 * - Readability: The composition process is explicit and easy to understand.
 */