/*
  TypeScript's 'private' keyword provides compile-time privacy.
  It prevents accidental access during development but offers no runtime protection.
  The transpiled JavaScript will expose these members.
*/

// 1. Define a class with a 'private' member
class UserProfileTS {
    private _email: string;
    public username: string;

    constructor(username: string, email: string) {
        this.username = username;
        this._email = email;
        console.log(`UserProfileTS created: ${this.username}`);
    }

    // Public method to access or modify the private member (best practice)
    public getEmail(): string {
        return this._email;
    }

    public setEmail(newEmail: string): void {
        // Add validation logic here if necessary
        this._email = newEmail;
        console.log(`Email updated for ${this.username}`);
    }
}

// 2. Instantiate the class
const userTS = new UserProfileTS("devStrategist", "dev@example.com");

// 3. Attempt to access the 'private' member from outside
//    This line will cause a compile-time error in TypeScript:
//    'Property '_email' is private and only accessible within class 'UserProfileTS'.'
// userTS._email = "new@example.com"; // Uncommenting this line reveals the TS error.
// console.log(userTS._email);        // Uncommenting this line reveals the TS error.

// 4. Access the 'private' member via a public method (correct approach)
console.log(`Current email (via getter): ${userTS.getEmail()}`);
userTS.setEmail("updated.dev@example.com");
console.log(`New email (via getter): ${userTS.getEmail()}`);

/*
  Demonstrating runtime access after TypeScript compilation.
  In plain JavaScript, '_email' is just another property.
*/

// This part simulates what happens after TypeScript compiles to JavaScript.
// In a real JS environment (e.g., after 'tsc' output), this would work.
interface AnyUser { [key: string]: any; } // Type assertion to bypass TS checks for demonstration
const jsUser = userTS as AnyUser;

// At runtime, in pure JavaScript, '_email' is accessible.
// This output will only be visible if you compile the TypeScript and run the resulting JS.
console.log(`
--- Runtime Access Simulation (Post-Transpilation) ---`);
console.log(`Simulated direct access to _email in JS: ${jsUser._email}`);
jsUser._email = "runtime.override@example.com";
console.log(`Simulated overridden _email in JS: ${jsUser._email}`);
console.log(`Verified email via TS getter after JS override: ${userTS.getEmail()}`);

/*
  ECMAScript Private Class Fields ('#') provide true runtime privacy.
  They are a language feature, not just a TypeScript construct.
  Accessing them from outside the class results in a runtime error.
*/

// 1. Define a class with a '#' private field
class UserProfileJS {
    #email: string; // This is a true private field
    public username: string;

    constructor(username: string, email: string) {
        this.username = username;
        this.#email = email;
        console.log(`UserProfileJS created: ${this.username}`);
    }

    // Public method to access or modify the private field
    public getEmail(): string {
        return this.#email;
    }

    public setEmail(newEmail: string): void {
        // Add validation logic here if necessary
        this.#email = newEmail;
        console.log(`Email updated for ${this.username}`);
    }

    // Private method example (also using '#')
    #logActivity(message: string): void {
        console.log(`[ACTIVITY for ${this.username}]: ${message}`);
    }

    public performAction(): void {
        this.#logActivity("Performed an action.");
    }
}

// 2. Instantiate the class
const userJS = new UserProfileJS("codeConqueror", "code@example.com");

// 3. Attempt to access the '#' private field from outside
//    This will result in a runtime TypeError:
//    'Private field '#email' must be declared in an enclosing class'
try {
    // userJS.#email = "new.code@example.com"; // Uncommenting this line causes a syntax error in some environments
    // console.log(userJS.#email);             // and a runtime error in others (if syntax is allowed for check)

    // A more common way to demonstrate runtime error is to try to access it via reflection or direct property access:
    // These attempts will fail or return 'undefined' because '#email' isn't a regular enumerable property.
    console.log(`Attempting direct access to #email: ${ (userJS as any).#email }`); // This will likely throw a SyntaxError or TypeError
} catch (error: any) {
    console.error(`Runtime Error attempting to access #email: ${error.message}`);
}

// 4. Access the '#' private field via a public method (correct approach)
console.log(`Current email (via getter): ${userJS.getEmail()}`);
userJS.setEmail("updated.code@example.com");
console.log(`New email (via getter): ${userJS.getEmail()}`);

// Using a public method that calls a private method
userJS.performAction();

// 5. Demonstrate that private fields are not enumerable and cannot be easily discovered
console.log(`
--- Reflection Attempt ---`);
console.log(`Object.keys(userJS): ${Object.keys(userJS)}`);
console.log(`Object.getOwnPropertyNames(userJS): ${Object.getOwnPropertyNames(userJS)}`);
console.log(`Object.getOwnPropertySymbols(userJS): ${Object.getOwnPropertySymbols(userJS)}`);

