// 1. Cập nhật Object
const user = { name: "An", role: "user", address: { city: "HCM" } };

// Object spread vs Object.assign (Cảnh báo: Đều là shallow copy!)
const updatedUser = { ...user, role: "admin" }; 
// ⚠️ nested object vẫn dùng chung tham chiếu!
updatedUser.address.city = "Hanoi"; // user.address.city cũng bị đổi thành "Hanoi"!

// Deep copy bằng structuredClone (ES2022)
const deepCopyUser = structuredClone(user);
deepCopyUser.address.city = "Danang"; // An toàn, user.address.city vẫn là "Hanoi"

// 2. Cập nhật Array
const list = [1, 2, 3, 4];

// Không dùng push, pop, shift, unshift, splice (các hàm này mutate array gốc)
// Hãy dùng: spread operator, map, filter, concat, slice
const added = [...list, 5];                // push
const removed = list.filter(x => x !== 3); // remove item 3
const updated = list.map(x => x === 2 ? 20 : x); // update item 2 -> 20

function produce(baseState, recipe) {
  const draft = structuredClone(baseState); // Tạo bản sao deep
  recipe(draft); // Thực thi hàm biến đổi trên draft
  return Object.freeze(draft); // Trả về bản sao đóng băng (immutable)
}

const state = { name: "Quang", tags: ["js", "html"] };
const nextState = produce(state, draft => {
  draft.name = "Tang Quang";
  draft.tags.push("css");
});

console.log(state.name);      // "Quang" (không đổi)
console.log(nextState.name);  // "Tang Quang" (đổi)
console.log(state.tags);      // ["js", "html"] (không đổi)

const pipe = (...fns) => (x) => fns.reduce((res, fn) => fn(res), x);
const compose = (...fns) => (x) => fns.reduceRight((res, fn) => fn(res), x);

/**
 * Bài 3: JavaScript Functional Programming, High-Order Functions, Pipe/Compose và V8 Elements Kinds
 * Giáo trình tự học JavaScript - js-tools.org
 */

console.log("=== 1. Pure Functions & Immutability ===");

// Hàm không thuần khiết (impure) - làm thay đổi trực tiếp thuộc tính đối tượng (Side Effect)
function updateAgeImpure(user, newAge) {
  user.age = newAge; 
  return user;
}

// Hàm thuần khiết (pure) - tạo ra bản sao mới, bảo toàn nguyên gốc đối tượng cũ
function updateAgePure(user, newAge) {
  return { ...user, age: newAge }; // spread operator tạo bản sao mới
}

const userObj = { name: "An", age: 20 };
const updatedUser = updateAgePure(userObj, 21);
console.log("Đối tượng gốc không đổi (Immutability):", userObj); 
console.log("Đối tượng mới tạo ra:", updatedUser); 


console.log("\n=== 2. Currying (Chuyển đổi tham số) ===");

const add = (a, b, c) => a + b + c;

// Curried function dạng mũi tên lồng nhau
const curriedAdd = (a) => (b) => (c) => a + b + c;

console.log("Cộng thông thường add(1, 2, 3):", add(1, 2, 3));
console.log("Cộng curried curriedAdd(1)(2)(3):", curriedAdd(1)(2)(3));

// Ứng dụng: Tạo các hàm ghi log chuyên biệt
const log = (importance) => (message) => {
  console.log(`[${importance.toUpperCase()}] [${new Date().toLocaleTimeString()}]: ${message}`);
};

const logInfo = log("info");
const logError = log("error");

logInfo("Hệ thống khởi chạy thành công.");
logError("Kết nối cơ sở dữ liệu thất bại.");


console.log("\n=== 3. Memoization (Tối ưu hóa bằng lưu trữ bộ nhớ đệm) ===");

function fibonacci(n) {
  if (n <= 1) return n;
  return fibonacci(n - 1) + fibonacci(n - 2);
}

// High-Order Function để thực hiện memoize tổng quát
function memoize(fn) {
  const cache = {}; // Object đóng vai trò làm bộ nhớ đệm
  return function(...args) {
    const key = JSON.stringify(args);
    if (key in cache) {
      return cache[key];
    }
    const result = fn.apply(this, args);
    cache[key] = result;
    return result;
  };
}

const fastFibonacci = memoize(function(n) {
  if (n <= 1) return n;
  return fastFibonacci(n - 1) + fastFibonacci(n - 2);
});

console.time("Fibonacci thông thường (n=35)");
fibonacci(35);
console.timeEnd("Fibonacci thông thường (n=35)"); 

console.time("Fibonacci tối ưu qua Memoize (n=35)");
fastFibonacci(35);
console.timeEnd("Fibonacci tối ưu qua Memoize (n=35)"); 


console.log("\n=== 4. Khai thác High-Order Functions trên Array ===");

const products = [
  { id: 1, name: "Laptop", price: 1500, category: "Tech" },
  { id: 2, name: "Phone", price: 800, category: "Tech" },
  { id: 3, name: "Book", price: 20, category: "Lifestyle" },
  { id: 4, name: "Keyboard", price: 100, category: "Tech" }
];

