/*
 * Traditional defensive programming: The 'Null/Undefined Labyrinth'
 * This code demonstrates common scenarios before Optional Chaining and Nullish Coalescing,
 * highlighting the verbosity and potential for errors when accessing nested properties.
 */

// 1. Basic object structure with potential undefined properties
interface UserProfile {
  id: string;
  name: string;
  contact?: {
    email?: string;
    phone?: string;
  };
  settings?: {
    theme: string;
    notificationsEnabled?: boolean;
  };
  preferences?: string[];
}

// Example user data: some fields are missing or null
const user1: UserProfile = {
  id: 'user_001',
  name: 'Alice',
  contact: {},
  settings: { theme: 'dark' },
  preferences: ['marketing', 'updates']
};

const user2: UserProfile = {
  id: 'user_002',
  name: 'Bob',
  // contact and settings are completely missing
};

const user3: UserProfile = {
  id: 'user_003',
  name: 'Charlie',
  contact: { email: 'charlie@example.com', phone: null }, // Phone explicitly null
  settings: { theme: 'light', notificationsEnabled: false }
};

// --- Accessing deeply nested properties without ?. or ?? ---

// Scenario A: Accessing user1's email
let user1Email: string | undefined;
if (user1.contact && user1.contact.email) {
  user1Email = user1.contact.email;
} else {
  user1Email = 'N/A'; // Default value if not found
}
console.log(`User 1 Email: ${user1Email}`); // Expected: N/A

// Scenario B: Accessing user2's notifications enabled status
let user2NotificationsStatus: boolean | string;
if (user2.settings && typeof user2.settings.notificationsEnabled === 'boolean') {
  user2NotificationsStatus = user2.settings.notificationsEnabled;
} else {
  user2NotificationsStatus = 'Disabled by default';
}
console.log(`User 2 Notifications: ${user2NotificationsStatus}`); // Expected: Disabled by default

// Scenario C: Accessing user3's phone number
let user3PhoneNumber: string | null | undefined;
if (user3.contact && user3.contact.phone !== undefined) { // Check for undefined, not null for direct access
  user3PhoneNumber = user3.contact.phone;
} else {
  user3PhoneNumber = 'No phone provided';
}
// Note: This still needs refinement to distinguish between null and undefined for defaults
console.log(`User 3 Phone: ${user3PhoneNumber}`); // Expected: null (if default not applied correctly)

// Scenario D: Accessing an item from an array that might not exist
let firstPreferenceUser1: string | undefined;
if (user1.preferences && user1.preferences.length > 0) {
    firstPreferenceUser1 = user1.preferences[0];
}
console.log(`User 1 First Preference: ${firstPreferenceUser1}`); // Expected: marketing

let firstPreferenceUser2: string | undefined;
if (user2.preferences && user2.preferences.length > 0) {
    firstPreferenceUser2 = user2.preferences[0];
} else {
    firstPreferenceUser2 = 'No preferences';
}
console.log(`User 2 First Preference: ${firstPreferenceUser2}`); // Expected: No preferences


/*
 * Observe the redundancy and repetition in these checks.
 * Each level of potential null/undefined requires a new conditional, inflating code size
 * and obscuring the core logic. This is the challenge Optional Chaining and Nullish Coalescing address.
 */

/*
 * Activate Optional Chaining (?.) for concise, type-safe property access.
 * This code demonstrates how ?. streamlines the process of accessing nested properties,
 * array elements, and methods that might be null or undefined at intermediate levels.
 */

// 1. Reuse the UserProfile interface for consistency
interface UserProfile {
  id: string;
  name: string;
  contact?: {
    email?: string;
    phone?: string | null; // Added null explicitly for demonstration
  };
  settings?: {
    theme: string;
    notificationsEnabled?: boolean;
    getPreference?: () => string;
  };
  preferences?: string[];
}

// Example user data with varying levels of completeness
const userA: UserProfile = {
  id: 'usrA',
  name: 'Alice',
  contact: { email: 'alice@example.com' },
  settings: { theme: 'dark', getPreference: () => 'dark mode' },
  preferences: ['tech', 'news']
};

const userB: UserProfile = {
  id: 'usrB',
  name: 'Bob',
  // contact and settings are missing entirely
};

