// Base class
class Vehicle {
  drive() {
    console.log("Driving at a speed of 60 km/h");
  }
}
// Subclass 1: PassengerVehicle
class PassengerVehicle extends Vehicle {
  // No need to override the drive() method as the base implementation is suitable
}
// Subclass 2: OffRoadVehicle
class OffRoadVehicle extends Vehicle {
  drive() {
    console.log("Driving off-road at a speed of 30 km/h");
  }
}
// Subclass 3: SportsVehicle
class SportsVehicle extends Vehicle {
  drive() {
    console.log("Driving at a high speed of 120 km/h");
  }
}
// Creating instances
const passengerVehicle = new PassengerVehicle();
const offRoadVehicle = new OffRoadVehicle();
const sportsVehicle = new SportsVehicle();
// Calling the drive method
passengerVehicle.drive(); // Output: Driving at a speed of 60 km/h
offRoadVehicle.drive();   // Output: Driving off-road at a speed of 30 km/h
sportsVehicle.drive();    // Output: Driving at a high speed of 120 km/h

// Strategy interface
class FuelStrategy {
  changeFuel() {
    throw new Error("This method should be overridden");
  }
}
// Concrete strategy for electric fuel
class ElectricFuelStrategy extends FuelStrategy {
  changeFuel() {
    console.log("Changing fuel to electric...");
  }
}

// Vehicle superclass
class Vehicle {
  constructor(fuelStrategy = null) {
    this.fuelStrategy = fuelStrategy;
  }
  drive() {
    console.log("Driving at 60 km/h");
  }
  performChangeFuel() {
    if (this.fuelStrategy) {
      this.fuelStrategy.changeFuel();
    } else {
      console.log("This vehicle does not support changing fuel.");
    }
  }
}

// Strategy interface
class FuelStrategy {
  changeFuel() {
    throw new Error("This method should be overridden");
  }
}
// Concrete strategy for electric fuel
class ElectricFuelStrategy extends FuelStrategy {
  changeFuel() {
    console.log("Changing fuel to electric...");
  }
}
// Vehicle superclass
class Vehicle {
  constructor(fuelStrategy = null) {
    this.fuelStrategy = fuelStrategy;
  }
  drive() {
    console.log("Driving at 60 km/h");
  }
  performChangeFuel() {
    if (this.fuelStrategy) {
      this.fuelStrategy.changeFuel();
    } else {
      console.log("This vehicle does not support changing fuel.");
    }
  }
}
// Subclass for PassengerVehicle
class PassengerVehicle extends Vehicle {
  constructor() {
    super(new ElectricFuelStrategy()); // Injecting the electric fuel strategy
  }
}
// Subclass for SportsVehicle
class SportsVehicle extends Vehicle {
  constructor() {
    super(new ElectricFuelStrategy()); // Injecting the electric fuel strategy
  }
  drive() {
    console.log("Driving at 200 km/h");
  }
}
// Usage
const passengerVehicle = new PassengerVehicle();
passengerVehicle.drive();             // Output: Driving at 60 km/h
passengerVehicle.performChangeFuel(); // Output: Changing fuel to electric...
const sportsVehicle = new SportsVehicle();
sportsVehicle.drive();                // Output: Driving at 200 km/h
sportsVehicle.performChangeFuel();    // Output: Changing fuel to electric...

// Vehicle Interface
class Vehicle {
  getSeatingCapacity() {
    throw new Error("This method should be overridden");
  }
  getTankCapacity() {
    throw new Error("This method should be overridden");
  }
}
// Concrete Vehicle Classes
class Car extends Vehicle {
  getSeatingCapacity() {
    return 5;
  }
  getTankCapacity() {
    return 50;
  }
}
class Bike extends Vehicle {
  getSeatingCapacity() {
    return 2;
  }
  getTankCapacity() {
    return 15;
  }
}
// Vehicle Factory
class VehicleFactory {
  static createVehicle(type) {
    if (type === "Car") {
      return new Car();
    } else if (type === "Bike") {
      return new Bike();
    } else {
      return null;
    }
  }
}
// Main Class
class Main {
  static print(vehicleType) {
    const vehicleClass = VehicleFactory.createVehicle(vehicleType);
    this.printVehicleDetails(vehicleClass);
  }
  static printVehicleDetails(vehicleClass) {
    if (vehicleClass) {
      console.log(`Seating Capacity: ${vehicleClass.getSeatingCapacity()}`);
      console.log(`Tank Capacity: ${vehicleClass.getTankCapacity()}`);
    } else {
      console.log("Invalid vehicle type provided.");
    }
  }
}
// Example usage
Main.print("Car");  // Output: Seating Capacity: 5, Tank Capacity: 50
Main.print("Bike"); // Output: Seating Capacity: 2, Tank Capacity: 15
Main.print("Truck"); // Output: Invalid vehicle type provided.

