/*
 * Step 1: Define the core types that represent different states or events.
 * We start with a common 'discriminant' property, 'kind' or 'type',
 * to differentiate between the members of the union.
 */

// 1. Define base types for different UI states
interface LoadingState {
  kind: 'loading';
  message: string;
}

interface SuccessState {
  kind: 'success';
  data: string[];
}

interface ErrorState {
  kind: 'error';
  errorCode: number;
  errorMessage: string;
}

// 2. Create the Discriminated Union type
// This union explicitly declares all possible states an entity can be in.
type AppState = LoadingState | SuccessState | ErrorState;

// 3. Demonstrate usage with a function that processes different states
function processAppState(state: AppState): string {
  // TypeScript's control flow analysis 'narrows' the type
  // based on the 'kind' property.
  switch (state.kind) {
    case 'loading':
      return `Loading data: ${state.message}`;
    case 'success':
      return `Data loaded: ${state.data.length} items. First item: ${state.data[0]}`;
    case 'error':
      return `Error ${state.errorCode}: ${state.errorMessage}`;
    default:
      // This 'default' case should ideally be unreachable if all cases are handled
      // and the union is exhaustive. TypeScript helps enforce this.
      const _exhaustiveCheck: never = state;
      return _exhaustiveCheck; // Ensures all union members are handled
  }
}

// 4. Create instances of each state for testing
const loading: AppState = { kind: 'loading', message: 'Fetching user data...' };
const success: AppState = { kind: 'success', data: ['Alice', 'Bob', 'Charlie'] };
const error: AppState = { kind: 'error', errorCode: 500, errorMessage: 'Failed to fetch user data.' };

// 5. Log the results to confirm correct processing
console.log(processAppState(loading));
console.log(processAppState(success));
console.log(processAppState(error));

/*
 * Expected Output:
 * Loading data: Fetching user data...
 * Data loaded: 3 items. First item: Alice
 * Error 500: Failed to fetch user data.
 */

/*
 * Step 2: Build a more complex state machine for an asynchronous data fetching operation.
 * This demonstrates state transitions and exhaustive checking.
 */

// 1. Define states for a data fetching process
interface InitialState {
  kind: 'initial';
}

interface FetchingState {
  kind: 'fetching';
  requestId: string;
}

interface SuccessFetchedState<T> {
  kind: 'success';
  data: T;
  timestamp: number;
}

interface ErrorFetchedState {
  kind: 'error';
  error: string;
  retryCount: number;
}

// 2. Create the Discriminated Union for our async operation's state
type AsyncDataState<T> = InitialState | FetchingState | SuccessFetchedState<T> | ErrorFetchedState;

// 3. Implement a reducer-like function to handle state transitions
// This function takes the current state and an action, returning a new state.
function transitionState<T>(currentState: AsyncDataState<T>, action: any): AsyncDataState<T> {
  // For simplicity, action types are 'any' here, but in a real app, they'd be
  // their own discriminated union for full type safety.
  // This example focuses on how the state itself is handled.
  switch (currentState.kind) {
    case 'initial':
      if (action.type === 'START_FETCH') {
        return { kind: 'fetching', requestId: action.requestId };
      }
      return currentState;

    case 'fetching':
      if (action.type === 'FETCH_SUCCESS') {
        return { kind: 'success', data: action.payload, timestamp: Date.now() };
      }
      if (action.type === 'FETCH_ERROR') {
        return { kind: 'error', error: action.error, retryCount: 0 }; // Initial retry count
      }
      return currentState;

    case 'success':
      // No direct transitions from success in this simple FSM, or maybe a 'REFRESH' action
      return currentState;

    case 'error':
      if (action.type === 'RETRY_FETCH') {
        return { kind: 'fetching', requestId: `retry-${currentState.retryCount + 1}` };
      }
      // Acknowledge error and move back to initial or reset
      if (action.type === 'ACKNOWLEDGE_ERROR') {
        return { kind: 'initial' };
      }
      return currentState;

    default:
      // TypeScript ensures exhaustive checking. If a new state is added to AsyncDataState<T>
      // and not handled here, it will trigger a compile-time error.
      const _exhaustiveCheck: never = currentState;
      return _exhaustiveCheck; // Catches unhandled states
  }
}

