Advanced JavaScript Engine & Web APIs

// Demonstrating Synchronous vs Microtask vs Macrotask Execution Order
console.log("1. Synchronous Main Script Start");

// Macrotask (Task Queue)
setTimeout(() => {
  console.log("2. Macrotask (setTimeout 0ms)");
}, 0);

// Microtask (Job Queue)
Promise.resolve().then(() => {
  console.log("3. Microtask 1 (Promise.then)");
}).then(() => {
  console.log("4. Microtask 2 (Chained Promise)");
});

// queueMicrotask explicit dispatch
queueMicrotask(() => {
  console.log("5. Microtask 3 (queueMicrotask)");
});

console.log("6. Synchronous Main Script End");

// Node.js / Browser Error-First Callback Pattern: (error, result)
function authenticateUser(username, password, callback) {
  setTimeout(() => {
    if (password === "securePass123") {
      callback(null, { id: 101, user: username });
    } else {
      callback(new Error("Invalid Credentials"), null);
    }
  }, 400);
}

function getUserOrders(userId, callback) {
  setTimeout(() => {
    callback(null, ["ORD-9021", "ORD-9022"]);
  }, 300);
}

// The Pyramid of Doom (Callback Hell)
authenticateUser("shiva", "securePass123", (err, user) => {
  if (err) {
    console.error("Authentication Failed:", err.message);
    return;
  }
  console.log("Auth Success:", user);

  // Nested Level 2
  getUserOrders(user.id, (orderErr, orders) => {
    if (orderErr) {
      console.error("Failed to get orders:", orderErr.message);
      return;
    }
    console.log("Retrieved Orders for User:", orders);
  });
});

// 1. Creating a Promise wrapper
function fetchServerMetric(serverName, delayMs, shouldFail = false) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (shouldFail) {
        reject(new Error(f`Server ${serverName} is offline`));
      } else {
        resolve({ server: serverName, ping: delayMs });
      }
    }, delayMs);
  });
}

// 2. Promise Chaining: Flattening the Pyramid
fetchServerMetric("US-East", 200)
  .then((res) => {
    console.log("Step 1 Received:", res.server);
    return fetchServerMetric("EU-West", 150); // Return new promise
  })
  .then((res2) => {
    console.log("Step 2 Received:", res2.server);
  })
  .catch((err) => {
    console.error("Chain Error:", err.message);
  })
  .finally(() => {
    console.log("Pipeline Complete: Connection closed.\n");
  });

// 3. Promise.allSettled: Resilient Batch Dispatch
const serverPromises = [
  fetchServerMetric("Server-Alpha", 100, false),
  fetchServerMetric("Server-Beta", 250, true),   // Fails!
  fetchServerMetric("Server-Gamma", 150, false)
];

Promise.allSettled(serverPromises).then((results) => {
  console.log("=== Server Telemetry Audit ===");
  results.forEach((outcome, idx) => {
    if (outcome.status === "fulfilled") {
      console.log(f`✔ [Online]  ${outcome.value.server} - Ping: ${outcome.value.ping}ms`);
    } else {
      console.log(f`✖ [Offline] Error: ${outcome.reason.message}`);
    }
  });
});

const delay = (ms) => new Promise((res) => setTimeout(res, ms));

async function fetchUserProfile(userId) {
  await delay(200);
  if (userId <= 0) throw new Error("Invalid User ID specified");
  return { id: userId, username: "devascent_coder", role: "Senior Engineer" };
}

async function fetchUserPermissions(role) {
  await delay(150);
  return ["READ", "WRITE", "DEPLOY"];
}

// Clean Asynchronous Orchestration
async function loadDashboard(targetId) {
  console.log("Starting dashboard data acquisition...");
  try {
    // 1. Sequential dependency: Permissions require the profile's role
    const profile = await fetchUserProfile(targetId);
    console.log("Profile loaded:", profile.username);

    const permissions = await fetchUserPermissions(profile.role);
    console.log("Permissions verified:", permissions);

    return { ...profile, permissions };
  } catch (err) {
    console.error("Dashboard Load Failed:", err.message);
    return null;
  } finally {
    console.log("Cleanup: Loading spinner dismissed.");
  }
}

loadDashboard(501);

