/**
 * Deconstruct Interfaces: The Contractual Blueprint
 * Defines the fundamental structure a User object must adhere to.
 * Enforces type safety for properties and methods within the contract.
 */
interface IUser {
    id: number;                 // Unique identifier for the user (required)
    username: string;           // User's chosen username (required)
    email: string;              // User's email address (required)
    registrationDate?: Date;    // Optional property: date of registration
    
    // Method signature: A function that returns a formatted full name string
    // Classes implementing IUser must provide this method.
    getProfileSummary(): string;
}

interface IAuditable {
    createdAt: Date;
    updatedAt: Date;
}

/**
 * Activating Adherence: Forging Class Implementation
 * Demonstrates a class explicitly implementing an interface.
 * The 'implements' keyword signals the class's commitment to the interface's contract.
 */

interface IProduct {
    id: string;
    name: string;
    price: number;
    description?: string;
    getDisplayPrice(): string;
}

class ConcreteProduct implements IProduct {
    // REQUIRED: All non-optional properties from IProduct must be present
    id: string;
    name: string;
    price: number;

    // OPTIONAL: description property is optional in IProduct, so it's optional here too
    description?: string;

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

    // REQUIRED: The getDisplayPrice method from IProduct must be implemented
    getDisplayPrice(): string {
        return `$${this.price.toFixed(2)}`;
    }
}

// Usage example:
const laptop = new ConcreteProduct('sku-123', 'Gaming Laptop', 1200.50);
console.log(`Product: ${laptop.name}, Price: ${laptop.getDisplayPrice()}`);

// Attempting to create a class that violates the contract will result in a compile-time error:
/*
class InvalidProduct implements IProduct { // ERROR: Class 'InvalidProduct' incorrectly implements interface 'IProduct'.
    id: string;
    name: string;
    // Missing 'price' property and 'getDisplayPrice' method
    constructor(id: string, name: string) {
        this.id = id;
        this.name = name;
    }
}
*/

/**
 * Elevating Specifications: Mastering Advanced Interface Features
 * Demonstrates the use of optional and readonly properties, and advanced method signatures within interfaces.
 * This allows for more granular and immutable contract definitions.
 */

interface IConfiguration {
    id: string;                         // Required unique identifier
    readonly owner: string;             // Readonly property: must be set at construction, cannot be changed later
    version: number;                    // Required version number
    isEnabled?: boolean;                // Optional property: may or may not be present
    
    // Method signature with parameters and return type
    applySettings(settings: object): boolean;
    
    // Index signature: Allows an interface to describe properties with dynamic names
    [key: string]: any; // Allows arbitrary string-indexed properties, but all other members must be compatible
}

class AppConfig implements IConfiguration {
    id: string;
    readonly owner: string;
    version: number;
    isEnabled?: boolean;

    // Additional properties not defined in the interface are allowed, but not enforced.
    private lastModified: Date;

    constructor(id: string, owner: string, version: number, isEnabled?: boolean) {
        this.id = id;
        this.owner = owner;
        this.version = version;
        this.isEnabled = isEnabled;
        this.lastModified = new Date(); // Initialize internal property
    }

    applySettings(settings: object): boolean {
        // Logic to apply settings
        console.log(`Applying settings for ${this.id}, version ${this.version}:`, settings);
        this.lastModified = new Date(); // Update internal state
        return true;
    }

    // To satisfy the index signature, any string-indexed property we add MUST be compatible
    // For example, if we had [key: string]: string, we couldn't have 'version: number'.
    // With [key: string]: any, we can have various types.
    status: string = 'active'; 
}

const config = new AppConfig('app-core', 'admin', 1.0, true);
console.log(`Config ID: ${config.id}, Owner: ${config.owner}, Version: ${config.version}`);
config.applySettings({ theme: 'dark', language: 'en' });

// config.owner = 'new-admin'; // COMPILE ERROR: Cannot assign to 'owner' because it is a read-only property.

// Accessing dynamically added property
console.log(`Config Status: ${config.status}`);

/**
 * Orchestrating Consistency: Multiple Interfaces and Interface Extension
 * Demonstrates a class implementing multiple interfaces and how interfaces can extend each other.
 * This enables composition of behaviors and creation of hierarchical contracts.
 */

// Base interface for any entity with a unique ID
interface IIdentifiable {
    id: string;
    getUniqueId(): string;
}