const userC: UserProfile = {
  id: 'usrC',
  name: 'Charlie',
  contact: { phone: '555-1234' }, // Email is missing
  settings: { theme: 'light', notificationsEnabled: false },
  preferences: [] // Empty array
};

const userD: UserProfile = {
  id: 'usrD',
  name: 'David',
  contact: { phone: null } // Phone is explicitly null
};

// --- Applying Optional Chaining (?. )---

// Scenario A: Accessing email with ?.
// If 'contact' is undefined or null, or 'email' is undefined, userAEmaill will be undefined.
const userAEmail = userA.contact?.email;
console.log(`User A Email: ${userAEmail}`); // Expected: alice@example.com

const userBEmail = userB.contact?.email;
console.log(`User B Email: ${userBEmail}`); // Expected: undefined

// Scenario B: Accessing notifications enabled status with ?.
// This is specifically for accessing a property that might not exist.
const userBNotifications = userB.settings?.notificationsEnabled;
console.log(`User B Notifications Status: ${userBNotifications}`); // Expected: undefined

const userCNotifications = userC.settings?.notificationsEnabled;
console.log(`User C Notifications Status: ${userCNotifications}`); // Expected: false (exists and is boolean)

// Scenario C: Accessing a method with ?.
// If 'settings' or 'getPreference' is undefined/null, the call is skipped, and result is undefined.
const userAPreference = userA.settings?.getPreference?.();
console.log(`User A Preference: ${userAPreference}`); // Expected: dark mode

const userBPref = userB.settings?.getPreference?.();
console.log(`User B Preference: ${userBPref}`); // Expected: undefined

// Scenario D: Accessing array elements with ?.
// Accesses the first element if 'preferences' exists and is not empty.
const userAFirstPref = userA.preferences?.[0];
console.log(`User A First Preference: ${userAFirstPref}`); // Expected: tech

const userCFirstPref = userC.preferences?.[0];
console.log(`User C First Preference: ${userCFirstPref}`); // Expected: undefined (empty array, so [0] is undefined)

const userBFirstPref = userB.preferences?.[0];
console.log(`User B First Preference: ${userBFirstPref}`); // Expected: undefined

// Scenario E: Handling null vs undefined with ?.
// Optional chaining stops at null as well, yielding undefined.
const userDPhone = userD.contact?.phone;
console.log(`User D Phone: ${userDPhone}`); // Expected: null (?. returned the explicit null value)

const userDPhoneValue = userD.contact?.phone !== undefined ? userD.contact?.phone : 'No phone';
console.log(`User D Phone (with traditional check for default): ${userDPhoneValue}`); // Still complex, points to need for ??

/*
 * Key takeaway: Optional Chaining dramatically reduces boilerplate, returning 'undefined'
 * if any part of the chain (property, method, or array index) is null or undefined.
 * It preserves TypeScript's type inference, indicating the result is 'T | undefined'.
 */

/*
 * Harness Nullish Coalescing (??) for precise default value assignment.
 * This code illustrates the key distinction between ?? and ||, emphasizing
 * how ?? respects falsy values like 0, '', and false as legitimate.
 */

// 1. Define a configuration interface with various data types
interface AppConfig {
  port?: number;             // Could be 0 (valid) or undefined
  host?: string;             // Could be '' (valid) or undefined
  enableTelemetry?: boolean; // Could be false (valid) or undefined
  apiTimeout?: number | null; // Could be null (valid) or undefined
}

// Example configurations with missing or falsy values
const config1: AppConfig = {
  port: 0,
  host: '',
  enableTelemetry: false,
  apiTimeout: 5000
};

const config2: AppConfig = {
  // All properties are undefined
};

const config3: AppConfig = {
  port: 8080,
  host: 'localhost',
  apiTimeout: null // Explicitly null
};

// --- Comparing Nullish Coalescing (??) vs. Logical OR (||) ---

console.log('--- Port Configuration ---');
// Using ||: Treats 0 as falsy, assigns default
const portOr = config1.port || 3000;
console.log(`Config 1 Port (using ||): ${portOr}`); // Expected: 3000 (Incorrect, 0 is a valid port)

// Using ??: Treats 0 as valid, assigns it
const portNullish = config1.port ?? 3000;
console.log(`Config 1 Port (using ??): ${portNullish}`); // Expected: 0 (Correct)

