// Define a base Vehicle class
class Vehicle {
  constructor(make, model, year) {
    this.make = make;
    this.model = model;
    this.year = year;
    this.isRunning = false;
  }

  // Instance method
  start() {
    if (!this.isRunning) {
      this.isRunning = true;
      console.log(`${this.make} ${this.model} is now running`);
    } else {
      console.log('Vehicle is already running');
    }
  }

  stop() {
    if (this.isRunning) {
      this.isRunning = false;
      console.log(`${this.make} ${this.model} has stopped`);
    } else {
      console.log('Vehicle is already stopped');
    }
  }

  // Getter method
  get age() {
    return new Date().getFullYear() - this.year;
  }

  // Static method
  static compareAge(vehicle1, vehicle2) {
    return vehicle1.age - vehicle2.age;
  }

  // Method that can be overridden
  getDescription() {
    return `${this.year} ${this.make} ${this.model}`;
  }
}

// Create instances
const car1 = new Vehicle('Toyota', 'Camry', 2020);
const car2 = new Vehicle('Honda', 'Civic', 2018);

console.log(car1.getDescription()); // "2020 Toyota Camry"
console.log(car1.age); // 5 (current year - 2020)
car1.start(); // "Toyota Camry is now running"

// Using static method
console.log(Vehicle.compareAge(car1, car2)); // -2

class BankAccount {
  // Private fields (ES2022)
  #balance;
  #accountNumber;
  #transactionHistory;

  constructor(accountNumber, initialBalance = 0) {
    this.#accountNumber = accountNumber;
    this.#balance = initialBalance;
    this.#transactionHistory = [];
  }

  // Private method
  #addTransaction(type, amount, description) {
    this.#transactionHistory.push({
      type,
      amount,
      description,
      timestamp: new Date().toISOString(),
      balance: this.#balance
    });
  }

  // Public methods (interface)
  deposit(amount, description = 'Deposit') {
    if (amount <= 0) {
      throw new Error('Deposit amount must be positive');
    }
    
    this.#balance += amount;
    this.#addTransaction('credit', amount, description);
    return this.#balance;
  }

  withdraw(amount, description = 'Withdrawal') {
    if (amount <= 0) {
      throw new Error('Withdrawal amount must be positive');
    }
    
    if (amount > this.#balance) {
      throw new Error('Insufficient funds');
    }
    
    this.#balance -= amount;
    this.#addTransaction('debit', amount, description);
    return this.#balance;
  }

  // Getter for controlled access to private data
  get balance() {
    return this.#balance;
  }

  get accountNumber() {
    return this.#accountNumber.slice(-4).padStart(this.#accountNumber.length, '*');
  }

  getTransactionHistory(limit = 10) {
    return this.#transactionHistory
      .slice(-limit)
      .map(transaction => ({
        ...transaction,
        // Don't expose full balance history for security
        balance: undefined
      }));
  }
}

// Usage example
const account = new BankAccount('1234567890', 1000);
console.log(account.balance); // 1000
console.log(account.accountNumber); // "******7890"

account.deposit(500, 'Salary');
account.withdraw(200, 'Groceries');

// This would throw an error - private field access
// console.log(account.#balance); // SyntaxError

// Base class
class Animal {
  constructor(name, species) {
    this.name = name;
    this.species = species;
  }

  // Method to be overridden (polymorphism)
  makeSound() {
    return 'Some generic animal sound';
  }

  // Method that uses polymorphic behavior
  introduce() {
    return `Hi, I'm ${this.name}, and I say: ${this.makeSound()}`;
  }

  // Common behavior
  sleep() {
    return `${this.name} is sleeping`;
  }
}

// Derived classes
class Dog extends Animal {
  constructor(name, breed) {
    super(name, 'Canine'); // Call parent constructor
    this.breed = breed;
  }

  // Override parent method (polymorphism)
  makeSound() {
    return 'Woof! Woof!';
  }

  // Additional behavior specific to dogs
  fetch() {
    return `${this.name} is fetching the ball!`;
  }
}

