JavaScript Error Handling – try, catch, finally

function parseJSON(text) {
  try {
    const data = JSON.parse(text);
    console.log('Parsed:', data);
    return data;
  } catch (error) {
    console.error('Parse failed:', error.message);
    return null;
  } finally {
    console.log('parseJSON completed'); // always runs
  }
}

parseJSON('{"name":"Alice"}'); // Parsed: {name:'Alice'} → parseJSON completed
parseJSON('not valid json');   // Parse failed: ... → parseJSON completed

// Optional catch binding (ES2019) – omit the error variable if not needed
try {
  riskyOperation();
} catch {
  console.log('Something failed');
}

// You can throw anything
try {
  throw 'a string error'; // valid but not recommended
  throw 42;               // also valid
  throw { code: 500 };    // better – but use Error objects for best practice
} catch (e) {
  console.log(typeof e, e);
}

try {
  null.property; // throws TypeError
} catch (error) {
  console.log(error.name);    // 'TypeError'
  console.log(error.message); // "Cannot read properties of null"
  console.log(error.stack);   // Stack trace (string with file + line info)
  console.log(error instanceof TypeError); // true
  console.log(error instanceof Error);     // true
}

// Creating Error objects explicitly
const err = new Error('Something went wrong');
console.log(err.name);    // 'Error'
console.log(err.message); // 'Something went wrong'
console.log(err.stack);   // Error: Something went wrong\n  at ...

// throw new Error is always preferred over throw 'string'
// because it includes a stack trace

// Custom error class
class ValidationError extends Error {
  constructor(message, field) {
    super(message);
    this.name = 'ValidationError';
    this.field = field;
  }
}

class NetworkError extends Error {
  constructor(message, statusCode) {
    super(message);
    this.name = 'NetworkError';
    this.statusCode = statusCode;
  }
}

// Using custom errors
function validateAge(age) {
  if (typeof age !== 'number') {
    throw new ValidationError('Age must be a number', 'age');
  }
  if (age < 0 || age > 150) {
    throw new ValidationError('Age must be between 0 and 150', 'age');
  }
  return age;
}

try {
  validateAge(-5);
} catch (error) {
  if (error instanceof ValidationError) {
    console.log(`Validation failed on field "${error.field}": ${error.message}`);
  } else {
    throw error; // re-throw unknown errors
  }
}
// Validation failed on field "age": Age must be between 0 and 150

// Only handle errors you understand — re-throw everything else
function processFile(data) {
  try {
    return JSON.parse(data);
  } catch (error) {
    if (error instanceof SyntaxError) {
      // We understand this — handle it gracefully
      console.warn('Invalid JSON, using empty object');
      return {};
    }
    // Unknown error — re-throw to propagate it up
    throw error;
  }
}

// Wrapping and re-throwing with context
async function loadUserProfile(userId) {
  try {
    const response = await fetch(`/api/users/${userId}`);
    if (!response.ok) {
      throw new NetworkError(`Failed to load user ${userId}`, response.status);
    }
    return await response.json();
  } catch (error) {
    if (error instanceof NetworkError) throw error; // already wrapped
    throw new NetworkError(`Unexpected error loading user: ${error.message}`, 0);
  }
}

// async/await – use try/catch exactly like synchronous code
async function fetchData(url) {
  try {
    const response = await fetch(url);
    if (!response.ok) {
      throw new NetworkError(`HTTP ${response.status}`, response.status);
    }
    const data = await response.json();
    return data;
  } catch (error) {
    if (error instanceof NetworkError) {
      console.error('Network error:', error.message);
      return null;
    }
    throw error;
  }
}

// Promise chain – use .catch()
fetch('/api/data')
  .then(res => res.json())
  .then(data => processData(data))
  .catch(error => {
    console.error('Pipeline failed:', error);
  })
  .finally(() => {
    hideLoadingSpinner();
  });

// Promise.allSettled – wait for all, even if some fail
const results = await Promise.allSettled([
  fetch('/api/users'),
  fetch('/api/products'),
  fetch('/api/orders')
]);

results.forEach((result, i) => {
  if (result.status === 'fulfilled') {
    console.log(`Request ${i} succeeded`);
  } else {
    console.error(`Request ${i} failed:`, result.reason);
  }
});

// Browser: catch uncaught synchronous errors
window.onerror = function(message, source, lineno, colno, error) {
  sendToErrorService({ message, source, lineno, error: error?.stack });
  return true; // prevents default browser error display
};

// Browser: catch unhandled promise rejections
window.addEventListener('unhandledrejection', event => {
  console.error('Unhandled promise rejection:', event.reason);
  sendToErrorService({ type: 'unhandledrejection', reason: event.reason });
  event.preventDefault(); // prevents console output in some environments
});

// Node.js equivalent
process.on('uncaughtException', (error) => {
  console.error('Uncaught exception:', error);
  // Clean up and exit — DO NOT continue running after uncaughtException
  process.exit(1);
});

process.on('unhandledRejection', (reason, promise) => {
  console.error('Unhandled rejection at:', promise, 'reason:', reason);
});

// Error logging best practice
function reportError(error, context = {}) {
  const report = {
    name: error.name,
    message: error.message,
    stack: error.stack,
    timestamp: new Date().toISOString(),
    url: window.location.href,
    ...context
  };
  // Send to Sentry, Datadog, etc.
  navigator.sendBeacon('/api/errors', JSON.stringify(report));
}