// Basic cases
const a = false;  // auto-inferred to be a boolean
const b = true;   // auto-inferred to be a boolean
const c = a || b; // auto-inferred to be a boolean

// Niche cases in certain blocks
enum CounterActionType {
  Increment = "INCREMENT",
  IncrementBy = "INCREMENT_BY",
}

interface IncrementAction {
  type: CounterActionType.Increment;
}

interface IncrementByAction {
  type: CounterActionType.IncrementBy;
  payload: number;
}

type CounterAction = IncrementAction | IncrementByAction;

function reducer(state: number, action: CounterAction) {
  switch (action.type) {
    case CounterActionType.Increment:
      // TS infers that the action is IncrementAction
      // & has no payload when the code in this case is
      // being executed
      return state + 1;
    case CounterActionType.IncrementBy:
      // TS infers that the action is IncrementByAction
      // & has a number as a payload when the code in this
      // case is being executed
      return state + action.payload;
    default:
      return state;
 }
}

type PermissionStatus = "granted" | "denied" | "undetermined";

const permissionStatus: PermissionStatus = "granted"; // ✅
const permissionStatus: PermissionStatus = "random";  // ❌

interface UnauthenticatedUser {
  isAuthenticated: false;
}

interface AuthenticatedUser {
  data: {
    /* ... */
 };
  isAuthenticated: true;
}

type User = UnauthenticatedUser | AuthenticatedUser;

const user: User = {
  isAuthenticated: false,
}; // ✅

type UnauthenticatedUserData = null;

enum PrivacyStatus {
  Public,
  Private,
}

enum PrivacyStatus {
  Public = "public",
  Private = "private",
}

enum PrivacyStatus {
  Public,  // 0
  Private, // 1
}

enum PrivacyStatus {
  Public,     // 0
  OnlyWith,   // 1
  OnlyExcept, // 2
  Private,    // 3
}

// continuing from the previous example
interface UnauthenticatedUser {
  isAuthenticated: false;
}

interface AuthenticatedUser {
  data: {
    /* ... */
 };
  isAuthenticated: true;
}

const isAuthenticatedUser = (user: User): user is AuthenticatedUser =>
  user.isAuthenticated;

if (isAuthenticatedUser(user)) {
  // user is AuthenticatedUser & you can access the data property
  console.log(user.data);
}

enum PaticipationStatus {
  Joined = "JOINED",
  Left = "LEFT",
  Pending = "PENDING",
}

// Using index signature
interface ParticipantData {
 [id: string]: PaticipationStatus;
}

// Using Record
type ParticipantData = Record<string, PaticipationStatus>;

const participants: ParticipantData = {
  id1: PaticipationStatus.Joined,
  id2: PaticipationStatus.Left,
  id3: PaticipationStatus.Pending,
  // ...
};

const getJsonString = <T>(data: T) => JSON.stringify(data, null, 2);

// usage
getJsonString({ name: "John Doe" }); // ✅
getJsonString([1, 2, 3]);            // ✅
getJsonString("Hello World");        // ✅

const removeItemFromArray = <T extends { id: string }>(
  array: T[],
  id: string
) => {
  const index = array.findIndex((item) => item.id === id);
  if (index !== -1) {
    array.splice(index, 1);
 }
  return array;
};

// usage
removeItemFromArray(
 [
  { id: "1", name: "John Doe" },
  { id: "2", name: "Jane Doe" },
 ],
 "1"
);                                   // ✅
removeItemFromArray([1, 2, 3], "1"); // ❌

interface User {
  name: string;
  age: number;
}

const user: Readonly<User> = {
  name: "John Doe",
  age: 30,
};

user.name = "Jane Doe"; // ❌ Error: Cannot assign to 'name' because it is a read-only property

const numbers: ReadonlyArray<number> = [1, 2, 3];

numbers.push(4); // ❌ Error: Property 'push' does not exist on type 'readonly number[]'
numbers[0] = 10; // ❌ Error: Index signature in type 'readonly number[]' only permits reading

type DeepReadonly<T> = {
  readonly [P in keyof T]: T[P] extends object ? DeepReadonly<T[P]> : T[P];
};

interface User {
  name: string;
  address: {
    city: string;
    country: string;
 };
}

const user: DeepReadonly<User> = {
  name: "John Doe",
  address: {
    city: "New York",
    country: "USA",
 },
};

user.address.city = "Los Angeles"; // ❌ Error: Cannot assign to 'city' because it is a read-only property

interface User {
  name: string;
  age?: number;
  email: string;
}

type PickUser = Pick<User, "name" | "age">;
type OmitUser = Omit<User, "age">;
type PartialUser = Partial<User>;
type RequiredUser = Required<User>;

// PickUser is equivalent to:
// interface PickUser {
//   name: string;
//   age?: number;
// }

// OmitUser is equivalent to:
// interface OmitUser {
//   name: string;
//   email: string;
// }

// PartialUser is equivalent to:
// interface PartialUser {
//   name?: string;
//   age?: number;
//   email?: string;
// }

// RequiredUser is equivalent to:
// interface RequiredUser {
//   name: string;
//   age: number;
//   email: string;
// }

interface UnauthenticatedUser {
  isAuthenticated: false;
}

interface AuthenticatedUser {
  data: {
    /* ... */
 };
  isAuthenticated: true;
}

// Union - user type allows both unauthenticated users and authenticated users to be stored
type User = UnauthenticatedUser | AuthenticatedUser;

interface UserData {
  name: string;
  email: string;
  phoneNumber: string;
}

interface UserMetaData {
  lastSignedInAt: Date;
  signInLocation: {
    country: string;
    city: string;
 };
}

type UserFullData = UserData & UserMetaData;
// UserFullData is equivalent to:
// interface UserFullData {
//   name: string;
//   email: string;
//   phoneNumber: string;
//   lastSignedInAt: Date;
//   signInLocation: {
//     country: string;
//     city: string;
//   };