// Interface for entities that can be enabled/disabled
interface IActivatable {
    isEnabled: boolean;
    toggleActivation(): void;
}

// Interface extending IIdentifiable to add user-specific properties
interface IUserProfile extends IIdentifiable {
    username: string;
    email: string;
    // Additional methods specific to a user profile
    updateEmail(newEmail: string): void;
}

// A class implementing multiple interfaces: IIdentifiable and IActivatable
class Device implements IIdentifiable, IActivatable {
    id: string;
    isEnabled: boolean;
    name: string;

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

    getUniqueId(): string {
        return `Device-${this.id}`;
    }

    toggleActivation(): void {
        this.isEnabled = !this.isEnabled;
        console.log(`Device ${this.id} is now ${this.isEnabled ? 'enabled' : 'disabled'}.`);
    }
}

// A class implementing the extended interface IUserProfile
class UserAccount implements IUserProfile {
    id: string;
    username: string;
    email: string;
    registrationDate: Date;

    constructor(id: string, username: string, email: string) {
        this.id = id;
        this.username = username;
        this.email = email;
        this.registrationDate = new Date();
    }

    getUniqueId(): string {
        return `User-${this.id}`;
    }

    updateEmail(newEmail: string): void {
        if (newEmail !== this.email) {
            this.email = newEmail;
            console.log(`Email for ${this.username} updated to ${this.email}`);
        } else {
            console.log('New email is the same as current email.');
        }
    }
}

// Usage:
const sensor = new Device('sen-001', 'Temperature Sensor');
sensor.toggleActivation(); // Device sen-001 is now disabled.

const adminUser = new UserAccount('usr-005', 'johndoe', 'john.doe@example.com');
console.log(`User unique ID: ${adminUser.getUniqueId()}`);
adminUser.updateEmail('john.newemail@example.com');

/**
 * Fortifying Development: Best Practices and Common Pitfalls
 * This section focuses on architectural implications, common errors, and strategic choices.
 * No specific code snippet for a 'pitfall' as it's conceptual, but we can illustrate a 'good practice'.
 */

interface IDatabaseService {
    connect(): Promise<void>;
    disconnect(): Promise<void>;
    query<T>(sql: string, params?: any[]): Promise<T[]>;
}

// Good Practice: Injecting dependencies via interfaces for testability and flexibility
class UserRepository {
    private dbService: IDatabaseService;

    // The constructor takes an IDatabaseService, not a concrete implementation
    constructor(dbService: IDatabaseService) {
        this.dbService = dbService;
    }

    async findUserById(id: number): Promise<any | null> {
        await this.dbService.connect();
        try {
            const users = await this.dbService.query<any>('SELECT * FROM users WHERE id = $1', [id]);
            return users.length > 0 ? users[0] : null;
        } finally {
            await this.dbService.disconnect();
        }
    }
}

// A mock database service for testing, implementing the same interface
class MockDatabaseService implements IDatabaseService {
    async connect(): Promise<void> {
        console.log('Mock DB connected.');
    }
    async disconnect(): Promise<void> {
        console.log('Mock DB disconnected.');
    }
    async query<T>(sql: string, params?: any[]): Promise<T[]> {
        console.log(`Mock DB query: ${sql} with params: ${params}`);
        // Simulate returning data for a specific query
        if (sql.includes('users') && params && params[0] === 1) {
            return [{ id: 1, name: 'Test User', email: 'test@example.com' }] as T[];
        }
        return [] as T[];
    }
}

// Production database service (e.g., a PostgreSQL client)
class RealDatabaseService implements IDatabaseService {
    // ... actual database connection and query logic ...
    async connect(): Promise<void> { console.log('Real DB connected.'); /* actual connection */ }
    async disconnect(): Promise<void> { console.log('Real DB disconnected.'); /* actual disconnection */ }
    async query<T>(sql: string, params?: any[]): Promise<T[]> { 
        console.log('Real DB query executed.'); 
        // Placeholder for actual query logic
        return [] as T[]; 
    }
}

// Usage with Mock for testing
const mockDb = new MockDatabaseService();
const userRepoTest = new UserRepository(mockDb);
userRepoTest.findUserById(1).then(user => console.log('Found user (Mock):', user));

// Usage with Real service for production
// const realDb = new RealDatabaseService();
// const userRepoProd = new UserRepository(realDb);
// userRepoProd.findUserById(1).then(user => console.log('Found user (Prod):', user));