class Cat extends Animal {
  constructor(name, isIndoor = true) {
    super(name, 'Feline');
    this.isIndoor = isIndoor;
  }

  // Override parent method with different behavior
  makeSound() {
    return 'Meow!';
  }

  // Cat-specific behavior
  climb() {
    return `${this.name} is climbing`;
  }
}

class Bird extends Animal {
  constructor(name, canFly = true) {
    super(name, 'Avian');
    this.canFly = canFly;
  }

  makeSound() {
    return 'Tweet tweet!';
  }

  fly() {
    return this.canFly 
      ? `${this.name} is flying high!` 
      : `${this.name} cannot fly`;
  }
}

// Polymorphism in action
const animals = [
  new Dog('Buddy', 'Golden Retriever'),
  new Cat('Whiskers'),
  new Bird('Tweety'),
  new Bird('Penguin', false)
];

// Each animal responds differently to the same method call
animals.forEach(animal => {
  console.log(animal.introduce());
  // Output:
  // Hi, I'm Buddy, and I say: Woof! Woof!
  // Hi, I'm Whiskers, and I say: Meow!
  // Hi, I'm Tweety, and I say: Tweet tweet!
  // Hi, I'm Penguin, and I say: Tweet tweet!
});

// Demonstrating method-specific behaviors
console.log(animals[0].fetch()); // "Buddy is fetching the ball!"
console.log(animals[1].climb()); // "Whiskers is climbing"
console.log(animals[2].fly());   // "Tweety is flying high!"
console.log(animals[3].fly());   // "Penguin cannot fly"

// Abstract base class simulation
class Shape {
  constructor() {
    if (new.target === Shape) {
      throw new Error('Cannot instantiate abstract class Shape directly');
    }
  }

  // Abstract method - must be implemented by subclasses
  calculateArea() {
    throw new Error('calculateArea() method must be implemented by subclass');
  }

  calculatePerimeter() {
    throw new Error('calculatePerimeter() method must be implemented by subclass');
  }

  // Concrete method that uses abstract methods
  getDescription() {
    return `This shape has an area of ${this.calculateArea()} and perimeter of ${this.calculatePerimeter()}`;
  }
}

// Interface simulation using mixins
const Drawable = {
  draw() {
    throw new Error('draw() method must be implemented');
  },
  
  setColor(color) {
    this.color = color;
  }
};

const Movable = {
  moveTo(x, y) {
    this.x = x;
    this.y = y;
    console.log(`Moved to position (${x}, ${y})`);
  },
  
  moveBy(deltaX, deltaY) {
    this.x = (this.x || 0) + deltaX;
    this.y = (this.y || 0) + deltaY;
    console.log(`Moved by (${deltaX}, ${deltaY}) to (${this.x}, ${this.y})`);
  }
};

// Concrete implementations
class Rectangle extends Shape {
  constructor(width, height) {
    super();
    this.width = width;
    this.height = height;
    this.x = 0;
    this.y = 0;
    this.color = 'black';
  }

  calculateArea() {
    return this.width * this.height;
  }

  calculatePerimeter() {
    return 2 * (this.width + this.height);
  }

  draw() {
    console.log(`Drawing a ${this.color} rectangle at (${this.x}, ${this.y}) with width ${this.width} and height ${this.height}`);
  }
}

class Circle extends Shape {
  constructor(radius) {
    super();
    this.radius = radius;
    this.x = 0;
    this.y = 0;
    this.color = 'black';
  }

  calculateArea() {
    return Math.PI * this.radius ** 2;
  }

  calculatePerimeter() {
    return 2 * Math.PI * this.radius;
  }

  draw() {
    console.log(`Drawing a ${this.color} circle at (${this.x}, ${this.y}) with radius ${this.radius}`);
  }
}

// Apply interfaces using Object.assign
Object.assign(Rectangle.prototype, Drawable, Movable);
Object.assign(Circle.prototype, Drawable, Movable);

// Usage
const rectangle = new Rectangle(10, 5);
const circle = new Circle(3);

