/*
  Scenario: We process configuration data where property names are determined at runtime,
  but all values are consistently strings.
*/

// 1. Define an interface using an index signature.
//    This declares that any property accessed via a string key will return a string value.
interface StringConfig {
  [key: string]: string;
  // Optional: We can add known properties alongside the index signature.
  // For example, 'version' is always expected.
  // version?: string; // If 'version' might not always be present.
  // version: string; // If 'version' is always present, it must conform to the index signature type (string).
}

// 2. Activate the interface for a dynamic object.
const myDynamicConfig: StringConfig = {
  featureToggleA: 'enabled',
  databaseUrl: 'postgres://localhost:5432/mydb',
  apiEndpoint: '/v1/data'
};

// 3. Access properties safely.
//    TypeScript knows that accessing myDynamicConfig with a string key will yield a string.
const toggleStatus = myDynamicConfig.featureToggleA; // Type: string
const url = myDynamicConfig['databaseUrl'];      // Type: string

console.log(`Toggle Status: ${toggleStatus}`);
console.log(`Database URL: ${url}`);

// 4. Demonstrate type safety enforcement.
//    Attempting to assign a non-string value will result in a compile-time error.
// myDynamicConfig.port = 8080; // Error: Type 'number' is not assignable to type 'string'.

// 5. Example with a numeric index signature (less common for objects, more for arrays/tuple-like behavior if keys are numbers)
interface NumericConfig {
  [key: number]: string;
}

const numericData: NumericConfig = {
  0: 'first',
  1: 'second'
};

console.log(`Numeric data at 0: ${numericData[0]}`); // Type: string

// 6. Refinement: Allowing different value types (union types)
interface MixedConfig {
  [key: string]: string | number | boolean;
  // We can still have specific properties, but they must conform to the union type
  createdAt: number; // This is allowed as 'number' is part of 'string | number | boolean'
}

const mixedSettings: MixedConfig = {
  appName: 'MyApp',
  version: 1.0,
  isEnabled: true,
  createdAt: Date.now()
};

console.log(`App Name: ${mixedSettings.appName}`);     // Type: string | number | boolean
console.log(`Version: ${mixedSettings.version}`);       // Type: string | number | boolean
console.log(`Is Enabled: ${mixedSettings.isEnabled}`); // Type: string | number | boolean
console.log(`Created At: ${mixedSettings.createdAt}`); // Type: string | number | boolean

// Note: When using union types for values, we must narrow down the type before using specific methods.
if (typeof mixedSettings.version === 'number') {
  console.log(`Version number plus one: ${mixedSettings.version + 1}`);
}

/*
  Scenario: We model a collection of users, where each user is identified by a string ID
  and has a consistent structure (name and age).
*/

// 1. Define the type for the values our Record will hold.
interface UserProfile {
  name: string;
  age: number;
}

// 2. Activate the Record utility type.
//    Record<K, V> constructs an object type whose property keys are K and whose property values are V.
//    Here, keys are 'string' (user IDs) and values are 'UserProfile'.
type UserCollection = Record<string, UserProfile>;

// 3. Create an object conforming to UserCollection.
const users: UserCollection = {
  'user-101': {
    name: 'Alice',
    age: 30
  },
  'user-102': {
    name: 'Bob',
    age: 24
  },
  // 'user-103': { name: 'Charlie', age: 'twenty' } // Error: Type 'string' is not assignable to type 'number'.
};

// 4. Access properties safely.
const alice = users['user-101'];
console.log(`Alice's name: ${alice.name}, age: ${alice.age}`);

// 5. Demonstrate type enforcement for keys.
//    Record<K, V> is especially powerful when K is a union type of literal strings.
type Status = 'pending' | 'completed' | 'failed';

interface TaskState {
  message: string;
  timestamp: number;
}

// This ensures that our dictionary *only* has keys 'pending', 'completed', 'failed'.
type TaskStatuses = Record<Status, TaskState>;

const projectTasks: TaskStatuses = {
  pending: {
    message: 'Waiting for approval',
    timestamp: Date.now() - 3600000 // one hour ago
  },
  completed: {
    message: 'All tasks finished',
    timestamp: Date.now()
  },
  failed: {
    message: 'Build failed',
    timestamp: Date.now() - 120000 // two minutes ago
  }
};

console.log(`Pending task message: ${projectTasks.pending.message}`);

// projectTasks.inProgress = { message: 'In progress', timestamp: Date.now() }; // Error: Object literal may only specify known properties.

// 6. Practical difference: Index Signatures vs. Record
//    Index Signatures allow *any* string key, and you can add specific known properties.
interface AnyStringKeyObject {
  [key: string]: number;
  fixedProperty: number; // This is allowed
}

