/*
 * File: src/contracts.ts
 * Description: Defines foundational interfaces and demonstrates single interface extension.
 */

/**
 * Represents a basic identifiable entity with a unique ID.
 * Essential for any system requiring tracking or referencing objects.
 */
interface Identifiable {
  id: string;
}

/**
 * Represents an entity that can be named.
 * Crucial for user-facing descriptions or internal logging.
 */
interface Numerable {
  name: string;
}

/**
 * Represents a resource that can be displayed, extending basic identification.
 * This interface extends 'Identifiable', ensuring any Displayable resource
 * inherently possesses an 'id' property.
 */
interface Displayable extends Identifiable {
  display(): string;
}

/**
 * A concrete class implementing the Displayable interface.
 * It must provide an 'id' and the 'display' method as per the contract.
 */
class Product implements Displayable {
  id: string;
  name: string;

  constructor(id: string, name: string) {
    this.id = id;
    this.name = name;
  }

  display(): string {
    return `Product ID: ${this.id}, Name: ${this.name}`;
  }
}

// Usage example:
const myProduct = new Product('prod-001', 'Widget X');
console.log(myProduct.display()); // Output: Product ID: prod-001, Name: Widget X


// Demonstrating type compatibility:
const identifiableItem: Identifiable = myProduct; // A Product is Identifiable
// identifiableItem.display(); // Error: Property 'display' does not exist on type 'Identifiable'

/**
 * Function to process any identifiable item.
 * Demonstrates how interfaces enforce contracts for function parameters.
 */
function processIdentifiable(item: Identifiable) {
  console.log(`Processing item with ID: ${item.id}`);
}

processIdentifiable(myProduct); // Output: Processing item with ID: prod-001


// Interface extending multiple interfaces (brief preview, detailed in Part 3)
interface FullDescribable extends Identifiable, Numerable {
    description: string;
}

class DetailedItem implements FullDescribable {
    id: string;
    name: string;
    description: string;

    constructor(id: string, name: string, description: string) {
        this.id = id;
        this.name = name;
        this.description = description;
    }
}

const detailed = new DetailedItem('di-001', 'Super Item', 'An item with full details.');
console.log(`Detailed Item: ${detailed.id}, ${detailed.name}, ${detailed.description}`);

/*
 * File: src/multi-implementation.ts
 * Description: Demonstrates how a class implements multiple distinct interfaces.
 */

/**
 * Defines a contract for entities that can be saved.
 */
interface Savable {
  save(): void;
}

/**
 * Defines a contract for entities that can be loaded.
 */
interface Loadable {
  load(id: string): void;
}

/**
 * Defines a contract for entities that possess a version.
 */
interface Versionable {
  version: number;
  updateVersion(newVersion: number): void;
}

/**
 * A class that requires both saving and loading capabilities,
 * along with version management. It implements all three distinct interfaces.
 * This demonstrates enforcing multiple separate contracts on a single class.
 */
class ConfigurationManager implements Savable, Loadable, Versionable {
  private data: Record<string, any>;
  version: number;

  constructor(initialVersion: number = 1) {
    this.data = {};
    this.version = initialVersion;
  }

  save(): void {
    console.log(`Configuration saved. Current version: ${this.version}`);
    // Simulate saving data to a persistent store
    localStorage.setItem('configData', JSON.stringify(this.data));
  }

  load(id: string): void {
    console.log(`Loading configuration for ID: ${id}`);
    // Simulate loading data from a persistent store
    const storedData = localStorage.getItem('configData');
    if (storedData) {
      this.data = JSON.parse(storedData);
      console.log('Configuration loaded successfully.');
    } else {
      console.log('No configuration found.');
    }
  }

  updateVersion(newVersion: number): void {
    if (newVersion > this.version) {
      this.version = newVersion;
      console.log(`Version updated to ${this.version}`);
    } else {
      console.warn(`New version ${newVersion} is not greater than current version ${this.version}.`);
    }
  }

  // Specific method for ConfigurationManager
  setConfig(key: string, value: any): void {
    this.data[key] = value;
    console.log(`Set config: ${key} = ${value}`);
  }

  getConfig(key: string): any {
    return this.data[key];
  }
}

// Usage example:
const configManager = new ConfigurationManager();
configManager.setConfig('theme', 'dark');
configManager.setConfig('language', 'en-US');
configManager.save();

configManager.updateVersion(2);
configManager.load('user-prefs'); // ID might be used for specific user configs in a real app

console.log(`Current theme: ${configManager.getConfig('theme')}`); // Output: dark
console.log(`Manager version: ${configManager.version}`); // Output: 2

// Demonstrating type checking for multiple interfaces
function requiresSavable(item: Savable) {
    item.save();
}

function requiresLoadable(item: Loadable) {
    item.load('default');
}

requiresSavable(configManager);
requiresLoadable(configManager);
// requiresSavable({ version: 1 }); // Error: Property 'save' is missing

/*
 * File: src/interface-composition.ts
 * Description: Demonstrates interfaces extending multiple other interfaces.
 */

/**
 * Base interface for any entity with a position.
 */
interface Positionable {
  x: number;
  y: number;
  getPosition(): { x: number; y: number };
}

/**
 * Base interface for any entity with dimensions.
 */
interface Sizable {
  width: number;
  height: number;
  getDimensions(): { width: number; height: number };
}

/**
 * Base interface for any entity that can be rendered.
 */
interface Renderable {
  render(): void;
}