console.log(rectangle.getDescription());
// "This shape has an area of 50 and perimeter of 30"

rectangle.setColor('red');
rectangle.moveTo(10, 20);
rectangle.draw();
// "Moved to position (10, 20)"
// "Drawing a red rectangle at (10, 20) with width 10 and height 5"

circle.setColor('blue');
circle.moveBy(5, 5);
circle.draw();
// "Moved by (5, 5) to (5, 5)"
// "Drawing a blue circle at (5, 5) with radius 3"

/**
 * Task Management System - complete OOP Example
 * Demonstrates encapsulation, inheritance, polymorphism, and design patterns
 */

// Base Task class with encapsulation
class Task {
  static #taskCounter = 0;
  #id;
  #title;
  #description;
  #status;
  #createdAt;
  #updatedAt;

  constructor(title, description = '') {
    if (!title || typeof title !== 'string') {
      throw new Error('Task title is required and must be a string');
    }

    this.#id = ++Task.#taskCounter;
    this.#title = title.trim();
    this.#description = description.trim();
    this.#status = 'pending';
    this.#createdAt = new Date();
    this.#updatedAt = new Date();
  }

  // Getters for controlled access
  get id() { return this.#id; }
  get title() { return this.#title; }
  get description() { return this.#description; }
  get status() { return this.#status; }
  get createdAt() { return this.#createdAt; }
  get updatedAt() { return this.#updatedAt; }

  // Setters with validation
  set title(newTitle) {
    if (!newTitle || typeof newTitle !== 'string') {
      throw new Error('Title must be a non-empty string');
    }
    this.#title = newTitle.trim();
    this.#updateTimestamp();
  }

  set description(newDescription) {
    this.#description = (newDescription || '').trim();
    this.#updateTimestamp();
  }

  // Private method
  #updateTimestamp() {
    this.#updatedAt = new Date();
  }

  // Abstract-like method to be overridden
  complete() {
    this.#status = 'completed';
    this.#updateTimestamp();
    return this;
  }

  // Polymorphic method
  getTaskInfo() {
    return {
      id: this.#id,
      title: this.#title,
      description: this.#description,
      status: this.#status,
      type: this.constructor.name,
      createdAt: this.#createdAt,
      updatedAt: this.#updatedAt
    };
  }

  // Common behavior
  toJSON() {
    return this.getTaskInfo();
  }
}

// Specialized task types using inheritance
class UrgentTask extends Task {
  #priority;
  #deadline;

  constructor(title, description, deadline) {
    super(title, description);
    this.#priority = 'high';
    this.#deadline = new Date(deadline);
    
    if (this.#deadline <= new Date()) {
      throw new Error('Deadline must be in the future');
    }
  }

  get priority() { return this.#priority; }
  get deadline() { return this.#deadline; }

  // Override parent method (polymorphism)
  getTaskInfo() {
    return {
      ...super.getTaskInfo(),
      priority: this.#priority,
      deadline: this.#deadline,
      isOverdue: this.isOverdue()
    };
  }

  isOverdue() {
    return new Date() > this.#deadline && this.status !== 'completed';
  }

  complete() {
    super.complete();
    console.log(`Urgent task "${this.title}" completed!`);
    return this;
  }
}

class RecurringTask extends Task {
  #interval;
  #nextDue;

  constructor(title, description, intervalDays) {
    super(title, description);
    this.#interval = intervalDays;
    this.#nextDue = new Date(Date.now() + intervalDays * 24 * 60 * 60 * 1000);
  }

  get interval() { return this.#interval; }
  get nextDue() { return this.#nextDue; }

  complete() {
    super.complete();
    // Reset for next occurrence
    this.#nextDue = new Date(Date.now() + this.#interval * 24 * 60 * 60 * 1000);
    console.log(`Recurring task "${this.title}" completed! Next due: ${this.#nextDue.toDateString()}`);
    return this;
  }

  getTaskInfo() {
    return {
      ...super.getTaskInfo(),
      interval: this.#interval,
      nextDue: this.#nextDue
    };
  }
}

// Observer pattern for task events
class TaskEventEmitter {
  #observers = new Map();

  subscribe(event, callback) {
    if (!this.#observers.has(event)) {
      this.#observers.set(event, []);
    }
    this.#observers.get(event).push(callback);
  }

  emit(event, data) {
    if (this.#observers.has(event)) {
      this.#observers.get(event).forEach(callback => callback(data));
    }
  }
}

// Factory pattern for task creation
class TaskFactory {
  static createTask(type, ...args) {
    switch (type.toLowerCase()) {
      case 'urgent':
        return new UrgentTask(...args);
      case 'recurring':
        return new RecurringTask(...args);
      case 'basic':
      default:
        return new Task(...args);
    }
  }
}

// Main task manager using multiple patterns
class TaskManager extends TaskEventEmitter {
  #tasks = new Map();
  #completedTasks = new Map();

  addTask(type, ...args) {
    try {
      const task = TaskFactory.createTask(type, ...args);
      this.#tasks.set(task.id, task);
      
      this.emit('taskAdded', {
        task: task.getTaskInfo(),
        totalTasks: this.#tasks.size
      });
      
      return task;
    } catch (error) {
      this.emit('taskError', { error: error.message });
      throw error;
    }
  }

  completeTask(taskId) {
    const task = this.#tasks.get(taskId);
    if (!task) {
      throw new Error(`Task with ID ${taskId} not found`);
    }

    task.complete();
    
    // Move to completed unless it's recurring
    if (!(task instanceof RecurringTask)) {
      this.#completedTasks.set(taskId, task);
      this.#tasks.delete(taskId);
    }

    this.emit('taskCompleted', {
      task: task.getTaskInfo(),
      totalTasks: this.#tasks.size,
      totalCompleted: this.#completedTasks.size
    });

    return task;
  }

  getTasks(status = 'all') {
    let tasks = [];
    
    switch (status) {
      case 'pending':
        tasks = Array.from(this.#tasks.values())
          .filter(task => task.status === 'pending');
        break;
      case 'completed':
        tasks = Array.from(this.#completedTasks.values());
        break;
      case 'all':
      default:
        tasks = [
          ...Array.from(this.#tasks.values()),
          ...Array.from(this.#completedTasks.values())
        ];
    }

    return tasks.map(task => task.getTaskInfo());
  }

  getOverdueTasks() {
    return Array.from(this.#tasks.values())
      .filter(task => task instanceof UrgentTask && task.isOverdue())
      .map(task => task.getTaskInfo());
  }

  getTasksByType(type) {
    const tasks = Array.from(this.#tasks.values());
    return tasks
      .filter(task => task.constructor.name === type)
      .map(task => task.getTaskInfo());
  }
}

// Usage demonstration
const taskManager = new TaskManager();

// Set up event listeners
taskManager.subscribe('taskAdded', (data) => {
  console.log(`✅ Task added: ${data.task.title} (Total: ${data.totalTasks})`);
});

taskManager.subscribe('taskCompleted', (data) => {
  console.log(`🎉 Task completed: ${data.task.title}`);
});

taskManager.subscribe('taskError', (data) => {
  console.error(`❌ Error: ${data.error}`);
});

// Create various types of tasks
const basicTask = taskManager.addTask('basic', 'Write documentation');
const urgentTask = taskManager.addTask('urgent', 'Fix critical bug', 'Security vulnerability', '2025-10-20');
const recurringTask = taskManager.addTask('recurring', 'Weekly team meeting', 'Sync with the team', 7);

// Complete some tasks
taskManager.completeTask(basicTask.id);
taskManager.completeTask(urgentTask.id);

// Get various task lists
console.log('\nAll tasks:', taskManager.getTasks());
console.log('\nPending tasks:', taskManager.getTasks('pending'));
console.log('\nCompleted tasks:', taskManager.getTasks('completed'));
console.log('\nUrgent tasks:', taskManager.getTasksByType('UrgentTask'));

// Example test file: TaskManager.test.js
import { TaskManager, Task, UrgentTask } from './TaskManager.js';

describe('TaskManager', () => {
  let taskManager;

  beforeEach(() => {
    taskManager = new TaskManager();
  });

  describe('Task Creation', () => {
    test('should create a basic task', () => {
      const task = taskManager.addTask('basic', 'Test task');
      
      expect(task).toBeInstanceOf(Task);
      expect(task.title).toBe('Test task');
      expect(task.status).toBe('pending');
      expect(task.id).toBeDefined();
    });

    test('should create an urgent task with deadline', () => {
      const deadline = new Date(Date.now() + 86400000); // Tomorrow
      const task = taskManager.addTask('urgent', 'Urgent task', 'Description', deadline);
      
      expect(task).toBeInstanceOf(UrgentTask);
      expect(task.priority).toBe('high');
      expect(task.deadline).toEqual(deadline);
    });

    test('should throw error for invalid task data', () => {
      expect(() => {
        taskManager.addTask('basic', ''); // Empty title
      }).toThrow('Task title is required');
    });
  });

  describe('Task Completion', () => {
    test('should complete a task successfully', () => {
      const task = taskManager.addTask('basic', 'Test task');
      const completedTask = taskManager.completeTask(task.id);
      
      expect(completedTask.status).toBe('completed');
      expect(taskManager.getTasks('pending')).toHaveLength(0);
      expect(taskManager.getTasks('completed')).toHaveLength(1);
    });

    test('should throw error when completing non-existent task', () => {
      expect(() => {
        taskManager.completeTask(999);
      }).toThrow('Task with ID 999 not found');
    });
  });

  describe('Event Handling', () => {
    test('should emit events when tasks are added', (done) => {
      taskManager.subscribe('taskAdded', (data) => {
        expect(data.task.title).toBe('Event test task');
        expect(data.totalTasks).toBe(1);
        done();
      });

      taskManager.addTask('basic', 'Event test task');
    });

    test('should emit events when tasks are completed', (done) => {
      const task = taskManager.addTask('basic', 'Complete test task');

      taskManager.subscribe('taskCompleted', (data) => {
        expect(data.task.status).toBe('completed');
        done();
      });

      taskManager.completeTask(task.id);
    });
  });

  describe('Task Filtering', () => {
    beforeEach(() => {
      taskManager.addTask('basic', 'Basic task 1');
      taskManager.addTask('urgent', 'Urgent task 1', 'Description', new Date(Date.now() + 86400000));
      taskManager.addTask('recurring', 'Recurring task 1', 'Description', 7);
    });

    test('should filter tasks by status', () => {
      const pendingTasks = taskManager.getTasks('pending');
      expect(pendingTasks).toHaveLength(3);
      
      // Complete one task
      const firstTask = taskManager.getTasks('pending')[0];
      taskManager.completeTask(firstTask.id);
      
      expect(taskManager.getTasks('pending')).toHaveLength(2);
      expect(taskManager.getTasks('completed')).toHaveLength(1);
    });

    test('should filter tasks by type', () => {
      const urgentTasks = taskManager.getTasksByType('UrgentTask');
      expect(urgentTasks).toHaveLength(1);
      expect(urgentTasks[0].priority).toBe('high');
    });
  });
});

// Mock testing for external dependencies
describe('Task with external dependencies', () => {
  test('should handle API calls in task completion', async () => {
    // Mock fetch
    global.fetch = jest.fn(() =>
      Promise.resolve({
        ok: true,
        json: () => Promise.resolve({ success: true })
      })
    );

    class APITask extends Task {
      async complete() {
        const response = await fetch('/api/complete-task', {
          method: 'POST',
          body: JSON.stringify({ taskId: this.id })
        });
        
        if (response.ok) {
          super.complete();
        }
        
        return this;
      }
    }

    const apiTask = new APITask('API Task');
    await apiTask.complete();
    
    expect(apiTask.status).toBe('completed');
    expect(fetch).toHaveBeenCalledWith('/api/complete-task', {
      method: 'POST',
      body: JSON.stringify({ taskId: apiTask.id })
    });
  });
});