Mediator Pattern

// Mediator Pattern Example

// Chat Room Mediator
class ChatRoom {
  constructor() {
    this.users = {};
    this.messageHistory = [];
  }
  
  register(user) {
    this.users[user.name] = user;
    user.setChatRoom(this);
    this.broadcast('system', `${user.name} has joined the chat`, user);
  }
  
  send(message, from, to = null) {
    const timestamp = new Date().toLocaleTimeString();
    const messageData = {
      from: from.name,
      to: to ? to.name : 'all',
      message,
      timestamp
    };
    
    this.messageHistory.push(messageData);
    
    if (to) {
      // Private message
      to.receive(`[Private from ${from.name}] ${message}`, timestamp);
      from.receive(`[Private to ${to.name}] ${message}`, timestamp);
    } else {
      // Broadcast to all users except sender
      for (let key in this.users) {
        if (this.users[key] !== from) {
          this.users[key].receive(`[${from.name}] ${message}`, timestamp);
        }
      }
    }
  }
  
  broadcast(type, message, excludeUser = null) {
    const timestamp = new Date().toLocaleTimeString();
    for (let key in this.users) {
      if (this.users[key] !== excludeUser) {
        this.users[key].receive(`[System] ${message}`, timestamp);
      }
    }
  }
}

// User class
class User {
  constructor(name) {
    this.name = name;
    this.chatRoom = null;
  }
  
  setChatRoom(chatRoom) {
    this.chatRoom = chatRoom;
  }
  
  send(message, to = null) {
    if (this.chatRoom) {
      if (to) {
        this.chatRoom.send(message, this, to);
      } else {
        this.chatRoom.send(message, this);
      }
    }
  }
  
  receive(message, timestamp) {
    console.log(`${this.name} received at ${timestamp}: ${message}`);
  }
}

// Usage
console.log('=== Chat Room Example ===');
const chatRoom = new ChatRoom();

const alice = new User('Alice');
const bob = new User('Bob');
const charlie = new User('Charlie');

chatRoom.register(alice);
chatRoom.register(bob);
chatRoom.register(charlie);

alice.send('Hello everyone!');
bob.send('Hey Alice!');
charlie.send('Hi there!', alice); // Private message to Alice

// Air Traffic Control Mediator
class AirTrafficControl {
  constructor() {
    this.aircraft = [];
    this.runwayAvailable = true;
  }
  
  registerAircraft(aircraft) {
    this.aircraft.push(aircraft);
    aircraft.setATCMediator(this);
  }
  
  requestLanding(aircraft) {
    if (this.runwayAvailable) {
      this.runwayAvailable = false;
      console.log(`ATC: ${aircraft.name} cleared for landing on runway.`);
      
      // Notify other aircraft
      this.aircraft.forEach(plane => {
        if (plane !== aircraft) {
          plane.notify(`${aircraft.name} is landing. Please maintain altitude.`);
        }
      });
      
      // Simulate landing time
      setTimeout(() => {
        this.runwayAvailable = true;
        console.log(`ATC: Runway is now clear.`);
        this.notifyRunwayStatus();
      }, 3000);
      
      return true;
    } else {
      console.log(`ATC: ${aircraft.name} please circle. Runway occupied.`);
      return false;
    }
  }
  
  requestTakeoff(aircraft) {
    if (this.runwayAvailable) {
      this.runwayAvailable = false;
      console.log(`ATC: ${aircraft.name} cleared for takeoff.`);
      
      // Notify other aircraft
      this.aircraft.forEach(plane => {
        if (plane !== aircraft) {
          plane.notify(`${aircraft.name} is taking off. Maintain safe distance.`);
        }
      });
      
      setTimeout(() => {
        this.runwayAvailable = true;
        console.log(`ATC: Runway is now clear.`);
        this.notifyRunwayStatus();
      }, 2000);
      
      return true;
    } else {
      console.log(`ATC: ${aircraft.name} hold position. Runway occupied.`);
      return false;
    }
  }
  
  notifyRunwayStatus() {
    this.aircraft.forEach(plane => {
      plane.notify('Runway is now available.');
    });
  }
  
  broadcastWeatherUpdate(weather) {
    console.log(`ATC: Weather update - ${weather}`);
    this.aircraft.forEach(plane => {
      plane.notify(`Weather update: ${weather}`);
    });
  }
}

class Aircraft {
  constructor(name) {
    this.name = name;
    this.atc = null;
  }
  
  setATCMediator(atc) {
    this.atc = atc;
  }
  