const portUndefined = config2.port ?? 3000;
console.log(`Config 2 Port (using ??): ${portUndefined}`); // Expected: 3000

console.log('\n--- Host Configuration ---');
// Using ||: Treats '' as falsy, assigns default
const hostOr = config1.host || '127.0.0.1';
console.log(`Config 1 Host (using ||): ${hostOr}`); // Expected: 127.0.0.1 (Incorrect, '' is a valid host value for some contexts)

// Using ??: Treats '' as valid, assigns it
const hostNullish = config1.host ?? '127.0.0.1';
console.log(`Config 1 Host (using ??): ${hostNullish}`); // Expected: '' (Correct)

const hostUndefined = config2.host ?? '127.0.0.1';
console.log(`Config 2 Host (using ??): ${hostUndefined}`); // Expected: 127.0.0.1

console.log('\n--- Telemetry Configuration ---');
// Using ||: Treats false as falsy, assigns default
const telemetryOr = config1.enableTelemetry || true;
console.log(`Config 1 Telemetry (using ||): ${telemetryOr}`); // Expected: true (Incorrect, false is a valid setting)

// Using ??: Treats false as valid, assigns it
const telemetryNullish = config1.enableTelemetry ?? true;
console.log(`Config 1 Telemetry (using ??): ${telemetryNullish}`); // Expected: false (Correct)

const telemetryUndefined = config2.enableTelemetry ?? true;
console.log(`Config 2 Telemetry (using ??): ${telemetryUndefined}`); // Expected: true

console.log('\n--- API Timeout Configuration (with null) ---');
// Using ||: Treats null as falsy, assigns default
const timeoutOr = config3.apiTimeout || 10000;
console.log(`Config 3 API Timeout (using ||): ${timeoutOr}`); // Expected: 10000 (Incorrect, null might indicate no timeout)

// Using ??: Treats null as 'nullish', assigns default
const timeoutNullish = config3.apiTimeout ?? 10000;
console.log(`Config 3 API Timeout (using ??): ${timeoutNullish}`); // Expected: 10000

// What if null itself is the desired default when undefined? (Less common, but possible)
const timeoutNullAsDefault = config2.apiTimeout ?? null;
console.log(`Config 2 API Timeout (defaulting to null): ${timeoutNullAsDefault}`); // Expected: null

/*
 * The examples clearly demonstrate that ?? provides superior control over default values,
 * preventing unintended assignments when actual falsy values (0, '', false) are meaningful.
 */

/*
 * Engineer Synergies: Combining ?. and ?? for Ultimate Clarity.
 * This code demonstrates how Optional Chaining and Nullish Coalescing
 * work together seamlessly to provide clean, robust, and type-safe data access,
 * especially in complex, deeply nested structures.
 */

// 1. Comprehensive data structure for a user's order history and preferences
interface OrderItem {
  productId: string;
  quantity: number;
  price: number;
}

interface Order {
  orderId: string;
  items?: OrderItem[];
  totalAmount: number;
  shippingAddress?: {
    street: string;
    city: string;
    zipCode?: string | null; // Can be null or undefined
  };
  status?: 'pending' | 'shipped' | 'delivered';
  deliveryInstructions?: string;
}

interface UserSettings {
  emailNotifications?: boolean;
  smsNotifications?: boolean | null;
  theme?: 'dark' | 'light' | 'system';
  itemsPerPage?: number; // Can be 0 (valid) or undefined
}

interface UserProfileWithOrders {
  userId: string;
  username: string;
  orders?: Order[];
  settings?: UserSettings;
  lastLoginIp?: string;
  isActive: boolean;
}

// Example user profiles with various data completeness
const userWithData: UserProfileWithOrders = {
  userId: 'u101',
  username: 'Alice Smith',
  orders: [
    {
      orderId: 'ORD001',
      items: [
        { productId: 'P001', quantity: 2, price: 10.50 },
        { productId: 'P002', quantity: 1, price: 25.00 }
      ],
      totalAmount: 46.00,
      shippingAddress: { street: '123 Main St', city: 'Metropolis', zipCode: '10001' },
      status: 'shipped'
    },
    {
      orderId: 'ORD002',
      totalAmount: 50.00, // Items missing, but total present
      shippingAddress: { street: '456 Elm St', city: 'Gotham', zipCode: null }, // Zip code null
      status: 'pending'
    }
  ],
  settings: {
    emailNotifications: true,
    smsNotifications: false, // Explicitly false (valid)
    theme: 'dark',
    itemsPerPage: 10
  },
  isActive: true
};

