/*
 * Reflect API: Direct invocation of internal JavaScript operations.
 * It's not a constructor; all its methods are static.
 * Each method corresponds to a trap in the Proxy API, providing a default, consistent behavior.
 */

// 1. Reflect.get(target, propertyKey, receiver)
// Retrieves the value of a property from an object.
const user = {
  firstName: 'John',
  lastName: 'Doe',
  get fullName() {
    return `${this.firstName} ${this.lastName}`;
  }
};

console.log('--- Reflect.get Examples ---');
console.log('Direct property access:', Reflect.get(user, 'firstName')); // Output: John

// Demonstrating 'receiver' for 'this' binding in getters
const proxyLikeObject = { firstName: 'Jane', lastName: 'Smith' };
console.log('Getter with receiver:', Reflect.get(user, 'fullName', proxyLikeObject)); // Output: Jane Smith
// Without receiver, 'this' would refer to 'user' itself. With receiver, 'this' points to 'proxyLikeObject' during fullName execution.


// 2. Reflect.set(target, propertyKey, value, receiver)
// Sets the value of a property on an object.
console.log('\n--- Reflect.set Examples ---');
const product = { name: 'Laptop', price: 1200 };
let successSet = Reflect.set(product, 'price', 1300);
console.log('Price after set:', product.price);     // Output: 1300
console.log('Set operation successful:', successSet); // Output: true (boolean indicating success)

// Using 'receiver' in conjunction with setters (less common than with getters, but possible)
const dimensions = { width: 100, height: 200, set area(val) { this.width = val / 2; this.height = val / 2; } };
const newSize = { width: 0, height: 0 };
Reflect.set(dimensions, 'area', 400, newSize);
console.log('NewSize after set with receiver (width):', newSize.width); // Output: 200 (width of newSize modified by setter)
console.log('NewSize after set with receiver (height):', newSize.height); // Output: 200


// 3. Reflect.has(target, propertyKey)
// Checks if an object has a property.
console.log('\n--- Reflect.has Examples ---');
console.log('Has firstName:', Reflect.has(user, 'firstName'));  // Output: true
console.log('Has age:', Reflect.has(user, 'age'));            // Output: false

// 4. Reflect.deleteProperty(target, propertyKey)
// Deletes a property from an object.
console.log('\n--- Reflect.deleteProperty Examples ---');
const config = { debugMode: true, verbose: false };
let deleted = Reflect.deleteProperty(config, 'verbose');
console.log('Config after deletion:', config);      // Output: { debugMode: true }
console.log('Deletion successful:', deleted);       // Output: true

// 5. Reflect.ownKeys(target)
// Returns an array of the target object's own property keys (enumerable and non-enumerable).
console.log('\n--- Reflect.ownKeys Example ---');
const objWithSymbols = { a: 1, [Symbol('b')]: 2 };
Object.defineProperty(objWithSymbols, 'c', { value: 3, enumerable: false });
console.log('Own keys:', Reflect.ownKeys(objWithSymbols)); // Output: [ 'a', 'c', Symbol(b) ] (order might vary)

// Reflect offers a consistent, predictable interface. Unlike direct object operations, which might throw errors
// or return different results based on contexts (e.g., calling a setter on a non-writable property vs. Reflect.set), 
// Reflect methods consistently return a boolean for success/failure where applicable, or the computed value.

/*
 * Proxy API: Intercepts fundamental operations for a target object.
 * It allows us to define custom behaviors (traps) for these operations.
 * Without Reflect, handling default forwarding in traps can be complex and error-prone.
 */

// Define a target object
const targetObject = {
  message: 'Hello',
  _secret: 'top_secret_data',
  get greet() {
    return `${this.message} World!`;
  }
};