  requestLanding() {
    console.log(`${this.name}: Requesting landing permission.`);
    return this.atc.requestLanding(this);
  }
  
  requestTakeoff() {
    console.log(`${this.name}: Requesting takeoff permission.`);
    return this.atc.requestTakeoff(this);
  }
  
  notify(message) {
    console.log(`${this.name} received: ${message}`);
  }
}

// Usage
console.log('\n=== Air Traffic Control Example ===');
const atc = new AirTrafficControl();

const flight1 = new Aircraft('United 123');
const flight2 = new Aircraft('Delta 456');
const flight3 = new Aircraft('American 789');

atc.registerAircraft(flight1);
atc.registerAircraft(flight2);
atc.registerAircraft(flight3);

flight1.requestLanding();
flight2.requestLanding(); // Will be denied
atc.broadcastWeatherUpdate('Clear skies, wind 10 knots');

// UI Components Mediator
class FormMediator {
  constructor() {
    this.components = {};
  }
  
  register(name, component) {
    this.components[name] = component;
    component.setMediator(this);
  }
  
  notify(sender, event, data) {
    switch(event) {
      case 'country-changed':
        this.handleCountryChange(data);
        break;
      case 'shipping-changed':
        this.handleShippingChange(data);
        break;
      case 'calculate-total':
        this.calculateTotal();
        break;
    }
  }
  
  handleCountryChange(country) {
    console.log(`Mediator: Country changed to ${country}`);
    
    // Update shipping options based on country
    if (country === 'USA') {
      this.components.shippingSelect.setOptions(['Standard', 'Express', 'Overnight']);
    } else {
      this.components.shippingSelect.setOptions(['International Standard', 'International Express']);
    }
    
    // Update tax rate
    const taxRate = country === 'USA' ? 0.08 : 0.15;
    this.components.taxField.setValue(taxRate);
    
    this.calculateTotal();
  }
  
  handleShippingChange(option) {
    console.log(`Mediator: Shipping changed to ${option}`);
    const shippingCosts = {
      'Standard': 5,
      'Express': 15,
      'Overnight': 30,
      'International Standard': 20,
      'International Express': 40
    };
    
    this.components.shippingCost.setValue(shippingCosts[option] || 0);
    this.calculateTotal();
  }
  
  calculateTotal() {
    const subtotal = this.components.subtotalField.getValue();
    const tax = subtotal * this.components.taxField.getValue();
    const shipping = this.components.shippingCost.getValue();
    const total = subtotal + tax + shipping;
    
    this.components.totalField.setValue(total);
    console.log(`Mediator: Total calculated: $${total.toFixed(2)}`);
  }
}

class FormComponent {
  constructor(name, value = null) {
    this.name = name;
    this.value = value;
    this.mediator = null;
  }
  
  setMediator(mediator) {
    this.mediator = mediator;
  }
  
  setValue(value) {
    this.value = value;
    console.log(`${this.name}: Value set to ${value}`);
  }
  
  getValue() {
    return this.value;
  }
}

class SelectComponent extends FormComponent {
  constructor(name, options = []) {
    super(name);
    this.options = options;
  }
  
  setOptions(options) {
    this.options = options;
    console.log(`${this.name}: Options updated to [${options.join(', ')}]`);
  }
  
  select(option) {
    if (this.options.includes(option)) {
      this.value = option;
      console.log(`${this.name}: Selected "${option}"`);
      this.mediator.notify(this, this.name === 'countrySelect' ? 'country-changed' : 'shipping-changed', option);
    }
  }
}

// Usage
console.log('\n=== Form Mediator Example ===');
const formMediator = new FormMediator();

// Create components
const countrySelect = new SelectComponent('countrySelect', ['USA', 'Canada', 'Mexico']);
const shippingSelect = new SelectComponent('shippingSelect', []);
const subtotalField = new FormComponent('subtotalField', 100);
const taxField = new FormComponent('taxField', 0);
const shippingCost = new FormComponent('shippingCost', 0);
const totalField = new FormComponent('totalField', 0);

// Register components
formMediator.register('countrySelect', countrySelect);
formMediator.register('shippingSelect', shippingSelect);
formMediator.register('subtotalField', subtotalField);
formMediator.register('taxField', taxField);
formMediator.register('shippingCost', shippingCost);
formMediator.register('totalField', totalField);

// Simulate user interactions
countrySelect.select('USA');
shippingSelect.select('Express');

console.log('\n--- Changing country to Canada ---');
countrySelect.select('Canada');
shippingSelect.select('International Express');