//    Record<string, V> also allows any string key, but is more explicit about the key type and value type.
//    It's often preferred for clarity when all keys are expected to be of a consistent type.
type StringKeyRecord = Record<string, number>;

const obj1: AnyStringKeyObject = { a: 1, b: 2, fixedProperty: 3 };
const obj2: StringKeyRecord = { a: 1, b: 2 };

//    Key difference when the key type is a union:
//    Index Signature with union key is not directly possible to *restrict* keys to that union.
//    Record<Union, V> *restricts* keys to exactly the members of the Union.

//    Let's say we want an object *only* with keys 'alpha', 'beta', 'gamma'
type SpecificKeys = 'alpha' | 'beta' | 'gamma';
type SpecificRecord = Record<SpecificKeys, boolean>;

const mySpecificObject: SpecificRecord = {
  alpha: true,
  beta: false,
  gamma: true
};

// mySpecificObject.delta = true; // Error: Object literal may only specify known properties.

//    With an index signature, this restriction isn't inherent without additional checks.
interface PotentialSpecificKeys {
  [key: string]: boolean;
  // We could add optional specific keys, but this doesn't *prevent* other keys
  alpha?: boolean;
  beta?: boolean;
  gamma?: boolean;
}

const myPotentialObject: PotentialSpecificKeys = {
  alpha: true,
  // delta: false // This *is* allowed by the index signature, even if we intended to restrict keys
};

// Conclusion: Use Record<Union, V> when we explicitly want to *restrict* the allowed keys to a specific set.
//             Use index signatures when we know the *type* of keys and values, but the specific keys are truly unknown/arbitrary at compile time.

/*
  Scenario: We process a diverse set of events, where keys identify event types,
  and values can be different data structures (e.g., string, number, or a complex object).
*/

// 1. Define distinct types for the values.
type SimpleEventValue = string | number;

interface ComplexEventData {
  id: string;
  timestamp: number;
  details?: string;
}

// 2. Forge a union type for the possible values.
type EventValue = SimpleEventValue | ComplexEventData;

// 3. Apply an index signature with the union type.
interface EventCatalog {
  [eventType: string]: EventValue;
}

const myEvents: EventCatalog = {
  'userLogin': 'success',
  'pageView': 150,
  'dataUpdate': {
    id: 'rec-abc-123',
    timestamp: Date.now(),
    details: 'User profile updated'
  },
  // 'errorOccurred': Symbol('uniqueError') // Error: Type 'Symbol' is not assignable to type 'EventValue'.
};

console.log(`User Login status: ${myEvents.userLogin}`);
console.log(`Page View count: ${myEvents.pageView}`);

// 4. Important: Type narrowing for union values.
//    We must check the type before accessing specific properties of ComplexEventData.
const dataUpdateEvent = myEvents.dataUpdate;
if (typeof dataUpdateEvent === 'object' && dataUpdateEvent !== null && 'id' in dataUpdateEvent) {
  // TypeScript now knows dataUpdateEvent is ComplexEventData within this block
  console.log(`Data Update ID: ${dataUpdateEvent.id}, Timestamp: ${dataUpdateEvent.timestamp}`);
}

// 5. Mapped Types for transforming existing types into dynamic objects.
//    Scenario: We want to create an object where keys are properties of another interface,
//    and values indicate if that property is 'available' or 'unavailable'.

interface Product {
  id: string;
  name: string;
  price: number;
  description?: string;
}

// Use a mapped type to create a new type that maps Product keys to 'status' strings.
// [P in keyof Product]: This iterates over each property key of Product.
// 'available' | 'unavailable': This sets the value type for each new property.
type ProductAvailability = { [P in keyof Product]: 'available' | 'unavailable' };

const productStatus: ProductAvailability = {
  id: 'available',
  name: 'available',
  price: 'unavailable',
  description: 'available' // Even optional properties get a status
};

console.log(`Product ID status: ${productStatus.id}`);

// 6. Common Pitfalls: Undefined values and accidental 'any'.
//    Always activate 'strictNullChecks' in tsconfig.json to catch potential undefined issues.

interface LooseConfig {
  [key: string]: string;
}

const looseConf: LooseConfig = {};

// const value = looseConf.nonExistentKey; // With strictNullChecks: Type 'string | undefined' is not assignable to type 'string'.
// Without strictNullChecks, this would be 'string', potentially leading to runtime errors.

// 7. Good practice: Explicitly handle undefined or use optional chaining.
const optionalValue = looseConf.nonExistentKey; // Type: string | undefined
if (optionalValue !== undefined) {
  console.log(`Found value: ${optionalValue}`);
}

// Using optional chaining (ECMAScript 2020+)
console.log(`Value with optional chaining: ${looseConf.anotherKey?.toUpperCase()}`); // No error, returns undefined if 'anotherKey' is missing