const userNoOrders: UserProfileWithOrders = {
  userId: 'u102',
  username: 'Bob Johnson',
  settings: {
    theme: 'system',
    itemsPerPage: 0 // Explicitly 0 (valid)
  },
  isActive: true
};

const userMinimal: UserProfileWithOrders = {
  userId: 'u103',
  username: 'Charlie Brown',
  isActive: false
};

// --- Combining ?. and ?? for robust data access ---

console.log('--- Order Details ---');
// Get first order's status, or 'No Orders' if orders array is missing/empty
const firstOrderStatus = userWithData.orders?.[0]?.status ?? 'No Orders';
console.log(`User With Data - First Order Status: ${firstOrderStatus}`); // Expected: shipped

const noOrdersStatus = userNoOrders.orders?.[0]?.status ?? 'No Orders';
console.log(`User No Orders - First Order Status: ${noOrdersStatus}`); // Expected: No Orders

// Get the zip code of the second order, defaulting to 'N/A' if missing or null
const secondOrderZip = userWithData.orders?.[1]?.shippingAddress?.zipCode ?? 'N/A';
console.log(`User With Data - Second Order Zip: ${secondOrderZip}`); // Expected: N/A (because zipCode is null)

const minimalOrderZip = userMinimal.orders?.[0]?.shippingAddress?.zipCode ?? 'N/A';
console.log(`User Minimal - Order Zip: ${minimalOrderZip}`); // Expected: N/A

console.log('\n--- User Settings ---');
// Get email notification preference, default to false if undefined
const userEmailNotifs = userWithData.settings?.emailNotifications ?? false;
console.log(`User With Data - Email Notifications: ${userEmailNotifs}`); // Expected: true

const userMinimalEmailNotifs = userMinimal.settings?.emailNotifications ?? false;
console.log(`User Minimal - Email Notifications: ${userMinimalEmailNotifs}`); // Expected: false

// Get SMS notification preference, defaulting to true if null/undefined
const userSmsNotifs = userWithData.settings?.smsNotifications ?? true; // false is a valid value, so ?? returns false
console.log(`User With Data - SMS Notifications: ${userSmsNotifs}`); // Expected: false

// Get items per page setting, defaulting to 20 if undefined (but allows 0)
const itemsPerPage = userNoOrders.settings?.itemsPerPage ?? 20;
console.log(`User No Orders - Items Per Page: ${itemsPerPage}`); // Expected: 0

const minimalItemsPerPage = userMinimal.settings?.itemsPerPage ?? 20;
console.log(`User Minimal - Items Per Page: ${minimalItemsPerPage}`); // Expected: 20

console.log('\n--- Fallback Scenarios ---');
// Get first item's product ID from the first order, defaulting to a specific value
const firstItemProductId = userWithData.orders?.[0]?.items?.[0]?.productId ?? 'NO_PRODUCT_ID';
console.log(`User With Data - First Item Product ID: ${firstItemProductId}`); // Expected: P001

const noItemsProductId = userWithData.orders?.[1]?.items?.[0]?.productId ?? 'NO_PRODUCT_ID';
console.log(`User With Data (no items in second order) - First Item Product ID: ${noItemsProductId}`); // Expected: NO_PRODUCT_ID

const minimalUserProductId = userMinimal.orders?.[0]?.items?.[0]?.productId ?? 'NO_PRODUCT_ID';
console.log(`User Minimal - First Item Product ID: ${minimalUserProductId}`); // Expected: NO_PRODUCT_ID

/*
 * These examples demonstrate the immense power of combining ?. and ??.
 * The ?. handles the uncertainty of intermediate properties, while ?? provides a robust default
 * only when the final result of the optional chain is explicitly null or undefined,
 * preventing unintended assignments for valid falsy values.
 */

/*
 * Optimize Development: Best Practices, Pitfalls, and TypeScript Integration.
 * This section provides code examples for common mistakes and best practices
 * when using Optional Chaining and Nullish Coalescing in TypeScript.
 */