// Production-grade Fetch utility with Timeout and Status Checking
async function postCourseReview(endpointUrl, payload, timeoutMs = 4000) {
  // Set up AbortController for strict network cancellation
  const controller = new AbortController();
  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);

  try {
    const response = await fetch(endpointUrl, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "Authorization": "Bearer devascent_token_9901"
      },
      body: JSON.stringify(payload),
      signal: controller.signal
    });

    // Clear the timer once response headers arrive
    clearTimeout(timeoutId);

    // Mandatory HTTP Status Guard
    if (!response.ok) {
      throw new Error(f`HTTP Server Failure: ${response.status} ${response.statusText}`);
    }

    // Phase 2: Stream decode JSON payload
    const data = await response.json();
    console.log("Submission Successful:", data);
    return data;
  } catch (err) {
    if (err.name === "AbortError") {
      console.error("Fetch Terminated: Network request timed out!");
    } else {
      console.error("Network/Server Error:", err.message);
    }
    throw err;
  }
}

const studentProfile = {
  id: 884,
  fullName: "Siddharth Verma",
  isActive: true,
  skills: ["JavaScript", "React", "Node.js"],
  gpa: 3.88,
  // Unsupported types in JSON:
  registeredAt: new Date("2026-08-15"), // Serialized to ISO String
  internalNotes: undefined,               // DROPPED completely!
  calculateFees: function() { return 0; } // DROPPED completely!
};

// 1. JSON.stringify(value, replacer, space)
const jsonText = JSON.stringify(studentProfile, null, 2);
console.log("Serialized JSON String:\n" + jsonText);

// 2. Defensive JSON.parse() utility
function safeParseJSON(rawText, fallback = {}) {
  try {
    return JSON.parse(rawText);
  } catch (err) {
    console.warn("JSON Parse Warning: Corrupted payload, using fallback.", err.message);
    return fallback;
  }
}

const corruptedPayload = '{ "name": "Aman", "grade": }'; // Malformed syntax!
const safeResult = safeParseJSON(corruptedPayload, { error: true });
console.log("Safe parse result:", safeResult);

// Production Storage Engine: Auto-Serialization + Time-To-Live (TTL) Cache
const StorageEngine = {
  set(key, value, ttlSeconds = 3600) {
    const now = Date.now();
    const item = {
      data: value,
      expiry: now + (ttlSeconds * 1000)
    };
    try {
      localStorage.setItem(key, JSON.stringify(item));
      console.log(f`Saved '${key}' with TTL: ${ttlSeconds}s`);
    } catch (e) {
      // Catches QuotaExceededError if device disk is completely full
      console.error("Storage Quota Exceeded:", e);
    }
  },

  get(key) {
    const itemStr = localStorage.getItem(key);
    if (!itemStr) return null;

    try {
      const item = JSON.parse(itemStr);
      // Check if the expiration timestamp has elapsed
      if (Date.now() > item.expiry) {
        localStorage.removeItem(key);
        console.warn(f`Item '${key}' expired and was evicted from cache.`);
        return null;
      }
      return item.data;
    } catch (e) {
      return null;
    }
  },

  remove(key) {
    localStorage.removeItem(key);
  }
};

// Example: Caching user theme settings
StorageEngine.set("app_theme", { mode: "dark", accent: "#f59e0b" }, 5);
const cachedTheme = StorageEngine.get("app_theme");
console.log("Retrieved Theme:", cachedTheme);

// =================== FILE 1: utils/mathEngine.js ===================
// Named exports
export const TAX_RATE = 0.18;

export function calculateFinalPrice(basePrice, discount = 0) {
  const discounted = basePrice - discount;
  return discounted + (discounted * TAX_RATE);
}

// Default export (The primary tool of this module)
export default class InvoiceLedger {
  constructor(clientName) {
    this.client = clientName;
    this.items = [];
  }
  addItem(name, cost) {
    this.items.push({ name, cost });
  }
}

// =================== FILE 2: mainApplication.js ===================
// Combining default import and named imports with renaming ('as')
import InvoiceLedger, { calculateFinalPrice as getPrice, TAX_RATE } from "./utils/mathEngine.js";

const orderLedger = new InvoiceLedger("DevAscent Academy");
orderLedger.addItem("Cloud Hosting", 12000);

console.log("Tax Standard:", (TAX_RATE * 100) + "%");
console.log("Calculated Total:", getPrice(12000, 2000));

// Dynamic Import on-demand (Code-Splitting for performance)
async function loadHeavyChartingLibrary() {
  console.log("Loading charting engine dynamically...");
  const chartMod = await import("./analyticsChart.js");
  chartMod.renderGraph();
}

