/*
  Demonstrates the evolution from conventional privacy to true private class fields.
  Run this code in a modern JavaScript environment (Node.js 14+ or browser).
*/

class LegacyCounter {
  constructor() {
    // Convention: Prefixing with underscore implies 'private'
    this._count = 0;
  }

  increment() {
    this._count++;
  }

  getCount() {
    return this._count;
  }
}

const legacyCounter = new LegacyCounter();
legacyCounter.increment();
console.log(`Legacy Counter (incremented): ${legacyCounter.getCount()}`); // Output: 1

// Problem: The '_count' field is still accessible and modifiable from outside
legacyCounter._count = 100; // Direct external modification, breaking encapsulation
console.log(`Legacy Counter (modified externally): ${legacyCounter.getCount()}`); // Output: 100

console.log('\n--- Introducing True Private Fields ---\n');

class SecureCounter {
  // True Private Field: Inaccessible from outside the class
  #count = 0;

  increment() {
    this.#count++;
  }

  getCount() {
    return this.#count;
  }
}

const secureCounter = new SecureCounter();
secureCounter.increment();
console.log(`Secure Counter (incremented): ${secureCounter.getCount()}`); // Output: 1

// Attempting to access or modify #count from outside the class results in an error
// Uncommenting the line below will throw a SyntaxError or TypeError, depending on context.
// secureCounter.#count = 100; 
// console.log(`Secure Counter (attempted external modification): ${secureCounter.getCount()}`);

try {
  // Demonstrate the error when trying to access a private field externally
  // This uses a non-standard but common way to illustrate the error for demonstration
  // In reality, attempting `obj.#field` directly outside the class scope is a SyntaxError.
  // For runtime checks, you'd usually see a TypeError if reflective access was attempted.
  eval('secureCounter.#count'); 
} catch (e) {
  console.log(`Attempt to access secureCounter.#count from outside: ${e.message}`);
}

/*
  Illustrates the syntax and behavior of private class fields and methods.
  Run this code in a modern JavaScript environment (Node.js 14+ or browser).
*/

class DataProcessor {
  // Private field for internal data storage
  #data;
  // Private static field for configuration or shared internal state
  static #MAX_SIZE = 100;

  constructor(initialData) {
    if (initialData.length > DataProcessor.#MAX_SIZE) {
      throw new Error(`Data exceeds maximum allowed size of ${DataProcessor.#MAX_SIZE}`);
    }
    this.#data = this.#sanitize(initialData);
  }

  // Private method for internal data manipulation
  #sanitize(input) {
    console.log('  [Internal]: Sanitizing data...');
    return input.trim().toLowerCase();
  }

  // Public method to process data using private members
  process() {
    console.log(`Processing data: '${this.#data}'`);
    // Private methods can access other private fields of the same instance
    // Private fields can be used within public methods
    return `Processed: ${this.#data.split('').reverse().join('')}`;
  }

  // Public method to demonstrate calling a private method from a public one
  getProcessedData() {
    // We cannot directly expose #data. Instead, we return a derived value.
    // Attempting to return this.#data directly is fine within the class,
    // but external access to the reference itself is not possible.
    return this.process(); // Calls a public method that uses private members
  }

  // Public method to demonstrate private static field usage
  static checkSizeLimit(inputLength) {
    return inputLength <= DataProcessor.#MAX_SIZE;
  }
}

// Create an instance of DataProcessor
const processor = new DataProcessor('  Hello World  ');
console.log(processor.getProcessedData());

// Demonstrating static private field access (via public static method)
console.log(`Is 50 within size limit? ${DataProcessor.checkSizeLimit(50)}`);
console.log(`Is 150 within size limit? ${DataProcessor.checkSizeLimit(150)}`);

// --- Attempted external access (will fail) ---