// 4. Simulate a data fetching flow
let dataState: AsyncDataState<string[]> = { kind: 'initial' };
console.log(`Current state: ${dataState.kind}`); // Output: Current state: initial

dataState = transitionState(dataState, { type: 'START_FETCH', requestId: 'req-123' });
console.log(`Current state: ${dataState.kind}`); // Output: Current state: fetching

dataState = transitionState(dataState, { type: 'FETCH_SUCCESS', payload: ['Item A', 'Item B'] });
console.log(`Current state: ${dataState.kind}. Data length: ${(dataState as SuccessFetchedState<string[]>).data.length}`);
// Output: Current state: success. Data length: 2

dataState = transitionState(dataState, { type: 'START_FETCH', requestId: 'req-124' }); // Should not change state from success
console.log(`Current state after invalid transition: ${dataState.kind}`); // Output: Current state after invalid transition: success

dataState = { kind: 'fetching', requestId: 'req-456' }; // Manually setting state to simulate an error during fetch
dataState = transitionState(dataState, { type: 'FETCH_ERROR', error: 'Network issue', retryCount: 0 });
console.log(`Current state: ${dataState.kind}. Error: ${(dataState as ErrorFetchedState).error}`);
// Output: Current state: error. Error: Network issue

dataState = transitionState(dataState, { type: 'RETRY_FETCH' });
console.log(`Current state: ${dataState.kind}. Request ID: ${(dataState as FetchingState).requestId}`);
// Output: Current state: fetching. Request ID: retry-1

/*
 * Step 3: Integrate Discriminated Unions into a reducer pattern, common in React's useReducer
 * or Redux-like architectures. This demonstrates type-safe action handling.
 */

// 1. Define states for a counter application (simple example)
interface CounterState {
  count: number;
}

// 2. Define actions as a Discriminated Union
interface IncrementAction {
  type: 'INCREMENT';
  payload?: number; // Optional payload for increment by a specific value
}

interface DecrementAction {
  type: 'DECREMENT';
  payload?: number;
}

interface ResetAction {
  type: 'RESET';
}

// Union of all possible actions
type CounterAction = IncrementAction | DecrementAction | ResetAction;

// 3. Implement a reducer function that processes actions and returns new state
function counterReducer(state: CounterState, action: CounterAction): CounterState {
  switch (action.type) {
    case 'INCREMENT':
      // TypeScript knows 'action' is IncrementAction here
      return { ...state, count: state.count + (action.payload || 1) };
    case 'DECREMENT':
      // TypeScript knows 'action' is DecrementAction here
      return { ...state, count: state.count - (action.payload || 1) };
    case 'RESET':
      // TypeScript knows 'action' is ResetAction here
      return { ...state, count: 0 };
    default:
      // Ensure exhaustive checking for all action types
      const _exhaustiveCheck: never = action;
      return _exhaustiveCheck; // This line should ideally not be reached if all actions are handled
  }
}

// 4. Initialize state and simulate dispatching actions
let currentCounterState: CounterState = { count: 0 };
console.log(`Initial count: ${currentCounterState.count}`); // Output: Initial count: 0

currentCounterState = counterReducer(currentCounterState, { type: 'INCREMENT' });
console.log(`After increment: ${currentCounterState.count}`); // Output: After increment: 1

currentCounterState = counterReducer(currentCounterState, { type: 'INCREMENT', payload: 5 });
console.log(`After increment by 5: ${currentCounterState.count}`); // Output: After increment by 6