// 8. Pitfall: Incorrect key types
//    Ensure the key type in your index signature (e.g., 'string' or 'number') matches how you intend to access it.
interface NumberIndexedDict {
  [key: number]: string;
}

const numDict: NumberIndexedDict = { 1: 'one', 2: 'two' };
// numDict['1']; // Error: Element implicitly has an 'any' type because expression of type '"1"' can't be used to index type 'NumberIndexedDict'.
// This is because '1' (string literal) is not 'number'. Correct access: numDict[1];

console.log(`Number indexed dict value at 1: ${numDict[1]}`);

/*
  Scenario: Processing a dynamic API response containing varying keys based on user roles or feature flags.
  We aim to transform and validate this data.
*/

// 1. Define the possible structures for API response values.
interface UserDetails {
  name: string;
  email: string;
  role: 'admin' | 'user' | 'guest';
}

interface ProductInfo {
  productId: string;
  price: number;
  stock: number;
}

interface GenericMessage {
  message: string;
  code: number;
}

// 2. Create a union type for all possible dynamic data types.
type ApiResponseData = UserDetails | ProductInfo | GenericMessage;

// 3. Use a Record type to model the entire dynamic API response structure.
//    Keys are expected to be strings (e.g., 'currentUser', 'productCatalog', 'statusMessage').
type DynamicApiResponse = Record<string, ApiResponseData>;

// 4. Simulate a dynamic API response.
const apiResponse: DynamicApiResponse = {
  'currentUser': {
    name: 'Jane Doe',
    email: 'jane@example.com',
    role: 'admin'
  },
  'productCatalog': {
    productId: 'XYZ987',
    price: 99.99,
    stock: 500
  },
  'statusMessage': {
    message: 'Operation successful',
    code: 200
  },
  'auditLog': { message: 'User accessed admin panel', code: 101 } // Another GenericMessage
};

console.log(`Current User Role: ${apiResponse.currentUser.role}`);

// 5. Strategic Implementation: Processing and type-guarding dynamic data.
//    We need to identify the specific type of data received for each key.

function processApiResponse(response: DynamicApiResponse) {
  for (const key in response) {
    if (Object.prototype.hasOwnProperty.call(response, key)) {
      const data = response[key];

      // Type Guard 1: Check for UserDetails
      if ('name' in data && 'email' in data && 'role' in data) {
        const user = data as UserDetails; // Type assertion after 'in' checks
        console.log(`Processed User: ${user.name} (${user.role})`);
      }
      // Type Guard 2: Check for ProductInfo
      else if ('productId' in data && 'price' in data && 'stock' in data) {
        const product = data as ProductInfo;
        console.log(`Processed Product: ${product.productId} (Price: $${product.price})`);
      }
      // Type Guard 3: Check for GenericMessage (ensure it's not a leftover from previous checks)
      else if ('message' in data && 'code' in data) {
        const message = data as GenericMessage;
        console.log(`Processed Message [${message.code}]: ${message.message}`);
      }
      else {
        console.warn(`Unknown data structure for key: ${key}`, data);
      }
    }
  }
}

processApiResponse(apiResponse);

// 6. Refactoring existing JavaScript objects:
//    Imagine this untyped JS object comes from somewhere:
//    const jsConfig = { theme: 'dark', fontSize: 16, enableDebug: true };

//    Applying types:
interface AppConfig {
  [key: string]: string | number | boolean;
}

const jsConfig: unknown = { theme: 'dark', fontSize: 16, enableDebug: true };

// We can safely cast after validation or when confident in the source.
const typedConfig = jsConfig as AppConfig;

console.log(`Typed config theme: ${typedConfig.theme}`);

// 7. Data transformation example: Filtering and mapping
interface RawMetric {
  metricName: string;
  value: number;
  timestamp: number;
}

// This raw data might come as an array from an API, which we want to organize by metricName
const rawMetrics: RawMetric[] = [
  { metricName: 'cpuUsage', value: 75, timestamp: Date.now() },
  { metricName: 'memoryUsage', value: 80, timestamp: Date.now() },
  { metricName: 'cpuUsage', value: 78, timestamp: Date.now() - 60000} // Duplicate for illustration
];

// Desired structure: Record<string, number> (latest value for each metric)
type LatestMetrics = Record<string, number>;

function aggregateMetrics(metrics: RawMetric[]): LatestMetrics {
  const aggregated: LatestMetrics = {};
  for (const metric of metrics) {
    // We'll just take the last encountered value for simplicity in this example
    aggregated[metric.metricName] = metric.value;
  }
  return aggregated;
}

const latestMetrics = aggregateMetrics(rawMetrics);
console.log('Latest Aggregated Metrics:', latestMetrics);
// Expected output: { cpuUsage: 78, memoryUsage: 80 }