/*
  This section does not require executable code, but rather conceptual comparison.
  The choice between '#' and 'private' hinges on whether compile-time guidance
  or runtime enforcement is the primary requirement for privacy.

  Consider the implications for security, maintainability, and compatibility.
*/

// Conceptual representation of the choice
function architectPrivacy(needsRuntimeSecurity: boolean, targetsOlderBrowsers: boolean) {
    if (needsRuntimeSecurity) {
        console.log("Decision: Activate ECMAScript '#' Private Fields for true runtime encapsulation.");
        console.log("Consider transpilation (Babel) if targeting older environments.");
    } else {
        console.log("Decision: Deploy TypeScript 'private' keyword for compile-time safety and developer guidance.");
        console.log("Understand that 'private' offers no runtime protection.");
    }

    if (targetsOlderBrowsers && needsRuntimeSecurity) {
        console.warn("Warning: '#' fields might require additional transpilation for older browsers. Verify Babel or similar setup.");
    }
}

console.log("\nScenario 1: Building a critical backend service with sensitive data.");
architectPrivacy(true, false); // True runtime security, no older browser concern

console.log("\nScenario 2: Developing an internal TypeScript library for other TS developers, focusing on API clarity.");
architectPrivacy(false, false); // Compile-time guidance is sufficient

console.log("\nScenario 3: Developing a cutting-edge web application where runtime security for specific features is paramount, but must support IE11.");
architectPrivacy(true, true); // Runtime security needed, but also older browser support means careful transpilation.

/*
  This code demonstrates advanced scenarios including inheritance and reflecting
  on class instances to highlight the true privacy of '#' fields.
  It shows how to structure a class hierarchy using both approaches.
*/

// Base class using 'private' keyword (TypeScript-only privacy)
class BaseServiceTS {
    private _apiKey: string; // TS private

    constructor(key: string) {
        this._apiKey = key;
        console.log("BaseServiceTS initialized.");
    }

    protected getApiKey(): string { // Protected for subclass access
        return this._apiKey; // Accessing TS private via a protected method
    }

    public fetchDataTS(): string {
        return `Fetching data with TS private API Key: ${this._apiKey.substring(0, 4)}...`;
    }
}

// Derived class attempting to access TS private directly (will fail at compile time)
class AnalyticsServiceTS extends BaseServiceTS {
    constructor(key: string) {
        super(key);
        console.log("AnalyticsServiceTS initialized.");
        // console.log(this._apiKey); // Compiler error: Property '_apiKey' is private
        console.log(`Accessing API Key via protected method: ${this.getApiKey().substring(0, 4)}...`);
    }
}

const analyticsTS = new AnalyticsServiceTS("TS_SECRET_KEY_123");
console.log(analyticsTS.fetchDataTS());


// Base class using '#' private field (Runtime privacy)
class BaseServiceJS {
    #secretToken: string; // JS Private Field

    constructor(token: string) {
        this.#secretToken = token;
        console.log("BaseServiceJS initialized.");
    }

    // Method to expose token to subclasses safely if needed, otherwise no direct access
    protected getSecretToken(): string {
        return this.#secretToken; // Accessing JS private from within the class
    }

    public fetchDataJS(): string {
        return `Fetching data with JS private Token: ${this.#secretToken.substring(0, 4)}...`;
    }
}

// Derived class attempting to access JS private field directly (will fail at runtime)
class ReportServiceJS extends BaseServiceJS {
    constructor(token: string) {
        super(token);
        console.log("ReportServiceJS initialized.");
        // console.log(this.#secretToken); // SyntaxError/TypeError: Private field '#secretToken' must be declared...
    }

    public generateReport(): string {
        // Subclasses cannot directly access '#' private fields of the base class.
        // They must rely on public/protected methods provided by the base class.
        // This emphasizes true encapsulation.
        return `Generating report with inherited (but not directly accessible) token.`;
    }
}

const reportJS = new ReportServiceJS("JS_SUPER_SECRET_TOKEN_XYZ");
console.log(reportJS.fetchDataJS());
console.log(reportJS.generateReport());

// Demonstrate inability to access '#' private fields via reflection
console.log("\n--- Reflecting on ReportServiceJS instance ---");
const instance = reportJS as any;
console.log("Attempting to access #secretToken directly:");
try {
    // This will likely result in a SyntaxError if attempted in a JS context that doesn't allow this form of access
    // Or simply 'undefined' if property doesn't exist. This is the strength of '#'
    console.log(instance.#secretToken); 
} catch (e: any) {
    console.log(`Caught error: ${e.message}`);
}

console.log("Object.getOwnPropertyNames(instance):");
console.log(Object.getOwnPropertyNames(instance)); // '#secretToken' is not listed