/*
  Union Types: Combining diverse data forms into a single, cohesive type.
  We leverage the '|' operator to declare that a variable or parameter can hold
  any one of the specified types. This is crucial for functions that accept
  multiple input shapes or for data structures that evolve based on context.
*/

// Scenario 1: Function accepting multiple input types
type ID = number | string;

function identifyUser(id: ID): void {
  // Type Narrowing: Decisively determine the exact type at runtime
  if (typeof id === 'string') {
    console.log(`User ID is a string: ${id.toUpperCase()}`);
  } else {
    console.log(`User ID is a number: ${id.toFixed(0)}`);
  }
}

identifyUser(12345);
identifyUser("USR-XYZ-789");

// Scenario 2: Modeling state with distinct possibilities
type LoadingState = { status: 'loading' };
type SuccessState = { status: 'success'; data: any };
type ErrorState = { status: 'error'; message: string };

type DataState = LoadingState | SuccessState | ErrorState;

function renderDataState(state: DataState): void {
  // Discriminated Union: A powerful pattern for type narrowing complex unions.
  // The 'status' property acts as a discriminant.
  switch (state.status) {
    case 'loading':
      console.log("Fetching data...");
      break;
    case 'success':
      console.log(`Data loaded: ${JSON.stringify(state.data)}`);
      break;
    case 'error':
      console.error(`Error: ${state.message}`);
      break;
    default:
      // Ensure exhaustive checking for robustness
      const _exhaustiveCheck: never = state;
      return _exhaustiveCheck;
  }
}

renderDataState({ status: 'loading' });
renderDataState({ status: 'success', data: { name: "Project X" } });
renderDataState({ status: 'error', message: "Network connection lost" });

// Scenario 3: Conditional function parameters or return types (conceptual)
// This often involves function overloads or more advanced conditional types,
// but the underlying principle starts with union types for flexibility.

interface Square { kind: "square"; size: number; }
interface Circle { kind: "circle"; radius: number; }

type Shape = Square | Circle;

function getArea(shape: Shape): number {
  if (shape.kind === "square") {
    return shape.size * shape.size;
  } else {
    return Math.PI * shape.radius * shape.radius;
  }
}

console.log(`Area of square (size 5): ${getArea({ kind: "square", size: 5 })}`);
console.log(`Area of circle (radius 3): ${getArea({ kind: "circle", radius: 3 })}`);

/*
  Intersection Types: Merging multiple types into a single, super-type.
  We employ the '&' operator to combine the properties of two or more types
  into a new type that possesses *all* properties from its constituents.
  This is fundamental for composition over inheritance, creating rich entity models.
*/

// Scenario 1: Combining base interfaces to create a comprehensive entity
interface HasName {
  name: string;
}

interface HasEmail {
  email: string;
}

interface HasPhone {
  phone: string;
}

// A User must have ALL of these properties
type UserProfile = HasName & HasEmail & HasPhone;

const adminUser: UserProfile = {
  name: "Alice Smith",
  email: "alice@example.com",
  phone: "123-456-7890"
};

console.log(`Admin User: ${adminUser.name}, ${adminUser.email}, ${adminUser.phone}`);

// Scenario 2: Adding specific capabilities or roles to existing types
interface Employee {
  id: string;
  startDate: Date;
}

interface Manager extends Employee {
  manageTeam(teamId: string): void;
}

// A SeniorManager is an Employee AND has Manager-like responsibilities
type SeniorManager = Employee & { department: string; level: number };

const bob: SeniorManager = {
  id: "EMP001",
  startDate: new Date(),
  department: "Engineering",
  level: 5
};

console.log(`Bob's Department: ${bob.department}, Level: ${bob.level}`);

// Scenario 3: Merging configuration objects or options
interface BaseConfig {
  timeout: number;
  retries: number;
}

interface DatabaseConfig {
  connectionString: string;
  poolSize: number;
}

interface APIConfig {
  baseUrl: string;
  apiKey: string;
}

type AppConfig = BaseConfig & DatabaseConfig & APIConfig;

