/*
 * Demonstrates the 'any' type's behavior.
 * 'any' bypasses all type checks, allowing any operation without compile-time validation.
 */

// 1. Declaring a variable with 'any'
let dataAny: any = 'Hello World';
console.log(dataAny); // Output: Hello World

// 2. Assigning different types to 'any' is permitted
dataAny = 123;
console.log(dataAny); // Output: 123

dataAny = { name: 'Alice', age: 30 };
console.log(dataAny); // Output: { name: 'Alice', age: 30 }

// 3. 'any' allows calling methods/accessing properties that may not exist at runtime
//    TypeScript compiler will NOT flag these as errors.
console.log(dataAny.name); // Valid at compile time, Output: Alice
console.log(dataAny.nonExistentMethod()); // Valid at compile time, will cause runtime error!

// 4. 'any' can be assigned to any other type without a type check
let myString: string = dataAny; // No error, even if dataAny holds a number or object
console.log(myString);

// This illustrates the danger: 'myString' is declared as string, but holds an object.
// Any operation on 'myString' expecting a string will now fail at runtime.
// For example, myString.toUpperCase() would crash if dataAny was { name: 'Alice' }.

console.log("--- DANGER ZONE ---");
try {
    let riskyValue: any = { method: () => 'result' };
    (riskyValue as any).nonExistentProperty.someAction(); // Runtime error: nonExistentProperty is undefined
} catch (e) {
    console.error("Caught a runtime error due to 'any':", e.message);
}

// 'any' essentially opts out of the TypeScript type system for the variable it's applied to
// and any subsequent variables derived from it without explicit type assertions.

/*
 * Demonstrates the 'unknown' type's behavior.
 * 'unknown' is a type-safe counterpart to 'any', forcing explicit type narrowing.
 */

// 1. Declaring a variable with 'unknown'
let dataUnknown: unknown = 'Hello TypeScript';
console.log(dataUnknown); // Output: Hello TypeScript

// 2. Assigning different types to 'unknown' is permitted
dataUnknown = 456;
console.log(dataUnknown); // Output: 456

dataUnknown = { id: 101, status: 'active' };
console.log(dataUnknown); // Output: { id: 101, status: 'active' }

// 3. 'unknown' prevents direct operations without type narrowing
//    The following lines will cause compile-time errors.
// console.log(dataUnknown.id); // Error: Object is of type 'unknown'.
// console.log(dataUnknown.toUpperCase()); // Error: Object is of type 'unknown'.

// 4. To operate on an 'unknown' type, we must perform type narrowing.
//    This forces us to explicitly check the type before interaction.
if (typeof dataUnknown === 'object' && dataUnknown !== null && 'id' in dataUnknown) {
    // Now TypeScript knows dataUnknown is an object with an 'id' property.
    // We still need a type assertion or further narrowing for precise type information.
    console.log((dataUnknown as { id: number }).id); // Output: 101
}

// Example with string narrowing
if (typeof dataUnknown === 'string') {
    console.log(dataUnknown.toUpperCase());
} else {
    console.log("dataUnknown is not a string, cannot call toUpperCase.");
}

// 5. 'unknown' cannot be assigned directly to most other types without explicit type assertion or narrowing.
// let myNumber: number = dataUnknown; // Error: Type 'unknown' is not assignable to type 'number'.

// This forces developers to be deliberate about type conversions, enhancing safety.
let myStrictNumber: number;
if (typeof dataUnknown === 'number') {
    myStrictNumber = dataUnknown;
    console.log("Assigned number: ", myStrictNumber); // Output: Assigned number: 456
}

console.log("--- SAFE INTERACTION ---");
let apiResponse: unknown = { message: 'Success', code: 200 };

// Safely access properties after narrowing
if (typeof apiResponse === 'object' && apiResponse !== null &&
    'message' in apiResponse && typeof (apiResponse as { message: unknown }).message === 'string') {
    console.log("API Message:", (apiResponse as { message: string }).message);
}

/*
 * Surgical comparison of 'any' vs 'unknown' when handling untrusted input.
 * Focus on how each type influences safety and development workflow.
 */

interface UserProfile {
    id: number;
    username: string;
    email?: string;
}

// Scenario: Processing an untrusted JSON payload from an API
const untrustedApiResponse = JSON.parse('{"id": 1, "username": "dev_master", "email": "dev@example.com", "secret": "top-secret"}');

console.log("--- Using 'any' for untrusted input ---");
let profileAny: any = untrustedApiResponse; // 'any' accepts anything

// With 'any', we can access properties directly without checks
// This works even if 'id' or 'username' didn't exist, leading to 'undefined'.
// If 'email' was a number, .includes() would crash at runtime.
console.log(`Any User: ${profileAny.username}, ID: ${profileAny.id}, Email contains 'dev': ${profileAny.email?.includes('dev')}`);

// We can even access non-existent properties without compile-time error
console.log(`Any secret (might be undefined): ${profileAny.secret}`);

// Type assertion (less common with any as it's already 'open')
const userAny: UserProfile = profileAny; // No type check performed here!
// If profileAny didn't match UserProfile, userAny would be malformed.
// userAny.nonExistentProperty; // This would cause runtime error if 'UserProfile' was enforced but 'profileAny' was something else.