// Vehicle Interface
class Vehicle {
  getSeatingCapacity() {
    throw new Error("This method should be overridden");
  }
  getTankCapacity() {
    throw new Error("This method should be overridden");
  }
}
// Concrete Vehicle Classes
class Car extends Vehicle {
  getSeatingCapacity() {
    return 5;
  }
  getTankCapacity() {
    return 50;
  }
}
class Bike extends Vehicle {
  getSeatingCapacity() {
    return 2;
  }
  getTankCapacity() {
    return 15;
  }
}
// Null Object Class
class NullVehicle extends Vehicle {
  getSeatingCapacity() {
    return 0; // Default or "do-nothing" behavior
  }
  getTankCapacity() {
    return 0; // Default or "do-nothing" behavior
  }
}
// Vehicle Factory
class VehicleFactory {
  static createVehicle(type) {
    if (type === "Car") {
      return new Car();
    } else if (type === "Bike") {
      return new Bike();
    } else {
      return new NullVehicle(); // Returning Null Object instead of null
    }
  }
}
// Main Class
class Main {
  static print(vehicleType) {
    const vehicleClass = VehicleFactory.createVehicle(vehicleType);
    this.printVehicleDetails(vehicleClass);
  }
  static printVehicleDetails(vehicleClass) {
    console.log(`Seating Capacity: ${vehicleClass.getSeatingCapacity()}`);
    console.log(`Tank Capacity: ${vehicleClass.getTankCapacity()}`);
  }
}
// Usage
Main.print("Car");
// Output: 
// Seating Capacity: 5
// Tank Capacity: 50
Main.print("Bike");
// Output:
// Seating Capacity: 2
// Tank Capacity: 15
Main.print("Truck");
// Output:
// Seating Capacity: 0
// Tank Capacity: 0

class AirConditioner {
  constructor() {
    this.isOn = false;          // Initial state of the AC is OFF
    this.temperature = 24;      // Default temperature
  }
  turnOn() {
    this.isOn = true;
    console.log("The AC is now ON.");
  }
  turnOff() {
    this.isOn = false;
    console.log("The AC is now OFF.");
  }
  setTemperature(temp) {
    this.temperature = temp;
    console.log(`The temperature is set to ${temp}°C.`);
  }
}
// Example usage
const myAC = new AirConditioner();
myAC.turnOn();               // Output: The AC is now ON.
myAC.setTemperature(22);     // Output: The temperature is set to 22°C.
myAC.turnOff();              // Output: The AC is now OFF.

// Command Interface
class Command {
    execute() {
        throw new Error("This method should be overridden");
    }
    undo() {
        throw new Error("This method should be overridden");
    }
}

// Concrete Command Class to turn on the Air Conditioner
class TurnOnCommand extends Command {
    constructor(ac) {
        super();
        this.ac = ac; // The air conditioner instance to control
    }
    execute() {
        this.ac.turnOn(); // Execute the command to turn on the AC
    }
    undo() {
        this.ac.turnOff(); // Undo the command to turn off the AC
    }
}
// Concrete Command Class to turn off the Air Conditioner
class TurnOffCommand extends Command {
    constructor(ac) {
        super();
        this.ac = ac; // The air conditioner instance to control
    }
    execute() {
        this.ac.turnOff(); // Execute the command to turn off the AC
    }
    undo() {
        this.ac.turnOn(); // Undo the command to turn on the AC
    }
}
// Concrete Command Class to set the temperature of the Air Conditioner
class SetTemperatureCommand extends Command {
    constructor(ac, temperature) {
        super();
        this.ac = ac; // The air conditioner instance to control
        this.temperature = temperature; // The desired temperature to set
        this.prevTemperature = ac.temperature; // Store the previous temperature for undo
    }
    execute() {
        this.ac.setTemperature(this.temperature); // Execute the command to set the temperature
    }
    undo() {
        this.ac.setTemperature(this.prevTemperature); // Undo by resetting to the previous temperature
    }
}

// Invoker Class for executing commands
class RemoteControl {
    constructor() {
        this.commandStack = []; // Stack to keep track of executed commands
    }
    // Set the command to be executed
    setCommand(command) {
        this.command = command;
    }
    // Execute the command and store it in the stack
    pressButton() {
        this.command.execute(); // Execute the current command
        this.commandStack.push(this.command); // Store the executed command for undo
    }
    // Undo the last executed command
    pressUndo() {
        if (this.commandStack.length > 0) {
            const lastCommand = this.commandStack.pop(); // Get the last command from the stack
            lastCommand.undo(); // Call the undo method of the last executed command
        } else {
            console.log("Nothing to undo."); // Message if there's nothing to undo
        }
    }
}