const appSettings: AppConfig = {
  timeout: 5000,
  retries: 3,
  connectionString: "mongodb://localhost:27017/appdb",
  poolSize: 10,
  baseUrl: "https://api.example.com",
  apiKey: "secret123"
};

console.log(`App Config Timeout: ${appSettings.timeout}, API Base URL: ${appSettings.baseUrl}`);

// Pitfall: Conflicting properties with different non-union types result in 'never'
interface A { x: string; }
interface B { x: number; }

// type C = A & B; // C will have 'x: never' - essentially an impossible type
// const impossible: C = { x: "hello" }; // Error: Type 'string' is not assignable to type 'never'.

// This illustrates why careful composition is key. TypeScript enforces strict compatibility.

/*
  Strategic Fusion: Combining Union and Intersection types for sophisticated logic.
  This segment explores advanced patterns like Discriminated Unions with shared properties,
  modeling complex event systems, and dynamic configuration objects.
  We demonstrate how these operators synergize to create highly expressive and safe types.
*/

// Scenario 1: Event System with common base and specific payloads
interface BaseEvent {
  timestamp: Date;
  userId: string;
}

interface UserLoggedInEvent extends BaseEvent {
  type: 'UserLoggedIn';
  loginMethod: 'oauth' | 'password';
}

interface ProductAddedToCartEvent extends BaseEvent {
  type: 'ProductAddedToCart';
  productId: string;
  quantity: number;
}

// An ApplicationEvent is one of these specific events, all sharing BaseEvent properties
type ApplicationEvent = UserLoggedInEvent | ProductAddedToCartEvent;

function processEvent(event: ApplicationEvent): void {
  console.log(`Processing event of type '${event.type}' at ${event.timestamp.toISOString()} by user ${event.userId}`);

  // Leveraging the discriminant 'type' for narrowing
  if (event.type === 'UserLoggedIn') {
    console.log(`  Login method: ${event.loginMethod}`);
  } else if (event.type === 'ProductAddedToCart') {
    console.log(`  Added product ${event.productId}, quantity ${event.quantity}`);
  }
}

processEvent({
  type: 'UserLoggedIn',
  timestamp: new Date(),
  userId: 'USR-001',
  loginMethod: 'password'
});

processEvent({
  type: 'ProductAddedToCart',
  timestamp: new Date(),
  userId: 'USR-002',
  productId: 'PRD-ABC',
  quantity: 2
});

// Scenario 2: Dynamic configuration based on context
// We need a base config and then context-specific overrides/additions.

interface DefaultSettings {
  debugMode: boolean;
  logLevel: 'info' | 'warn' | 'error';
}

interface DevelopmentEnvironmentConfig {
  environment: 'development';
  hotReload: boolean;
}

interface ProductionEnvironmentConfig {
  environment: 'production';
  cdnUrl: string;
  minification: boolean;
}

// A configuration for a specific environment
type EnvConfig = DefaultSettings & (DevelopmentEnvironmentConfig | ProductionEnvironmentConfig);

const devConfig: EnvConfig = {
  debugMode: true,
  logLevel: 'info',
  environment: 'development',
  hotReload: true
};

const prodConfig: EnvConfig = {
  debugMode: false,
  logLevel: 'error',
  environment: 'production',
  cdnUrl: 'https://cdn.example.com',
  minification: true
};

console.log(`Dev Config Debug Mode: ${devConfig.debugMode}, Hot Reload: ${devConfig.hotReload}`);
console.log(`Prod Config CDN URL: ${prodConfig.cdnUrl}, Minification: ${prodConfig.minification}`);

// Scenario 3: Representing API Responses that can be success or error, each with different structures
interface SuccessResponse<T> {
  status: 'success';
  data: T;
}

interface ErrorResponse {
  status: 'error';
  message: string;
  errorCode?: number;
}

type APIResult<T> = SuccessResponse<T> | ErrorResponse;

async function fetchData<T>(url: string): Promise<APIResult<T>> {
  try {
    const response = await fetch(url);
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    const data = await response.json();
    return { status: 'success', data: data as T };
  } catch (error: any) {
    return { status: 'error', message: error.message };
  }
}

// Example usage (assuming 'User' type is defined elsewhere)
interface User {
    id: number;
    name: string;
}

