/*
 * TypeScript's 'private' keyword offers compile-time checks,
 * but compiles to regular JavaScript properties, lacking runtime encapsulation.
 * This code demonstrates how it is still accessible at runtime.
 */

// --- TypeScript 'private' Example ---
class LegacyService {
    private internalSecret: string;

    constructor(secret: string) {
        this.internalSecret = secret;
    }

    public revealSecret(): string {
        return this.internalSecret;
    }
}

// Activate an instance
const legacyInstance = new LegacyService("compile-time-only-secret");
console.log(`Legacy Service (via public method): ${legacyInstance.revealSecret()}`);

// Deconstruct the 'private' barrier at runtime (TypeScript compiles to JS where it's just a property)
// @ts-ignore: We intentionally bypass TypeScript's check here to show the JS runtime reality.
console.log(`Legacy Service (direct runtime access): ${legacyInstance.internalSecret}`);


/*
 * ECMAScript Private Fields (prefixed with #) provide true runtime encapsulation.
 * The JavaScript engine itself enforces privacy, making direct external access impossible.
 */

// --- ECMAScript Private Field Example ---
class ModernService {
    #runtimeSecret: string;

    constructor(secret: string) {
        this.#runtimeSecret = secret;
    }

    public obtainSecret(): string {
        // Legitimate access from within the class
        return this.#runtimeSecret;
    }

    public displaySecretAttempt(): void {
        try {
            // @ts-ignore: Intentionally attempting illegal access to demonstrate runtime error
            console.log(`Attempting direct access to #runtimeSecret: ${this.#runtimeSecret}`); // This line would fail outside the class
        } catch (e) {
            console.error("Error during displaySecretAttempt (this should not happen inside class):", e);
        }
    }
}

// Activate an instance
const modernInstance = new ModernService("true-runtime-secret");
console.log(`Modern Service (via public method): ${modernInstance.obtainSecret()}`);

// Forge an attempt to bypass encapsulation (this will result in a runtime error)
try {
    // @ts-ignore: TypeScript will warn, but even compiled JS will throw a SyntaxError/TypeError
    console.log(`Attempting direct access to #runtimeSecret from outside: ${modernInstance.#runtimeSecret}`);
} catch (e: any) {
    console.error(`ERROR: Failed to access private field from outside class. This is expected! Type: ${e.name}, Message: ${e.message}`);
}

// Key Takeaway:
// TypeScript 'private' is a linting/compile-time feature.
// ECMAScript Private Fields (#) are a runtime language feature, enforced by the JS engine itself.

/*
 * Implement ECMAScript Private Fields for robust runtime encapsulation.
 * These fields are prefixed with '#' and can only be accessed from within the class body.
 */

// 1. Basic Class with Private Fields
class PaymentProcessor {
    #transactionId: string; // A private field for unique transaction ID
    #amount: number;       // A private field for the payment amount
    #isProcessed: boolean = false; // Private flag, default value

    constructor(amount: number) {
        // Initialize private fields within the constructor
        this.#transactionId = this.#generateUniqueId();
        this.#amount = amount;
        console.log(`PaymentProcessor created for amount: ${this.#amount} with ID: ${this.#transactionId}`);
    }

    // 2. Accessing Private Fields via Public Methods
    public processPayment(): boolean {
        if (!this.#isProcessed) {
            console.log(`Processing payment for ID: ${this.#transactionId} and amount: $${this.#amount}`);
            // Simulate payment processing logic
            this.#isProcessed = true; // Modify private state
            this.#logTransaction("Payment successful.");
            return true;
        }
        console.log(`Payment for ID: ${this.#transactionId} already processed.`);
        return false;
    }

    public getTransactionDetails(): string {
        // Legitimate read access from a public method
        return `ID: ${this.#transactionId}, Amount: $${this.#amount}, Processed: ${this.#isProcessed}`;
    }

    // 3. Private Methods (also prefixed with #) - Can only be called internally
    #generateUniqueId(): string {
        // This method is purely an internal implementation detail
        return `TRX-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
    }

    #logTransaction(message: string): void {
        // Internal logging mechanism
        console.log(`[Internal Log] Transaction ${this.#transactionId}: ${message}`);
    }
}

// Activate and utilize the PaymentProcessor
const paymentOne = new PaymentProcessor(100.50);
console.log(paymentOne.getTransactionDetails());
paymentOne.processPayment();
console.log(paymentOne.getTransactionDetails());

const paymentTwo = new PaymentProcessor(25.00);
paymentTwo.processPayment();
paymentTwo.processPayment(); // Attempt to process again, should be prevented by internal logic

// --- Demonstrate Runtime Errors for Illegal Access ---

// Attempt to access a private field directly from outside (will cause a runtime error)
try {
    // @ts-ignore: Intentional bypass for demonstration
    console.log(`Attempting to read #transactionId directly: ${paymentOne.#transactionId}`);
} catch (e: any) {
    console.error(`ERROR (Expected): Direct access to #transactionId failed: ${e.message}`);
}

// Attempt to call a private method directly from outside (will cause a runtime error)
try {
    // @ts-ignore: Intentional bypass for demonstration
    paymentOne.#logTransaction("External logging attempt");
} catch (e: any) {
    console.error(`ERROR (Expected): Direct call to #logTransaction failed: ${e.message}`);
}

// Key Takeaway:
// ECMAScript Private Fields and Methods ensure robust runtime encapsulation.
// External code cannot bypass these access restrictions, leading to more secure and predictable objects.

/*
 * Best practices for leveraging ECMAScript Private Fields in TypeScript.
 * Focus on intentional design, immutability principles, and clear boundaries.
 */