// Attempt to access private field #data directly
try {
  console.log(processor.#data); // SyntaxError: Private field '#data' must be declared in an enclosing class
} catch (e) {
  console.error(`Error accessing #data externally: ${e.message}`);
}

// Attempt to call private method #sanitize directly
try {
  processor.#sanitize('new data'); // SyntaxError
} catch (e) {
  console.error(`Error calling #sanitize externally: ${e.message}`);
}

// Attempt to access private static field #MAX_SIZE directly
try {
  console.log(DataProcessor.#MAX_SIZE); // SyntaxError
} catch (e) {
  console.error(`Error accessing static #MAX_SIZE externally: ${e.message}`);
}

/*
  Demonstrates strategic advantages of private class fields in a real-world scenario:
  a sophisticated Logger class managing internal state and configuration.
  Run this code in a modern JavaScript environment (Node.js 14+ or browser).
*/

// A utility for logging to different outputs
const LogOutput = {
  CONSOLE: 'console',
  FILE: 'file', // Placeholder for actual file logging logic
  NETWORK: 'network' // Placeholder for actual network logging logic
};

class Logger {
  // Private instance field to store the current logging level.
  // This prevents external code from directly altering the log level,
  // ensuring all log messages adhere to the configured severity.
  #level;

  // Private static field for default log level and valid levels.
  // This provides a single source of truth for configuration that cannot be modified at runtime.
  static #DEFAULT_LEVEL = 'info';
  static #VALID_LEVELS = new Set(['debug', 'info', 'warn', 'error']);
  static #activeOutputs = new Set([LogOutput.CONSOLE]);

  constructor(level = Logger.#DEFAULT_LEVEL) {
    if (!Logger.#VALID_LEVELS.has(level)) {
      throw new Error(`Invalid log level: '${level}'. Must be one of: ${[...Logger.#VALID_LEVELS].join(', ')}`);
    }
    this.#level = level;
    console.log(`Logger initialized with level: ${this.#level}`);
  }

  // Private method to format log messages consistently.
  // This ensures all messages have a uniform structure, preventing external tampering.
  #formatMessage(level, message) {
    const timestamp = new Date().toISOString();
    return `[${timestamp}][${level.toUpperCase()}]: ${message}`;
  }

  // Private method to determine if a message should be logged based on current level.
  // Encapsulates the logging logic, keeping it internal and protected.
  #shouldLog(messageLevel) {
    const levelsOrder = ['debug', 'info', 'warn', 'error'];
    return levelsOrder.indexOf(messageLevel) >= levelsOrder.indexOf(this.#level);
  }

  // Private method for the actual output mechanism.
  #output(formattedMessage) {
    if (Logger.#activeOutputs.has(LogOutput.CONSOLE)) {
      console.log(formattedMessage);
    }
    // Add logic for file/network logging here if needed
    // if (Logger.#activeOutputs.has(LogOutput.FILE)) { /* writeToFile(formattedMessage) */ }
    // if (Logger.#activeOutputs.has(LogOutput.NETWORK)) { /* sendOverNetwork(formattedMessage) */ }
  }

  // Public methods for logging at different levels.
  debug(message) {
    if (this.#shouldLog('debug')) this.#output(this.#formatMessage('debug', message));
  }

  info(message) {
    if (this.#shouldLog('info')) this.#output(this.#formatMessage('info', message));
  }

  warn(message) {
    if (this.#shouldLog('warn')) this.#output(this.#formatMessage('warn', message));
  }

  error(message) {
    if (this.#shouldLog('error')) this.#output(this.#formatMessage('error', message));
  }

  // Public static method to configure active outputs.
  // This is the only way to modify outputs, ensuring validation and control.
  static activateOutput(outputType) {
    if (Object.values(LogOutput).includes(outputType)) {
      Logger.#activeOutputs.add(outputType);
      console.log(`Output '${outputType}' activated.`);
    } else {
      console.warn(`Invalid output type: '${outputType}'.`);
    }
  }

  static deactivateOutput(outputType) {
    Logger.#activeOutputs.delete(outputType);
    console.log(`Output '${outputType}' deactivated.`);
  }
}

// --- Usage Examples ---

const appLogger = new Logger('info');
appLogger.debug('This debug message will not appear (level is info)');
appLogger.info('Application started successfully.');
appLogger.warn('Potential issue detected with external API.');
appLogger.error('Critical error: Database connection lost!');

console.log('\n--- Changing Logger configuration ---\n');

// Activating file output (hypothetically)
Logger.activateOutput(LogOutput.FILE);

// Deactivating console output
Logger.deactivateOutput(LogOutput.CONSOLE);

// Now, only 'file' output is active, so these messages will not appear on console.
const anotherLogger = new Logger('debug'); // Still respects the info level for 'appLogger'
anotherLogger.debug('This debug message will not appear on console due to deactivated output.');
anotherLogger.info('This info message will not appear on console either.');

// Re-activating console output to see messages again
Logger.activateOutput(LogOutput.CONSOLE);

anotherLogger.debug('Debug message visible again after console re-activation.');

// --- Attempted external modification (will fail) ---

try {
  // Attempt to change log level directly via private field
  // appLogger.#level = 'debug'; 
  eval('appLogger.#level = "debug";'); 
} catch (e) {
  console.error(`\nError attempting to modify private field externally: ${e.message}`);
}

try {
  // Attempt to change static config directly via private static field
  // Logger.#DEFAULT_LEVEL = 'error';
  eval('Logger.#DEFAULT_LEVEL = "error";');
} catch (e) {
  console.error(`Error attempting to modify private static field externally: ${e.message}`);
}

/*
  Demonstrates best practices, including when NOT to use private fields,
  and how to handle serialization challenges.
  Run this code in a modern JavaScript environment (Node.js 14+ or browser).
*/

// --- Best Practice: Avoid over-privacy --- 
// Only make truly internal implementation details private.
// Public API should remain discoverable and accessible.
class UserProfile {
  #userId;
  #passwordHash; // Truly private, sensitive data

  constructor(id, password) {
    this.#userId = id;
    this.#passwordHash = this.#generateHash(password);
  }

  #generateHash(password) {
    // In a real app, use a secure hashing algorithm like bcrypt
    return `hash_${password}_${this.#userId}`;
  }

  // Public method to check password, not expose hash directly
  checkPassword(password) {
    return this.#generateHash(password) === this.#passwordHash;
  }

  // Public properties for non-sensitive data, easily accessible
  username = `user_${this.#userId}`;
  email;

  setEmail(email) {
    // Validate email before setting
    if (email.includes('@')) {
      this.email = email;
    } else {
      console.warn('Invalid email format provided.');
    }
  }
}

const user = new UserProfile(123, 'mySecretPass');
console.log(`Username: ${user.username}`);
user.setEmail('user@example.com');
console.log(`User email: ${user.email}`);
console.log(`Password 'mySecretPass' is correct: ${user.checkPassword('mySecretPass')}`);
console.log(`Password 'wrongPass' is correct: ${user.checkPassword('wrongPass')}`);

// --- Consideration: Serialization --- 
// Private fields are not serialized by default when using JSON.stringify()

class ConfigStore {
  #apiKey = 'secret-123';
  #lastUpdated = new Date();
  publicSetting = 'default';

  get configData() {
    return {
      publicSetting: this.publicSetting,
      // Expose private data explicitly if serialization is desired
      // Make sure sensitive data is handled securely for real applications
      apiKey: this.#apiKey, 
      lastUpdated: this.#lastUpdated.toISOString()
    };
  }
}

const config = new ConfigStore();
config.publicSetting = 'custom_value';

const jsonStringified = JSON.stringify(config); // Only 'publicSetting' will be included
console.log(`\nJSON.stringify(config): ${jsonStringified}`); 
// Output: {"publicSetting":"custom_value"}

// To serialize private data, we must explicitly expose it, e.g., via a getter
const serializedConfig = JSON.stringify(config.configData);
console.log(`JSON.stringify(config.configData): ${serializedConfig}`);
// Output: {"publicSetting":"custom_value","apiKey":"secret-123","lastUpdated":"..."}

// --- Consideration: Debugging --- 
// Private fields are not directly visible in debuggers (e.g., Chrome DevTools 'Scope' panel)
// unless explicitly exposed via a getter or a public method during debugging sessions.

// For debugging, a temporary public getter might be useful:
/*
class DebuggableConfigStore {
  #debugField = 'internal-value';

  // Temporary getter for debugging purposes
  getDebugField() {
    return this.#debugField;
  }
}

const debugConfig = new DebuggableConfigStore();
console.log(debugConfig.getDebugField()); // Access for debugging
*/

/*
  Demonstrates a strategic pathway for migrating a legacy class (using '_' convention)
  to leverage modern private class fields ('#').
  Run this code in a modern JavaScript environment (Node.js 14+ or browser).
*/

// --- Legacy Class: Uses underscore convention for 'private' members ---
class LegacyTaskManager {
  constructor(tasks = []) {
    this._tasks = tasks; // Conventionally private array of tasks
    this._lastTaskId = 0; // Conventionally private counter
  }

  _generateTaskId() {
    this._lastTaskId++;
    return `task-${this._lastTaskId}`;
  }

  addTask(description) {
    const id = this._generateTaskId();
    this._tasks.push({ id, description, completed: false });
    console.log(`Legacy Task added: ${id}`);
  }

  getTasks() {
    return [...this._tasks]; // Return a copy to prevent external modification of internal array
  }

  // External code *could* do this, breaking encapsulation:
  // legacyManager._tasks.push({ id: 'external-task', description: 'Bypass API', completed: false });
}

console.log('--- Legacy Task Manager ---');
const legacyManager = new LegacyTaskManager();
legacyManager.addTask('Read documentation');
legacyManager.addTask('Implement new feature');
console.log('Legacy tasks:', legacyManager.getTasks());
legacyManager._tasks.push({ id: 'hacked-task', description: 'Bypassed task via _tasks', completed: false });
console.log('Legacy tasks after external modification:', legacyManager.getTasks());

console.log('\n--- Migrated Task Manager ---');
// --- Migrated Class: Uses true private fields for encapsulation ---
class TaskManager {
  #tasks; // Truly private array of tasks
  #lastTaskId = 0; // Truly private counter

  constructor(tasks = []) {
    this.#tasks = tasks.map(task => ({ ...task })); // Deep copy for initial tasks
    // Initialize #lastTaskId based on existing tasks if any
    if (this.#tasks.length > 0) {
      const maxIdNum = Math.max(0, ...this.#tasks.map(t => parseInt(t.id.replace('task-', '')) || 0));
      this.#lastTaskId = maxIdNum;
    }
  }

  #generateTaskId() {
    this.#lastTaskId++;
    return `task-${this.#lastTaskId}`;
  }

  addTask(description) {
    const id = this.#generateTaskId();
    this.#tasks.push({ id, description, completed: false });
    console.log(`Task added: ${id}`);
  }

  getTasks() {
    // Always return a defensive copy to prevent external modification of the internal array reference
    return [...this.#tasks]; 
  }

  markTaskCompleted(id) {
    const task = this.#tasks.find(t => t.id === id);
    if (task) {
      task.completed = true;
      console.log(`Task ${id} marked completed.`);
    } else {
      console.warn(`Task ${id} not found.`);
    }
  }
}

const newManager = new TaskManager([
  { id: 'task-1', description: 'Write tests', completed: false }
]);
newManager.addTask('Deploy to production');
newManager.markTaskCompleted('task-1');
console.log('New tasks:', newManager.getTasks());

// Attempt to access private fields directly (will throw SyntaxError)
// try {
//   console.log(newManager.#tasks);
// } catch (e) {
//   console.error(`Error: ${e.message}`);
// }

// The internal array cannot be modified externally:
// newManager.#tasks.push({ id: 'hacked-task', description: 'Bypassed task via #tasks', completed: false });