/**
 * Composed interface: A 'Drawable' entity is both Positionable and Sizable.
 * This demonstrates an interface extending multiple other interfaces.
 * This is NOT class multiple inheritance; it's type merging.
 */
interface Drawable extends Positionable, Sizable {
  drawShape(): void;
}

/**
 * Further composed interface: A 'FullComponent' is a Drawable and also Renderable.
 * This shows nesting of composed interfaces for highly specific contracts.
 */
interface FullComponent extends Drawable, Renderable {
  componentName: string;
  updateState(newState: any): void;
}

/**
 * A class implementing the 'FullComponent' interface.
 * It must provide implementations for all members from Positionable, Sizable, Renderable,
 * and FullComponent itself.
 */
class RectangleComponent implements FullComponent {
  x: number;
  y: number;
  width: number;
  height: number;
  componentName: string;
  private state: any;

  constructor(x: number, y: number, width: number, height: number, name: string) {
    this.x = x;
    this.y = y;
    this.width = width;
    this.height = height;
    this.componentName = name;
    this.state = {};
  }

  getPosition(): { x: number; y: number } {
    return { x: this.x, y: this.y };
  }

  getDimensions(): { width: number; height: number } {
    return { width: this.width, height: this.height };
  }

  drawShape(): void {
    console.log(`Drawing a rectangle at (${this.x}, ${this.y}) with size ${this.width}x${this.height}.`);
  }

  render(): void {
    console.log(`Rendering component '${this.componentName}' with current state:`, this.state);
    this.drawShape(); // Reusing method from Drawable
  }

  updateState(newState: any): void {
    this.state = { ...this.state, ...newState };
    console.log(`State updated for ${this.componentName}. New state:`, this.state);
  }
}

// Usage example:
const myRectangle = new RectangleComponent(10, 20, 100, 50, 'MainRectangle');
myRectangle.render();
// Output:
// Rendering component 'MainRectangle' with current state: {}
// Drawing a rectangle at (10, 20) with size 100x50.

myRectangle.updateState({ color: 'blue', opacity: 0.8 });
myRectangle.render();
// Output:
// State updated for MainRectangle. New state: { color: 'blue', opacity: 0.8 }
// Rendering component 'MainRectangle' with current state: { color: 'blue', opacity: 0.8 }
// Drawing a rectangle at (10, 20) with size 100x50.

console.log(`Rectangle position:`, myRectangle.getPosition()); // Output: { x: 10, y: 20 }
console.log(`Rectangle dimensions:`, myRectangle.getDimensions()); // Output: { width: 100, height: 50 }

/*
 * File: src/mixins.ts
 * Description: Demonstrates the Mixin pattern to achieve behavioral reuse in classes.
 */

/**
 * Interface defining logging capabilities.
 */
interface Loggable {
  log(message: string): void;
}

/**
 * Mixin function to add logging capabilities to a class.
 * @param Base A class constructor that the mixin will extend.
 * @returns A new class with logging capabilities.
 */
function LoggableMixin<TBase extends new (...args: any[]) => object>(Base: TBase) {
  return class extends Base implements Loggable {
    log(message: string): void {
      console.log(`[LOG - ${new Date().toISOString()}] ${message}`);
    }
  };
}

/**
 * Interface defining timestamping capabilities.
 */
interface Timestamped {
  createdAt: Date;
  updatedAt: Date;
  touch(): void;
}

/**
 * Mixin function to add timestamping capabilities to a class.
 * @param Base A class constructor that the mixin will extend.
 * @returns A new class with timestamping capabilities.
 */
function TimestampedMixin<TBase extends new (...args: any[]) => object>(Base: TBase) {
  return class extends Base implements Timestamped {
    createdAt: Date;
    updatedAt: Date;

    constructor(...args: any[]) {
      super(...args);
      this.createdAt = new Date();
      this.updatedAt = new Date();
    }

    touch(): void {
      this.updatedAt = new Date();
      console.log(`Touched at: ${this.updatedAt.toISOString()}`);
    }
  };
}

/**
 * The base class for our component.
 */
class MyBaseComponent {
  private id: string;

  constructor(id: string) {
    this.id = id;
  }

  getId(): string {
    return this.id;
  }
}

/**
 * Composing our base component with both Loggable and Timestamped mixins.
 * The order of mixins can matter if they have overlapping properties/methods.
 * In TypeScript, we use type assertions to correctly infer the composed type.
 */
const ComposedComponent = LoggableMixin(TimestampedMixin(MyBaseComponent));

// Type assertion to ensure the compiler understands the full type signature
interface MyComposedComponent extends MyBaseComponent, Loggable, Timestamped {}

/**
 * A concrete instance of our composed component.
 */
const myComponent: MyComposedComponent = new ComposedComponent('comp-123');

// Demonstrating the functionality from both mixins and the base class
myComponent.log(`Component ${myComponent.getId()} initialized.`);
console.log(`Created At: ${myComponent.createdAt.toISOString()}`);
myComponent.touch();
myComponent.log('State changed.');
console.log(`Updated At: ${myComponent.updatedAt.toISOString()}`);

// Expected Output (timestamps will vary):
// [LOG - 2023-10-27T10:00:00.000Z] Component comp-123 initialized.
// Created At: 2023-10-27T10:00:00.000Z
// Touched at: 2023-10-27T10:00:01.500Z
// [LOG - 2023-10-27T10:00:01.500Z] State changed.
// Updated At: 2023-10-27T10:00:01.500Z