// 1. Basic Proxy without Reflect (manual default forwarding)
// This demonstrates the complexity of correctly implementing default behavior manually.
const handlerWithoutReflect = {
  get(target, property, receiver) {
    console.log(`[WITHOUT REFLECT] Intercepting GET for property: ${String(property)}`);
    // Manual forwarding logic:
    if (property in target) {
      const value = target[property];
      // Special handling for functions and getters to maintain 'this' context
      if (typeof value === 'function') {
        return function (...args) {
          return value.apply(receiver, args);
        };
      }
      const descriptor = Object.getOwnPropertyDescriptor(target, property);
      if (descriptor && descriptor.get) {
        return descriptor.get.call(receiver);
      }
      return value;
    } else {
      return undefined; // Default for non-existent properties
    }
  },
  set(target, property, value, receiver) {
    console.log(`[WITHOUT REFLECT] Intercepting SET for property: ${String(property)} with value: ${value}`);
    // Manual forwarding logic:
    const descriptor = Object.getOwnPropertyDescriptor(target, property);
    if (descriptor && descriptor.set) {
      descriptor.set.call(receiver, value); // Use setter if available
      return true;
    } else if (descriptor && !descriptor.writable) {
      console.error(`Attempt to set non-writable property '${String(property)}'`);
      return false; // Cannot set non-writable property
    } else {
      target[property] = value;
      return true;
    }
  },
  has(target, property) {
    console.log(`[WITHOUT REFLECT] Intercepting HAS for property: ${String(property)}`);
    return property in target; // Manual default
  }
};

const proxyWithoutReflect = new Proxy(targetObject, handlerWithoutReflect);

console.log('\n--- Proxy without Reflect Examples ---');
console.log('Get existing property:', proxyWithoutReflect.message); // Output: [WITHOUT REFLECT] Intercepting GET... Hello
console.log('Get non-existent property:', proxyWithoutReflect.nonExistent); // Output: [WITHOUT REFLECT] Intercepting GET... undefined
proxyWithoutReflect.message = 'Hola';
console.log('Set existing property:', proxyWithoutReflect.message); // Output: [WITHOUT REFLECT] Intercepting SET... Hola
console.log('Has property message:', 'message' in proxyWithoutReflect); // Output: [WITHOUT REFLECT] Intercepting HAS... true

// Issues with manual forwarding:
// 1. Verbose and repetitive code for each trap.
// 2. Easy to miss edge cases (e.g., 'this' binding for getters/setters, non-configurable properties).
// 3. Difficult to maintain as JavaScript's internal methods evolve or new features are introduced.
// Reflect API provides a standardized, reliable way to achieve this default behavior.

/*
 * The Synergy: Using Reflect API methods within Proxy traps.
 * Reflect methods provide the correct, standardized default behavior for intercepted operations.
 * This ensures consistency, proper 'this' binding, and less boilerplate.
 */

// Target object with various property types
const employee = {
  name: 'Alice',
  _salary: 50000,
  status: 'active',
  get annualSalary() {
    return this._salary;
  },
  set annualSalary(value) {
    if (value < 0) {
      console.error('Salary cannot be negative.');
      return;
    }
    this._salary = value;
  },
  work() {
    return `${this.name} is working.`;
  }
};