// 1. Example interfaces for demonstration
interface Product {
  id: string;
  name: string;
  price: number;
  category?: string;
  inventory?: {
    stock: number;
    warehouse?: string;
  };
}

interface CartItem {
  product: Product;
  quantity: number;
}

interface ShoppingCart {
  id: string;
  items: CartItem[];
  customerInfo?: {
    email: string;
    phone?: string | null;
  };
  discountCode?: string;
}

// Example data
const validProduct: Product = {
  id: 'prod123',
  name: 'Laptop',
  price: 1200,
  inventory: { stock: 50, warehouse: 'East' }
};

const productNoInventory: Product = {
  id: 'prod124',
  name: 'Mouse',
  price: 25
};

const cartWithItems: ShoppingCart = {
  id: 'cart001',
  items: [
    { product: validProduct, quantity: 1 },
    { product: productNoInventory, quantity: 2 }
  ],
  customerInfo: { email: 'customer@example.com' },
  discountCode: '' // Empty string is a valid discount code state
};

const emptyCart: ShoppingCart = {
  id: 'cart002',
  items: []
};

const cartNoCustomer: ShoppingCart = {
  id: 'cart003',
  items: [
    { product: validProduct, quantity: 1 }
  ]
};

// --- Pitfall 1: Overuse of ?. for mandatory properties ---
// This is generally discouraged. If 'id' must exist, an error should be thrown earlier.
// const productId = productNoInventory?.id; // Bad practice if ID is truly mandatory.

// Correct approach: Assert non-null or handle as error if truly mandatory.
function getMandatoryProductId(product: Product): string {
  if (!product.id) {
    throw new Error('Product ID is mandatory.');
  }
  return product.id;
}
console.log(`Mandatory Product ID: ${getMandatoryProductId(validProduct)}`);
// console.log(getMandatoryProductId({ name: 'Invalid', price: 10 })); // Would throw error as expected

// --- Pitfall 2: Confusing ?? with || for falsy values ---
// Already covered extensively, but a reminder:
const discountCodeValue = cartWithItems.discountCode || 'NONE_APPLIED';
console.log(`Discount Code (using ||): ${discountCodeValue}`); // Expected: NONE_APPLIED (incorrect if '' is valid)

const discountCodePrecise = cartWithItems.discountCode ?? 'NONE_APPLIED';
console.log(`Discount Code (using ??): ${discountCodePrecise}`); // Expected: '' (correct)

// --- Best Practice 1: Clear type inference with ?. ---
// TypeScript correctly infers `string | undefined`
const firstItemWarehouse: string | undefined = cartWithItems.items?.[0]?.product?.inventory?.warehouse;
console.log(`First Item Warehouse: ${firstItemWarehouse}`); // Expected: East

const secondItemWarehouse: string | undefined = cartWithItems.items?.[1]?.product?.inventory?.warehouse;
console.log(`Second Item Warehouse: ${secondItemWarehouse}`); // Expected: undefined

// --- Best Practice 2: Chaining ?. and ?? for a definitive default ---
const customerPhone = cartNoCustomer.customerInfo?.phone ?? 'No Phone Provided';
console.log(`Customer Phone: ${customerPhone}`); // Expected: No Phone Provided

const customerEmail = cartNoCustomer.customerInfo?.email ?? 'No Email Provided';
console.log(`Customer Email: ${customerEmail}`); // Expected: No Email Provided (customerInfo is undefined)

// What if phone is explicitly null?
const phoneFromValidCustomer: string | null | undefined = cartWithItems.customerInfo?.phone;
console.log(`Phone from valid customer (can be null): ${phoneFromValidCustomer}`); // Expected: undefined

const phoneWithNullDefault = cartWithItems.customerInfo?.phone ?? 'No Phone Available';
console.log(`Phone with null-aware default: ${phoneWithNullDefault}`); // Expected: No Phone Available

// --- Best Practice 3: Using strictNullChecks ---
// Ensure your tsconfig.json has "strictNullChecks": true
// This will make optional properties truly optional and force handling of undefined/null.
// Example: Without strictNullChecks, `customerInfo?.email` might just be `string`,
// but with it, it's `string | undefined`, forcing you to handle the `undefined` case.

/*
 * Adhering to these best practices and understanding common pitfalls will ensure
 * that ?. and ?? are used effectively, leading to robust and maintainable TypeScript code.
 */