// Mocking a successful API call
const mockSuccessResponse: APIResult<User> = {
    status: 'success',
    data: { id: 1, name: 'John Doe' }
};

// Mocking an error API call
const mockErrorResponse: APIResult<User> = {
    status: 'error',
    message: 'Failed to fetch user data',
    errorCode: 500
};

function handleUserResult(result: APIResult<User>) {
    if (result.status === 'success') {
        console.log(`User data received: ${result.data.name}`);
    } else {
        console.error(`API Error: ${result.message}`);
    }
}

handleUserResult(mockSuccessResponse);
handleUserResult(mockErrorResponse);

/*
  Optimizing Type Systems: Best practices for using Union and Intersection types.
  We cover strategies to maintain readability, prevent common pitfalls, and ensure
  that our type architectures remain scalable and understandable over time.
*/

// Best Practice 1: Name complex types clearly
// Avoid inline types for anything non-trivial.

type UserLoginAttempt = { username: string } & ({ type: 'success' } | { type: 'failure'; error: string });

const successfulAttempt: UserLoginAttempt = { username: 'john.doe', type: 'success' };
const failedAttempt: UserLoginAttempt = { username: 'john.doe', type: 'failure', error: 'Invalid credentials' };

// Bad: Difficult to read and reuse
// const someVar: { data: string } | ({ loading: boolean } & { error?: string }) = { data: "abc" };

// Good: Clear intent, reusable
interface LoadingDataState { loading: boolean; error?: string; }
interface LoadedDataState { data: string; }
type AppDataState = LoadingDataState | LoadedDataState;

// Best Practice 2: Leverage type guards for exhaustive checking and narrowing

function handleAppState(state: AppDataState): void {
  if ('loading' in state) {
    console.log(`Loading state: ${state.loading}, Error: ${state.error ?? 'None'}`);
  } else {
    console.log(`Loaded state: ${state.data}`);
  }
}

handleAppState({ loading: true });
handleAppState({ data: "Hello World" });

// Pitfall 1: Over-engineering types, making them too abstract or nested.
// Keep types as simple as possible to express the domain logic.

// Pitfall 2: Conflicting properties in intersections (results in 'never')
// interface Foo { value: string; }
// interface Bar { value: number; }
// type FooBar = Foo & Bar; // 'value: never' - impossible type. TypeScript will catch this.

// Best Practice 3: Document complex type relationships
/**
 * Represents a configurable Widget component.
 * Combines base widget properties with optional theme-specific overrides.
 */
interface BaseWidgetProps {
  id: string;
  title: string;
}

interface DarkThemeProps {
  theme: 'dark';
  backgroundColor: string;
  textColor: string;
}

interface LightThemeProps {
  theme: 'light';
  primaryColor: string;
  accentColor: string;
}

type ThemedWidgetProps = BaseWidgetProps & (DarkThemeProps | LightThemeProps);

function renderWidget(props: ThemedWidgetProps) {
  console.log(`Rendering Widget: ${props.title} (ID: ${props.id})`);
  if (props.theme === 'dark') {
    console.log(`  Dark Theme: BG=${props.backgroundColor}, Text=${props.textColor}`);
  } else {
    console.log(`  Light Theme: Primary=${props.primaryColor}, Accent=${props.accentColor}`);
  }
}

renderWidget({
  id: 'widget-1',
  title: 'Dashboard Stats',
  theme: 'dark',
  backgroundColor: '#333',
  textColor: '#FFF'
});

renderWidget({
  id: 'widget-2',
  title: 'User Profile',
  theme: 'light',
  primaryColor: '#007bff',
  accentColor: '#6c757d'
});

// Best Practice 4: Use 'never' for exhaustive checking in switch statements
// (As shown in 'renderDataState' in the Union Types section) - this ensures no branch is missed.

// Pitfall 3: Not using type guards in unions, leading to runtime errors.
// function processThing(t: string | number) { console.log(t.toUpperCase()); } // Error if t is number

// Correct approach:
function processThing(t: string | number) {
  if (typeof t === 'string') {
    console.log(t.toUpperCase());
  } else {
    console.log(t.toFixed(2));
  }
}