// Proxy handler utilizing Reflect for default forwarding
const reflectingHandler = {
  // Intercepting property read operations
  get(target, property, receiver) {
    console.log(`[PROXY with Reflect] Intercepting GET for property: ${String(property)}`);
    // Use Reflect.get to forward the operation to the target
    // It correctly handles 'this' binding for getters via the 'receiver' argument.
    return Reflect.get(target, property, receiver);
  },

  // Intercepting property write operations
  set(target, property, value, receiver) {
    console.log(`[PROXY with Reflect] Intercepting SET for property: ${String(property)} with value: ${value}`);
    // Example: Basic validation before forwarding the set operation
    if (property === 'status' && !['active', 'inactive', 'on leave'].includes(value)) {
      console.warn(`Invalid status value for '${String(property)}': ${value}`);
      return false; // Prevent setting invalid status
    }
    // Use Reflect.set to forward the operation.
    // It correctly handles 'this' binding for setters and returns a boolean for success/failure.
    return Reflect.set(target, property, value, receiver);
  },

  // Intercepting 'in' operator checks
  has(target, property) {
    console.log(`[PROXY with Reflect] Intercepting HAS for property: ${String(property)}`);
    // Use Reflect.has for default 'in' operator behavior
    return Reflect.has(target, property);
  },

  // Intercepting function calls (e.g., employee.work())
  apply(target, thisArg, argumentsList) {
    console.log(`[PROXY with Reflect] Intercepting APPLY for method: ${target.name || 'anonymous function'}`);
    // Example: Log before and after function execution
    console.log('Before method execution...');
    const result = Reflect.apply(target, thisArg, argumentsList);
    console.log('After method execution...');
    return result;
  },

  // Intercepting constructor calls (e.g., new Class())
  construct(target, argumentsList, newTarget) {
    console.log(`[PROXY with Reflect] Intercepting CONSTRUCT for class: ${target.name || 'anonymous class'}`);
    // Example: Log constructor call
    console.log('Creating a new instance...');
    return Reflect.construct(target, argumentsList, newTarget);
  },

  // Add more traps here as needed, always forwarding with Reflect for default behavior.
  // E.g., ownKeys, deleteProperty, defineProperty, etc.

  // Example of deleteProperty trap
  deleteProperty(target, property) {
    console.log(`[PROXY with Reflect] Intercepting DELETE for property: ${String(property)}`);
    if (property === 'name') {
      console.warn('Cannot delete the name property.');
      return false; // Prevent deletion
    }
    return Reflect.deleteProperty(target, property);
  }
};

const employeeProxy = new Proxy(employee, reflectingHandler);

console.log('\n--- Proxy with Reflect Examples ---');

// Get operations
console.log('Employee name:', employeeProxy.name); // Uses get trap -> Reflect.get
console.log('Employee salary (getter):', employeeProxy.annualSalary); // Uses get trap -> Reflect.get, correctly binding 'this'
console.log('Employee job description (non-existent):', employeeProxy.jobDescription); // Uses get trap -> Reflect.get -> undefined

// Set operations
employeeProxy.name = 'Bob'; // Uses set trap -> Reflect.set
console.log('New employee name:', employeeProxy.name);
employeeProxy.annualSalary = 60000; // Uses set trap -> Reflect.set, correctly binding 'this' for setter
console.log('New employee salary:', employeeProxy.annualSalary);
employeeProxy.annualSalary = -100; // Uses set trap -> Reflect.set, but our custom validation prevents it and logs error.

employeeProxy.status = 'on leave'; // Valid status
console.log('Employee status:', employeeProxy.status);
employeeProxy.status = ' nghỉ'; // Invalid status, our custom validation catches it
console.log('Employee status after invalid attempt:', employeeProxy.status); // Still 'on leave'

// Has operation
console.log('Has name property:', 'name' in employeeProxy); // Uses has trap -> Reflect.has

// Apply operation (for methods)
console.log(employeeProxy.work()); // Uses apply trap -> Reflect.apply

// Delete operation
const tempObj = { id: 123 };
const tempProxy = new Proxy(tempObj, reflectingHandler);
console.log('Before delete tempObj:', tempProxy);
Reflect.deleteProperty(tempProxy, 'id'); // Uses deleteProperty trap -> Reflect.deleteProperty
console.log('After delete tempObj:', tempProxy);

console.log('Attempt to delete protected property:');
Reflect.deleteProperty(employeeProxy, 'name'); // Uses deleteProperty trap -> custom logic blocks it.
console.log('Employee name after failed deletion attempt:', employeeProxy.name);

// Key takeaway: Reflect.method(target, ...) provides the most robust and correct way
// to forward operations to the underlying target within a Proxy trap, handling 'this' context
// and property descriptors precisely as the JavaScript engine would natively.

/*
 * Advanced Patterns: Combining Proxy and Reflect for powerful abstractions.
 * Examples include validation, observability, memoization, and ORM-like structures.
 * Best practices emphasize consistent Reflect usage for robustness.
 */

// 1. Validation Proxy: Ensuring data integrity
class User {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }
}

