/*
  File: user.ts
  Description: Defines the base User type and demonstrates Pick usage.
*/

// 1. Define a comprehensive base type
interface User {
  id: string;
  firstName: string;
  lastName: string;
  email: string;
  age: number;
  role: 'admin' | 'user' | 'guest';
  createdAt: Date;
  updatedAt?: Date;
}

// 2. Use Pick to create a type for displaying user profile information
//    We select only the properties necessary for a public profile view.
type UserProfile = Pick<User, 'id' | 'firstName' | 'lastName' | 'email'>;

// 3. Use Pick to create a type for user creation (excluding system-generated fields)
//    For creating a new user, we only need basic input fields.
type NewUserInput = Pick<User, 'firstName' | 'lastName' | 'email' | 'age' | 'role'>;

// 4. Demonstrate usage with concrete examples
const user1: User = {
  id: 'usr_001',
  firstName: 'Alice',
  lastName: 'Smith',
  email: 'alice.smith@example.com',
  age: 30,
  role: 'user',
  createdAt: new Date()
};

const profile1: UserProfile = {
  id: user1.id,
  firstName: user1.firstName,
  lastName: user1.lastName,
  email: user1.email
};

console.log('User Profile:', profile1);
// Expected output: { id: 'usr_001', firstName: 'Alice', lastName: 'Smith', email: 'alice.smith@example.com' }

const newUser: NewUserInput = {
  firstName: 'Bob',
  lastName: 'Johnson',
  email: 'bob.johnson@example.com',
  age: 25,
  role: 'guest'
};

console.log('New User Input:', newUser);
// Expected output: { firstName: 'Bob', lastName: 'Johnson', email: 'bob.johnson@example.com', age: 25, role: 'guest' }

// 5. Common error: attempting to pick a non-existent property
// type InvalidPick = Pick<User, 'nonExistentProperty'>; // ERROR: Property 'nonExistentProperty' does not exist on type 'User'.

/*
  Summary of Pick:
  - Purpose: Creates a new type by selecting a subset of properties from an existing type.
  - Syntax: Pick<Type, Keys>
  - `Type`: The original type to pick from.
  - `Keys`: A union of string literals representing the property names to include.
  - Benefit: Promotes reusability and type safety, prevents accidental inclusion of irrelevant data.
*/

/*
  File: product.ts
  Description: Defines the base Product type and demonstrates Omit usage.
*/

// 1. Define a comprehensive base type for a product
interface Product {
  id: string;
  name: string;
  description: string;
  price: number;
  currency: string;
  stock: number;
  supplierId: string;
  internalCost: number; // Sensitive information
  createdAt: Date;
  updatedAt?: Date;
}

// 2. Use Omit to create a type for public product display
//    We want to exclude sensitive internalCost and supplierId from public view.
type PublicProduct = Omit<Product, 'internalCost' | 'supplierId'>;

// 3. Use Omit to create a type for updating product details
//    When updating, we usually don't modify the ID or creation date.
type ProductUpdateInput = Omit<Product, 'id' | 'createdAt' | 'updatedAt'>;

// 4. Demonstrate usage with concrete examples
const fullProduct: Product = {
  id: 'prod_101',
  name: 'Wireless Mouse',
  description: 'Ergonomic wireless mouse with customizable buttons.',
  price: 29.99,
  currency: 'USD',
  stock: 150,
  supplierId: 'sup_xyz_456',
  internalCost: 15.00,
  createdAt: new Date('2023-01-01T10:00:00Z')
};

const publicView: PublicProduct = {
  id: fullProduct.id,
  name: fullProduct.name,
  description: fullProduct.description,
  price: fullProduct.price,
  currency: fullProduct.currency,
  stock: fullProduct.stock,
  createdAt: fullProduct.createdAt
  // internalCost and supplierId are omitted by type safety
};

console.log('Public Product View:', publicView);
/* Expected output:
{ id: 'prod_101', name: 'Wireless Mouse', description: 'Ergonomic wireless mouse with customizable buttons.', price: 29.99, currency: 'USD', stock: 150, createdAt: 2023-01-01T10:00:00.000Z }
*/