const serverClusters = [
  { id: "node-01", region: "ap-south-1", load: "45%", status: "ACTIVE" },
  { id: "node-02", region: "us-east-1", load: "89%", status: "WARNING" },
  { id: "node-03", region: "eu-central-1", load: "12%", status: "ACTIVE" }
];

// 1. Clean structured table output
console.table(serverClusters);

// 2. Execution timing benchmarking
console.time("Heavy Data Processing Benchmark");
let sum = 0;
for (let i = 0; i < 1000000; i++) {
  sum += i;
}
console.timeEnd("Heavy Data Processing Benchmark");

// 3. Defensive Assertion & Stack Trace
function processTransaction(amount) {
  console.assert(amount > 0, f`Transaction Rejected: Invalid amount ₹${amount}`);
  if (amount <= 0) {
    console.trace("Call stack trace for audit:");
    // debugger; // Uncomment to freeze execution in DevTools
  }
}

processTransaction(-500);

/**
 * DevAscent Telemetry Engine
 * Features:
 * - Exponential Retry with Jitter
 * - Promise.allSettled Multi-Stream Parallelism
 * - LocalStorage Cache with TTL Expiration
 * - Structured JSON Schema Validation
 */

const TelemetryCache = {
  CACHE_PREFIX: "devascent_ticker_",

  read(symbol) {
    const raw = localStorage.getItem(this.CACHE_PREFIX + symbol);
    if (!raw) return null;
    try {
      const record = JSON.parse(raw);
      if (Date.now() > record.expiry) {
        localStorage.removeItem(this.CACHE_PREFIX + symbol);
        return null;
      }
      return record.data;
    } catch (e) {
      return null;
    }
  },

  write(symbol, data, ttlSeconds = 60) {
    const envelope = {
      data,
      expiry: Date.now() + (ttlSeconds * 1000)
    };
    localStorage.setItem(this.CACHE_PREFIX + symbol, JSON.stringify(envelope));
  }
};

// Resilient network fetcher with exponential backoff
async function fetchTickerWithRetry(symbol, retries = 2, delayMs = 300) {
  // 1. Check local storage cache first!
  const cached = TelemetryCache.read(symbol);
  if (cached) {
    return { ...cached, source: "LOCAL_STORAGE_CACHE" };
  }

  // 2. Attempt network transmission
  for (let attempt = 1; attempt <= retries + 1; attempt++) {
    try {
      console.log(f`Fetching [${symbol}] - Attempt #${attempt}...`);
      
      // Simulated network latency
      await new Promise((res) => setTimeout(res, 100));

      // Simulated sporadic network failure for demo
      if (symbol === "ETHEREUM" && attempt === 1) {
        throw new Error("Gateway 504 Timeout");
      }

      const mockData = {
        symbol,
        priceUSD: symbol === "BITCOIN" ? 68450.00 : 3520.50,
        timestamp: new Date().toISOString()
      };

      // Save in cache for 30 seconds
      TelemetryCache.write(symbol, mockData, 30);
      return { ...mockData, source: "LIVE_NETWORK_SOCKET" };
    } catch (err) {
      if (attempt > retries) throw err;
      console.warn(f`Retry Backoff: Attempt #${attempt} failed. Retrying in ${delayMs}ms...`);
      await new Promise((r) => setTimeout(r, delayMs));
      delayMs *= 2; // Exponential backoff
    }
  }
}

// Main Concurrent Dispatcher
async function runFinancialTelemetryStation() {
  console.log("==================================================");
  console.log("   DEVASCENT REAL-TIME TELEMETRY STATION");
  console.log("==================================================\n");

  const targets = ["BITCOIN", "ETHEREUM", "SOLANA"];
  
  // Dispatch all feeds simultaneously with Promise.allSettled
  const outcomes = await Promise.allSettled(
    targets.map((sym) => fetchTickerWithRetry(sym))
  );

  outcomes.forEach((outcome, i) => {
    if (outcome.status === "fulfilled") {
      const item = outcome.value;
      console.log(f`✔ [${item.symbol}] $${item.priceUSD} | Feed: ${item.source}`);
    } else {
      console.error(f`✖ [FAILED] Target Feed: ${targets[i]} | Reason: ${outcome.reason.message}`);
    }
  });

  console.log("\n==================================================");
}

runFinancialTelemetryStation();