console.log("--- Using 'unknown' for untrusted input ---");
let profileUnknown: unknown = untrustedApiResponse; // 'unknown' accepts anything, but requires narrowing

// Attempting direct access with 'unknown' results in compile-time errors:
// console.log(profileUnknown.username); // Error: Object is of type 'unknown'.

// We must perform explicit type narrowing to interact safely
let userUnknown: UserProfile;

if (typeof profileUnknown === 'object' && profileUnknown !== null) {
    // Cast to an intermediate type to check properties, or use 'in' operator
    const tempProfile = profileUnknown as {
        id?: unknown;
        username?: unknown;
        email?: unknown;
    };

    if (
        typeof tempProfile.id === 'number' &&
        typeof tempProfile.username === 'string'
        // Optional: check for email if required
    ) {
        userUnknown = {
            id: tempProfile.id,
            username: tempProfile.username,
            email: typeof tempProfile.email === 'string' ? tempProfile.email : undefined
        };
        console.log(`Unknown User: ${userUnknown.username}, ID: ${userUnknown.id}, Email contains 'dev': ${userUnknown.email?.includes('dev')}`);
    } else {
        console.error("Invalid UserProfile structure received.");
    }
} else {
    console.error("Received non-object type for profile.");
}

// Accessing 'secret' with unknown is not allowed without narrowing, which is good for security
// console.log(profileUnknown.secret); // Error: Object is of type 'unknown'.

// The 'unknown' approach forces us to validate the shape of the data,
// making our code resilient to unexpected input and preventing silent failures.

/*
 * Demonstrates practical type narrowing techniques required for 'unknown' types.
 * These techniques allow safe interaction with values of uncertain type.
 */

// 1. Using 'typeof' for primitive types
function processInputString(input: unknown) {
    if (typeof input === 'string') {
        // 'input' is now narrowed to 'string'
        console.log("Processed string:", input.toUpperCase());
    } else {
        console.log("Input is not a string.");
    }
}

processInputString("hello");     // Output: Processed string: HELLO
processInputString(123);         // Output: Input is not a string.
processInputString({ name: 'test' }); // Output: Input is not a string.

// 2. Using 'instanceof' for class instances
class MyClass {
    constructor(public value: number) {}
    getValue() { return this.value; }
}

function processClassInstance(obj: unknown) {
    if (obj instanceof MyClass) {
        // 'obj' is now narrowed to 'MyClass'
        console.log("MyClass value:", obj.getValue());
    } else {
        console.log("Object is not an instance of MyClass.");
    }
}

processClassInstance(new MyClass(42)); // Output: MyClass value: 42
processClassInstance({});            // Output: Object is not an instance of MyClass.

// 3. Using the 'in' operator for checking property existence in objects
function processObjectWithProperty(data: unknown) {
    if (typeof data === 'object' && data !== null && 'id' in data) {
        // TypeScript now knows 'data' is an object with an 'id' property.
        // We still need to assert the type of 'id' if we want to use it strongly.
        const typedData = data as { id: unknown }; // Temporarily cast for property access
        if (typeof typedData.id === 'number') {
            console.log("Object with numeric ID:", typedData.id);
        } else {
            console.log("Object has 'id' but it's not a number.");
        }
    } else {
        console.log("Data is not an object with an 'id' property.");
    }
}

processObjectWithProperty({ id: 123, name: 'Test' }); // Output: Object with numeric ID: 123
processObjectWithProperty({ name: 'No ID' });      // Output: Data is not an object with an 'id' property.
processObjectWithProperty(null);                  // Output: Data is not an object with an 'id' property.

// 4. User-defined type guards (predicates)
interface Person { name: string; age: number; }

function isPerson(value: unknown): value is Person {
    return (
        typeof value === 'object' &&
        value !== null &&
        'name' in value && typeof (value as { name: unknown }).name === 'string' &&
        'age' in value && typeof (value as { age: unknown }).age === 'number'
    );
}

function greet(entity: unknown) {
    if (isPerson(entity)) {
        // 'entity' is now narrowed to 'Person'
        console.log(`Hello, ${entity.name}! You are ${entity.age} years old.`);
    } else {
        console.log("Cannot greet: not a valid Person object.");
    }
}

greet({ name: 'Bob', age: 25 }); // Output: Hello, Bob! You are 25 years old.
greet({ name: 'Charlie' });     // Output: Cannot greet: not a valid Person object.

// 5. Assertion Functions (TypeScript 3.7+)
//    Ensures a condition is true, otherwise throws an error.
//    Compiler knows that code after this call can assume the type.
function assertIsString(val: unknown): asserts val is string {
    if (typeof val !== 'string') {
        throw new Error('Not a string!');
    }
}

function processAssertedString(input: unknown) {
    try {
        assertIsString(input); // If this doesn't throw, 'input' is guaranteed to be a string.
        console.log("Asserted string:", input.toLowerCase());
    } catch (e) {
        console.error("Error processing input:", e.message);
    }
}

processAssertedString("TypeScript"); // Output: Asserted string: typescript
processAssertedString(12345);      // Output: Error processing input: Not a string!

// These techniques are crucial for safely transforming 'unknown' values
// into explicitly typed values, upholding compile-time guarantees.