const userValidator = {
  set(target, property, value, receiver) {
    if (property === 'name') {
      if (typeof value !== 'string' || value.length < 2) {
        console.error('Validation Error: Name must be a string of at least 2 characters.');
        return false;
      }
    }
    if (property === 'age') {
      if (typeof value !== 'number' || value < 0 || !Number.isInteger(value)) {
        console.error('Validation Error: Age must be a non-negative integer.');
        return false;
      }
    }
    // Always use Reflect for default forwarding after validation
    return Reflect.set(target, property, value, receiver);
  },
  // Include other traps like 'get' for completeness or specific logging/access control
  get(target, property, receiver) {
    console.log(`Accessing ${String(property)} for validation check.`);
    return Reflect.get(target, property, receiver);
  }
};

console.log('\n--- Validation Proxy Example ---');
const validatedUser = new Proxy(new User('Charlie', 30), userValidator);
console.log('Initial user:', validatedUser);
validatedUser.name = 'David'; // Valid
validatedUser.age = 35;     // Valid
console.log('Updated user:', validatedUser);
validatedUser.name = 'A';   // Invalid: shorter than 2 chars
validatedUser.age = -5;     // Invalid: negative age
validatedUser.age = 30.5;   // Invalid: not an integer
console.log('User after invalid attempts:', validatedUser);


// 2. Observable Object: Notifying subscribers of changes
function createObservable(obj) {
  const subscribers = new Set();

  return {
    subscribe(callback) {
      subscribers.add(callback);
      return () => subscribers.delete(callback); // Unsubscribe function
    },
    proxy: new Proxy(obj, {
      set(target, property, value, receiver) {
        const oldValue = Reflect.get(target, property, receiver);
        const success = Reflect.set(target, property, value, receiver);
        if (success && oldValue !== value) {
          subscribers.forEach(callback => callback(property, value, oldValue));
        }
        return success;
      },
      get(target, property, receiver) {
        // Just forward get operations, or add specific logging/access control
        return Reflect.get(target, property, receiver);
      }
    })
  };
}

console.log('\n--- Observable Object Example ---');
const data = createObservable({ counter: 0, text: 'initial' });
const unsubscribe = data.subscribe((prop, newValue, oldValue) => {
  console.log(`Observed change: ${prop} from '${oldValue}' to '${newValue}'`);
});

data.proxy.counter++;  // Output: Observed change: counter from '0' to '1'
data.proxy.text = 'updated'; // Output: Observed change: text from 'initial' to 'updated'
data.proxy.counter++;  // Output: Observed change: counter from '1' to '2'
unsubscribe();
data.proxy.text = 'final'; // No output, unsubscribed


// 3. Simple Memoization Proxy: Caching function results
function expensiveCalculation(a, b) {
  console.log('Performing expensive calculation...');
  return a + b;
}

function memoize(fn) {
  const cache = new Map();
  return new Proxy(fn, {
    apply(target, thisArg, argumentsList) {
      const key = JSON.stringify(argumentsList); // Simple key for memoization
      if (cache.has(key)) {
        console.log(`[MEMOIZED] Returning cached result for ${key}`);
        return cache.get(key);
      }
      const result = Reflect.apply(target, thisArg, argumentsList);
      cache.set(key, result);
      return result;
    }
  });
}

console.log('\n--- Memoization Proxy Example ---');
const memoizedCalc = memoize(expensiveCalculation);
console.log('Result 1:', memoizedCalc(1, 2)); // Performs calculation, caches
console.log('Result 2:', memoizedCalc(1, 2)); // Returns cached
console.log('Result 3:', memoizedCalc(3, 4)); // Performs calculation, caches
console.log('Result 4:', memoizedCalc(1, 2)); // Returns cached

// Key Best Practices:
// - Always use Reflect for default forwarding within traps unless you have a specific, well-understood reason not to.
// - Ensure 'receiver' is passed to Reflect methods when appropriate (e.g., get, set, apply).
// - Consider the performance impact: Proxies add a slight overhead. Use judiciously.
// - Document your Proxy traps: Complex traps can be difficult to reason about.