// Main execution
const ac = new AirConditioner();
const remote = new RemoteControl();
// Create command instances
const turnOn = new TurnOnCommand(ac);
const turnOff = new TurnOffCommand(ac);
const setTemp = new SetTemperatureCommand(ac, 22);
// Use the remote to execute commands
remote.setCommand(turnOn);
remote.pressButton(); // Output: The AC is now ON.
remote.setCommand(setTemp);
remote.pressButton(); // Output: The temperature is set to 22°C.
remote.setCommand(turnOff);
remote.pressButton(); // Output: The AC is now OFF.
// Using the undo functionality
remote.pressUndo(); // Output: The AC is now ON.
remote.pressUndo(); // Output: The temperature is set to 24°C.
remote.pressUndo(); // Output: The AC is now OFF.

const array = [10, 20, 30]; // Create an array
const iterator = array[Symbol.iterator](); // Get the iterator for the array
// Iterate through the array using the iterator
console.log(iterator.next()); // { value: 10, done: false }
console.log(iterator.next()); // { value: 20, done: false }
console.log(iterator.next()); // { value: 30, done: false }
console.log(iterator.next()); // { value: undefined, done: true }

// Using an iterator with a string
const str = "hello"; // Create a string
const stringIterator = str[Symbol.iterator](); // Get the iterator for the string
console.log(stringIterator.next()); // { value: 'h', done: false }
console.log(stringIterator.next()); // { value: 'e', done: false }
// Using an iterator with a Map
const map = new Map(); // Create a Map
map.set('a', 1); // Set key-value pairs
map.set('b', 2);
const mapIterator = map[Symbol.iterator](); // Get the iterator for the Map
console.log(mapIterator.next()); // { value: [ 'a', 1 ], done: false }
console.log(mapIterator.next()); // { value: [ 'b', 2 ], done: false }

// Abstract Iterator
class Iterator {
    next() {
        throw new Error("Method 'next()' must be implemented.");
    }
    hasNext() {
        throw new Error("Method 'hasNext()' must be implemented.");
    }
}
// Concrete Iterator
class ConcreteIterator extends Iterator {
    constructor(collection) {
        super();
        this.collection = collection;
        this.index = 0; // Start from the first element
    }
    next() {
        if (this.hasNext()) {
            return this.collection[this.index++];
        }
        return null; // Return null if no next element
    }
    hasNext() {
        return this.index < this.collection.length; // Check if more elements exist
    }
}
// Abstract Aggregate Class
class Aggregate {
    createIterator() {
        throw new Error("Method 'createIterator()' must be implemented.");
    }
}
// Concrete Aggregate Class
class ConcreteAggregate extends Aggregate {
    constructor(collection) {
        super();
        this.collection = collection; // Store the collection
    }
    createIterator() {
        return new ConcreteIterator(this.collection); // Create a ConcreteIterator for the collection
    }
}
// Creating a collection
const numbers = [1, 2, 3, 4, 5];
// Creating a Concrete Aggregate instance
const aggregate = new ConcreteAggregate(numbers);
// Getting the iterator
const iterator = aggregate.createIterator();
// Traversing the collection
while (iterator.hasNext()) {
    console.log(iterator.next()); // Output: 1, 2, 3, 4, 5
}

// Abstract class
class Payment {
    processPayment() {
        this.validate();
        this.debit();
        this.calculateFee(); // This will call the overridden method
        this.credit();
    }
    validate() {
        console.log("Validating payment...");
    }
    debit() {
        console.log("Debiting amount...");
    }
    // This method will be overridden by subclasses
    calculateFee() {
        throw new Error("Method 'calculateFee()' must be implemented.");
    }
    credit() {
        console.log("Crediting amount...");
    }
}
// Subclass for peer-to-peer payment
class PayToFriend extends Payment {
    calculateFee() {
        console.log("No fees for friends.");
    }
}
// Subclass for merchant payment
class PayToMerchant extends Payment {
    calculateFee() {
        console.log("Calculating fee: 2% of the amount.");
    }
}
// Usage
const friendPayment = new PayToFriend();
friendPayment.processPayment();
// Output:
// Validating payment...
// Debiting amount...
// No fees for friends.
// Crediting amount...
const merchantPayment = new PayToMerchant();
merchantPayment.processPayment();
// Output:
// Validating payment...
// Debiting amount...
// Calculating fee: 2% of the amount.
// Crediting amount...