const updatePayload: ProductUpdateInput = {
  name: 'Advanced Wireless Mouse',
  description: 'Next-gen ergonomic wireless mouse with customizable buttons and extended battery life.',
  price: 34.99,
  currency: 'USD',
  stock: 120,
  internalCost: 17.50, // This can be updated internally
  supplierId: 'sup_abc_789' // Supplier might change
};

console.log('Product Update Input:', updatePayload);
/* Expected output:
{ name: 'Advanced Wireless Mouse', description: 'Next-gen ergonomic wireless mouse with customizable buttons and extended battery life.', price: 34.99, currency: 'USD', stock: 120, internalCost: 17.5, supplierId: 'sup_abc_789' }
*/

// 5. Common error: omitting a non-existent property (no error in Omit, it simply ignores it)
// type NoImpactOmit = Omit<Product, 'nonExistentProperty'>; // This is valid but has no effect

/*
  Summary of Omit:
  - Purpose: Creates a new type by removing specified properties from an existing type.
  - Syntax: Omit<Type, Keys>
  - `Type`: The original type to omit from.
  - `Keys`: A union of string literals representing the property names to exclude.
  - Benefit: Ideal for hiding sensitive data, creating partial update types, or simplifying types for specific contexts.
*/

/*
  File: combined_types.ts
  Description: Demonstrates combining Pick and Omit with other utility types for advanced scenarios.
*/

// 1. Define a base interface for a Task management system
interface Task {
  id: string;
  title: string;
  description: string;
  status: 'todo' | 'in-progress' | 'done';
  priority: 'low' | 'medium' | 'high';
  assigneeId: string;
  dueDate: Date;
  createdAt: Date;
  updatedAt?: Date;
  comments: string[];
}

// 2. Scenario 1: Create a type for a new task input
//    - We don't need 'id', 'createdAt', 'updatedAt', 'comments' (system/derived fields).
//    - We want 'dueDate' to be optional for creation.
type NewTaskInput = Omit<Task, 'id' | 'createdAt' | 'updatedAt' | 'comments'> & {
  dueDate?: Date; // Make dueDate optional, overriding the original required property
};

const newTask: NewTaskInput = {
  title: 'Implement authentication',
  description: 'Develop and integrate user authentication module.',
  status: 'todo',
  priority: 'high',
  assigneeId: 'usr_005',
  // dueDate is optional
};
console.log('New Task Input:', newTask);

// 3. Scenario 2: Create a type for a task card component (UI display)
//    - Only needs 'id', 'title', 'status', 'priority', 'dueDate', 'assigneeId'.
//    - For display, 'dueDate' might be a string (formatted), not Date object.
type TaskCardProps = Pick<Task, 'id' | 'title' | 'status' | 'priority' | 'assigneeId'> & {
  formattedDueDate: string; // Add a new property specific to UI
};

const taskForCard: Task = {
  id: 'tsk_001',
  title: 'Refactor database queries',
  description: 'Optimize slow SQL queries for performance.',
  status: 'in-progress',
  priority: 'medium',
  assigneeId: 'usr_002',
  dueDate: new Date('2024-07-15T09:00:00Z'),
  createdAt: new Date('2024-07-01T08:00:00Z'),
  comments: ['Initial review complete']
};

const taskCardData: TaskCardProps = {
  id: taskForCard.id,
  title: taskForCard.title,
  status: taskForCard.status,
  priority: taskForCard.priority,
  assigneeId: taskForCard.assigneeId,
  formattedDueDate: taskForCard.dueDate.toLocaleDateString('en-US')
};
console.log('Task Card Props:', taskCardData);

// 4. Scenario 3: Create a partial update type for a task
//    - We want all properties except 'id' to be optional.
//    - Omit 'id', then make remaining properties Partial.
type PartialTaskUpdate = Partial<Omit<Task, 'id'>>;