// Pipeline biến đổi dữ liệu sạch sẽ
const totalTechPrice = products
  .filter(p => p.category === "Tech") 
  .map(p => p.price)                   
  .reduce((sum, price) => sum + price, 0); 

console.log("Tổng giá trị các sản phẩm Tech:", totalTechPrice); 


console.log("\n=== 5. Xây dựng hàm Pipe & Compose ===");

// Pipe chạy từ trái qua phải (f -> g -> h)
const pipe = (...fns) => (x) => fns.reduce((res, fn) => fn(res), x);

// Compose chạy từ phải qua trái (h -> g -> f)
const compose = (...fns) => (x) => fns.reduceRight((res, fn) => fn(res), x);

const doubleVal = x => x * 2;
const addTen = x => x + 10;

const runPipe = pipe(doubleVal, addTen); // (x * 2) + 10
const runCompose = compose(doubleVal, addTen); // (x + 10) * 2

console.log("Pipe(doubleVal, addTen)(5) = ", runPipe(5)); // 20
console.log("Compose(doubleVal, addTen)(5) = ", runCompose(5)); // 30


console.log("\n=== 6. Mô phỏng V8 Elements Kinds trong Array ===");

// 1. SMI Elements: Mảng chứa toàn số nguyên nhỏ (Small Integers) -> Truy cập bộ nhớ O(1) tối đa
const arrSmi = [1, 2, 3]; // PACKED_SMI_ELEMENTS

// 2. Double Elements: Chứa số thực -> V8 chuyển đổi toàn bộ mảng sang dạng Double
arrSmi.push(4.5); // PACKED_DOUBLE_ELEMENTS (deoptimized)

// 3. Holey Elements: Có lỗ hổng trong chỉ mục mảng
const arrHoley = [1, 2, 3];
arrHoley[10] = 11; // Lỗ hổng ở chỉ mục 3 đến 9 -> HOLEY_SMI_ELEMENTS (truy cập chậm do check prototype)

console.log("arrSmi và arrHoley đã được khởi tạo để V8 xử lý phân loại Elements Kinds.");

// Cách truyền thống: if/else lồng nhau (Pyramid of Doom)
function getUserAvatarOld(userId) {
  const user = getUser(userId);
  if (user === null) return 'default.png';
  const profile = user.profile;
  if (profile === null) return 'default.png';
  const avatar = profile.avatar;
  if (avatar === null) return 'default.png';
  return avatar;
}

// Maybe Monad: null-safe chaining thanh lịch
class Maybe {
  constructor(value) { this._value = value; }

  static of(value) { return new Maybe(value); }

  isNothing() { return this._value === null || this._value === undefined; }

  // map: áp dụng fn nếu có giá trị, bỏ qua nếu null/undefined
  map(fn) {
    return this.isNothing() ? this : Maybe.of(fn(this._value));
  }

  // chain: giống map nhưng fn trả về Maybe (tránh Maybe lồng Maybe)
  chain(fn) {
    return this.isNothing() ? this : fn(this._value);
  }

  getOrElse(defaultValue) {
    return this.isNothing() ? defaultValue : this._value;
  }
}

// Sử dụng:
const getUser = (id) => Maybe.of(id === 1 ? { profile: { avatar: 'me.jpg' } } : null);

// Với user hợp lệ
const avatar1 = getUser(1)
  .map(u => u.profile)
  .map(p => p.avatar)
  .getOrElse('default.png');
console.log(avatar1);  // "me.jpg"

// Với user null — không crash, trả về default
const avatar2 = getUser(999)
  .map(u => u.profile)
  .map(p => p.avatar)
  .getOrElse('default.png');
console.log(avatar2);  // "default.png"

// Cách thông thường: 3 array tạm
const nums = Array.from({ length: 1000 }, (_, i) => i);
const result1 = nums
  .filter(n => n % 2 === 0)    // → Array[500]
  .map(n => n * 3)             // → Array[500]
  .reduce((acc, n) => acc + n, 0);

// Transducer: chỉ 1 lần reduce, không array tạm
const mapping = (fn) => (reducer) => (acc, val) => reducer(acc, fn(val));
const filtering = (pred) => (reducer) => (acc, val) => pred(val) ? reducer(acc, val) : acc;
const append = (acc, val) => { acc.push(val); return acc; };
const sum = (acc, val) => acc + val;

const transduce = (xform, reducer, init, coll) =>
  coll.reduce(xform(reducer), init);

// Compose 2 transducers: filter rồi map, chạy 1 lần
const xform = filtering(n => n % 2 === 0)(mapping(n => n * 3)(sum));
const result2 = nums.reduce((acc, val) => xform(acc, val), 0);

console.log(result1 === result2); // true — cùng kết quả!
// Nhưng result2 không tạo array tạm, tiết kiệm ~2x memory