currentCounterState = counterReducer(currentCounterState, { type: 'DECREMENT' });
console.log(`After decrement: ${currentCounterState.count}`); // Output: After decrement: 5

currentCounterState = counterReducer(currentCounterState, { type: 'RESET' });
console.log(`After reset: ${currentCounterState.count}`); // Output: After reset: 0

// Type error if trying to dispatch an unknown action type:
// currentCounterState = counterReducer(currentCounterState, { type: 'UNKNOWN_ACTION' });
// Argument of type '{ type: "UNKNOWN_ACTION"; }' is not assignable to parameter of type 'CounterAction'.

/*
 * Step 4: Explore advanced usage scenarios for Discriminated Unions, including
 * nested unions and designing extensible APIs.
 */

// 1. Nested Discriminated Unions for complex event structures
interface MouseClickEvent {
  type: 'mouse';
  action: 'click';
  x: number;
  y: number;
}

interface MouseMoveEvent {
  type: 'mouse';
  action: 'move';
  x: number;
  y: number;
}

type MouseEvent = MouseClickEvent | MouseMoveEvent;

interface KeyboardPressEvent {
  type: 'keyboard';
  action: 'press';
  key: string;
}

interface KeyboardReleaseEvent {
  type: 'keyboard';
  action: 'release';
  key: string;
}

type KeyboardEvent = KeyboardPressEvent | KeyboardReleaseEvent;

// A top-level discriminated union of events
type UserEvent = MouseEvent | KeyboardEvent;

// 2. Process nested events demonstrating multi-level narrowing
function processUserEvent(event: UserEvent): string {
  switch (event.type) {
    case 'mouse':
      // 'event' is narrowed to MouseEvent here
      switch (event.action) {
        case 'click':
          return `Mouse clicked at (${event.x}, ${event.y})`;
        case 'move':
          return `Mouse moved to (${event.x}, ${event.y})`;
      }
      break;
    case 'keyboard':
      // 'event' is narrowed to KeyboardEvent here
      switch (event.action) {
        case 'press':
          return `Key '${event.key}' pressed`;
        case 'release':
          return `Key '${event.key}' released`;
      }
      break;
    default:
      const _exhaustiveCheck: never = event;
      return _exhaustiveCheck; // Ensures all top-level types are handled
  }
  return 'Unknown event'; // Should not be reached with exhaustive checks
}

// 3. Examples of nested event processing
const click: UserEvent = { type: 'mouse', action: 'click', x: 100, y: 50 };
const keyPress: UserEvent = { type: 'keyboard', action: 'press', key: 'Enter' };

console.log(processUserEvent(click));
console.log(processUserEvent(keyPress));

/*
 * Expected Output:
 * Mouse clicked at (100, 50)
 * Key 'Enter' pressed
 */

// 4. Designing extensible APIs with generics and discriminated unions
// Example: A generic Result type for operations that can succeed or fail

interface SuccessResult<T> {
  status: 'success';
  value: T;
}

interface ErrorResult {
  status: 'error';
  message: string;
  code?: number;
}

type Result<T> = SuccessResult<T> | ErrorResult;

function handleOperationResult<T>(result: Result<T>): string {
  if (result.status === 'success') {
    // 'result' is SuccessResult<T>
    return `Operation successful: ${JSON.stringify(result.value)}`;
  } else {
    // 'result' is ErrorResult
    return `Operation failed: ${result.message}` + (result.code ? ` (Code: ${result.code})` : '');
  }
}

const successfulFetch: Result<string[]> = { status: 'success', value: ['data1', 'data2'] };
const failedAuth: Result<void> = { status: 'error', message: 'Authentication failed', code: 401 };

console.log(handleOperationResult(successfulFetch));
console.log(handleOperationResult(failedAuth));

/*
 * Expected Output:
 * Operation successful: ["data1","data2"]
 * Operation failed: Authentication failed (Code: 401)
 */