const taskUpdate: PartialTaskUpdate = {
  status: 'done',
  updatedAt: new Date(),
  description: 'Queries refactored and tested.'
};
console.log('Partial Task Update:', taskUpdate);

// 5. Combining with a Record type to define a dictionary of entities, then transforming values
interface Item {
    itemId: string;
    itemName: string;
    itemPrice: number;
    internalCode: string;
}

type PublicItemDict = Record<string, Omit<Item, 'internalCode'>>;

const inventory: PublicItemDict = {
    'ABC-001': {
        itemId: 'ABC-001',
        itemName: 'Gadget A',
        itemPrice: 19.99
    },
    'XYZ-002': {
        itemId: 'XYZ-002',
        itemName: 'Widget B',
        itemPrice: 49.99
    }
};
console.log('Public Inventory:', inventory);

/*
  Summary of Strategic Applications:
  - Combine Pick/Omit with intersection types (&) to add new properties or override existing ones.
  - Integrate with Partial<T> to create flexible update types.
  - Utilize with Record<K, V> for dictionaries of transformed types.
  - Apply to React component props for precise data flow.
*/

/*
  File: best_practices.ts
  Description: Illustrates best practices for using Pick and Omit, focusing on maintainability and clarity.
*/

// 1. Define a base interface for a user, including an optional field for demonstration
interface UserProfile {
  id: string;
  username: string;
  email: string;
  bio?: string; // Optional field
  lastLogin: Date;
  isAdmin: boolean;
}

// 2. Best Practice: Favor Pick for whitelisting when a small subset is needed.
//    Clearer intent: "These are the ONLY properties I want."
type PublicUserSummary = Pick<UserProfile, 'id' | 'username' | 'email'>;

const userSummary: PublicUserSummary = {
  id: 'u001',
  username: 'dev_explorer',
  email: 'explorer@example.com'
};
console.log('Public User Summary (Pick):', userSummary);

// 3. Best Practice: Favor Omit for blacklisting when a large subset is needed and few properties excluded.
//    Clearer intent: "I want everything EXCEPT these."
type AdminUserView = Omit<UserProfile, 'lastLogin' | 'isAdmin'>;

const adminUser: AdminUserView = {
  id: 'a001',
  username: 'admin_user',
  email: 'admin@example.com',
  bio: 'System Administrator',
};
console.log('Admin User View (Omit):', adminUser);

// 4. Avoiding excessive nesting or chaining of Pick/Omit
//    Bad: type DeeplyNestedType = Pick<Omit<Pick<User, 'id' | 'name'> & { temp: string }, 'temp'>, 'id'>;
//    Better: Simplify if possible, or create intermediate types for clarity.
interface BasicUserInfo {
  id: string;
  name: string;
}
interface TempUserInfo extends BasicUserInfo {
  temp: string;
}
type DeeplyNestedType = Pick<TempUserInfo, 'id'>; // More readable composition

// 5. Documenting complex type transformations
/**
 * @description Represents a user's publicly visible information for display on a user card.
 * Excludes sensitive fields like 'lastLogin' and 'isAdmin'.
 */
type UserCardInfo = Omit<UserProfile, 'lastLogin' | 'isAdmin'>;

// 6. Leverage template literal types with Pick/Omit for dynamic key selection (advanced)
interface Settings {
    userId: string;
    theme: 'dark' | 'light';
    language: string;
    'api-key': string; // Example of non-standard key name
}

// Pick all keys that start with 'user'
type UserScopedSettings = Pick<Settings, Extract<keyof Settings, `user${string}`>>;

const userSetting: UserScopedSettings = {
    userId: 'xyz-123'
};
console.log('User Scoped Settings:', userSetting);

/*
  Summary of Best Practices:
  - When to use Pick vs. Omit: Pick for small include lists (whitelisting), Omit for small exclude lists (blacklisting).
  - Avoid deep nesting: Create intermediate types for complex transformations.
  - Document intent: Use JSDoc comments for clarity.
  - Embrace IDE support: Auto-completion reduces errors.
  - Consider template literal types for dynamic key matching in advanced scenarios.
*/