// 1. Prioritize Private Fields for True Internal State
//    Use # for data or methods that MUST NOT be exposed or mutated externally.
class Authenticator {
    #apiKey: string; // Truly private API key, never directly exposed
    #sessionExpiry: number; // Internal timestamp for session validity

    constructor(apiKey: string, durationMinutes: number) {
        this.#apiKey = apiKey;
        this.#sessionExpiry = Date.now() + (durationMinutes * 60 * 1000);
    }

    // Public method to expose derived, non-sensitive information
    public isSessionValid(): boolean {
        return Date.now() < this.#sessionExpiry;
    }

    // Public method to perform actions that use the private key securely
    public authenticateRequest(request: any): boolean {
        this.#logAttempt(request.method);
        // Simulate using #apiKey internally for authentication
        if (request.headers?.['X-API-Key'] === this.#apiKey && this.isSessionValid()) {
            console.log("Request authenticated successfully.");
            return true;
        }
        console.log("Authentication failed.");
        return false;
    }

    #logAttempt(method: string): void {
        console.log(`[Auth Log] Attempt for method ${method} at ${new Date().toISOString()}`);
    }
}

const authService = new Authenticator("super-secret-key-123", 30); // 30-minute session
console.log(`Session valid initially: ${authService.isSessionValid()}`);
authService.authenticateRequest({ method: 'GET', headers: { 'X-API-Key': 'super-secret-key-123' } });
authService.authenticateRequest({ method: 'POST', headers: { 'X-API-Key': 'wrong-key' } });

// 2. Combine with Readonly for Immutable Public Properties (when relevant)
//    Private fields for internal control, public readonly for exposed immutable values.
class Configuration {
    readonly #configId: string; // Private ID for internal tracking
    public readonly settingA: string; // Public and immutable setting
    #internalCache: Map<string, any>;

    constructor(id: string, settingAValue: string) {
        this.#configId = `cfg-${id}`;
        this.settingA = settingAValue;
        this.#internalCache = new Map();
    }

    public getCachedValue(key: string): any {
        this.#accessCacheCount();
        return this.#internalCache.get(key);
    }

    #accessCacheCount(): void {
        // Simulate internal metrics tracking
        console.log(`Accessing cache for config ${this.#configId}`);
    }
}

const appConfig = new Configuration("prod", "Value1");
console.log(`Config settingA: ${appConfig.settingA}`);
// appConfig.settingA = "NewValue"; // Fails due to 'readonly'
// @ts-ignore
// console.log(appConfig.#configId); // Fails due to '#' private field

// 3. Avoid Overuse: Not every 'private' needs to be '#private'
//    Use TypeScript 'private' for compile-time guidance if runtime strictness isn't critical.
//    Use '#' when runtime enforcement of encapsulation is absolutely essential.

class DataStore {
    private _compilerPrivateData: string; // 'private' for developer guidance
    #runtimePrivateData: string;         // '#' for true runtime protection

    constructor(data1: string, data2: string) {
        this._compilerPrivateData = data1;
        this.#runtimePrivateData = data2;
    }

    public getData(): string {
        return `${this._compilerPrivateData} | ${this.#runtimePrivateData}`;
    }
}

const store = new DataStore("foo", "bar");
console.log(store.getData());
// @ts-ignore
console.log(store._compilerPrivateData); // Access possible at runtime in JS
// @ts-ignore
// console.log(store.#runtimePrivateData); // Access fails at runtime in JS

// Key Takeaway:
// Strategically apply private fields for crucial internal state management and security.
// Balance with TypeScript's 'private' for developer guidance where runtime enforcement is not critical.

/*
 * Demonstrate the architectural benefits of true runtime encapsulation
 * provided by ECMAScript Private Fields, focusing on refactoring safety
 * and predictable object behavior.
 */

// Example: A robust logging system using private fields for internal state
class LoggerService {
    #logBuffer: string[] = []; // Internal buffer, cannot be tampered with externally
    #maxBufferSize: number; // Private limit for the buffer size

    constructor(maxSize: number) {
        this.#maxBufferSize = maxSize;
        console.log(`LoggerService initialized with max buffer size: ${this.#maxBufferSize}`);
    }

    public logMessage(message: string): void {
        const timestampedMessage = `[${new Date().toISOString()}] ${message}`;
        this.#logBuffer.push(timestampedMessage);
        if (this.#logBuffer.length > this.#maxBufferSize) {
            this.#flushBuffer(); // Automatically flush when capacity reached
        }
    }

    public getLogCount(): number {
        return this.#logBuffer.length;
    }

    // This method is private, ensuring only the LoggerService itself decides when to flush
    #flushBuffer(): void {
        console.log("--- Flushing Log Buffer ---");
        this.#logBuffer.forEach(log => console.log(log));
        this.#logBuffer = []; // Clear the buffer after flushing
        console.log("--- Buffer Flushed ---");
    }

    // Public method to manually trigger a flush, if desired
    public forceFlush(): void {
        if (this.#logBuffer.length > 0) {
            this.#flushBuffer();
        } else {
            console.log("Log buffer is empty, no flush needed.");
        }
    }
}

// Activate the LoggerService
const appLogger = new LoggerService(3); // Max 3 messages before auto-flush

appLogger.logMessage("Application started.");
appLogger.logMessage("User logged in: John Doe.");
appLogger.logMessage("Data loaded from database."); // This will trigger an auto-flush

appLogger.logMessage("New feature activated.");
appLogger.forceFlush(); // Manually flush remaining messages

// --- Impact on Refactoring Safety --- 
// If the internal storage (#logBuffer) changes from an array to a LinkedList, 
// external code is unaffected because it only interacts via public methods.
// The private nature of #logBuffer ensures this internal refactoring is safe.

// Key Takeaway:
// True encapsulation via private fields enables safe internal refactoring,
// reduces coupling, and enhances system predictability and maintainability.