// DeepPartial - torna todas as propriedades opcionais recursivamente
type DeepPartial<T> = {
  [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
};

// Exemplo de uso
interface Config {
  api: {
    baseUrl: string;
    timeout: number;
    headers: {
      authorization: string;
      contentType: string;
    };
  };
  features: {
    darkMode: boolean;
    analytics: boolean;
  };
}

// Agora podemos fazer updates parciais profundos
function updateConfig(config: Config, updates: DeepPartial<Config>): Config {
  return deepMerge(config, updates);
}

updateConfig(defaultConfig, {
  api: {
    timeout: 5000, // Só atualiza timeout
  },
});

// DeepReadonly - imutabilidade profunda
type DeepReadonly<T> = {
  readonly [P in keyof T]: T[P] extends object
    ? T[P] extends Function
      ? T[P]
      : DeepReadonly<T[P]>
    : T[P];
};

// Uso com estado imutável
const state: DeepReadonly<AppState> = {
  user: {
    name: 'John',
    preferences: {
      theme: 'dark',
    },
  },
};

// ❌ Erro de compilação!
state.user.preferences.theme = 'light';

// Remove null e undefined recursivamente
type NonNullableDeep<T> = {
  [P in keyof T]-?: NonNullableDeep<NonNullable<T[P]>>;
};

interface ApiResponse {
  data?: {
    user?: {
      name?: string;
      email?: string;
    } | null;
  } | null;
}

// Após validação, garantimos que tudo existe
type ValidatedResponse = NonNullableDeep<ApiResponse>;
// { data: { user: { name: string; email: string } } }

// Gerar tipos de eventos automaticamente
type EventName = 'click' | 'focus' | 'blur' | 'change';
type EventHandler = `on${Capitalize<EventName>}`;
// "onClick" | "onFocus" | "onBlur" | "onChange"

// Usando para criar props de componentes
type EventHandlers = {
  [K in EventHandler]?: (event: Event) => void;
};

interface ButtonProps extends EventHandlers {
  label: string;
  variant: 'primary' | 'secondary';
}

// Definir rotas de API com parâmetros tipados
type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';

type ApiRoute<
  Method extends HttpMethod,
  Path extends string
> = `${Method} ${Path}`;

// Rotas específicas
type UserRoutes =
  | ApiRoute<'GET', '/users'>
  | ApiRoute<'GET', '/users/:id'>
  | ApiRoute<'POST', '/users'>
  | ApiRoute<'PUT', '/users/:id'>
  | ApiRoute<'DELETE', '/users/:id'>;

// Extrair parâmetros da rota
type ExtractParams<T extends string> =
  T extends `${infer _Start}:${infer Param}/${infer Rest}`
    ? Param | ExtractParams<Rest>
    : T extends `${infer _Start}:${infer Param}`
    ? Param
    : never;

type UserIdParam = ExtractParams<'/users/:id/posts/:postId'>;
// "id" | "postId"

// Extrair tipo de retorno de função async
type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;

async function fetchUser(): Promise<{ id: number; name: string }> {
  return { id: 1, name: 'John' };
}

type User = UnwrapPromise<ReturnType<typeof fetchUser>>;
// { id: number; name: string }

// Extrair tipo de elementos de array
type ArrayElement<T> = T extends (infer U)[] ? U : never;

type Item = ArrayElement<string[]>; // string

// Filtrar tipos de uma union
type FilterByType<T, U> = T extends U ? T : never;

type Mixed = string | number | boolean | null | undefined;
type OnlyStringsAndNumbers = FilterByType<Mixed, string | number>;
// string | number

// Excluir tipos de uma union (similar ao Exclude built-in)
type ExcludeType<T, U> = T extends U ? never : T;

type NoNullOrUndefined = ExcludeType<Mixed, null | undefined>;
// string | number | boolean

// Builder pattern com tipos
type Builder<T> = {
  [K in keyof T as `set${Capitalize<string & K>}`]: (value: T[K]) => Builder<T>;
} & {
  build: () => T;
};

interface UserConfig {
  name: string;
  email: string;
  age: number;
}

// O tipo Builder<UserConfig> terá:
// setName(value: string): Builder<UserConfig>
// setEmail(value: string): Builder<UserConfig>
// setAge(value: number): Builder<UserConfig>
// build(): UserConfig

function createBuilder<T>(): Builder<T> {
  const data: Partial<T> = {};

  const builder = new Proxy({} as Builder<T>, {
    get(_, prop: string) {
      if (prop === 'build') {
        return () => data as T;
      }
      if (prop.startsWith('set')) {
        const key = prop.slice(3).toLowerCase() as keyof T;
        return (value: T[keyof T]) => {
          data[key] = value;
          return builder;
        };
      }
    },
  });

  return builder;
}

// Uso
const user = createBuilder<UserConfig>()
  .setName('John')
  .setEmail('john@example.com')
  .setAge(30)
  .build();

type Getters<T> = {
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K];
};

type Setters<T> = {
  [K in keyof T as `set${Capitalize<string & K>}`]: (value: T[K]) => void;
};

type Accessors<T> = Getters<T> & Setters<T>;

interface State {
  count: number;
  name: string;
}

type StateAccessors = Accessors<State>;
// {
//   getCount: () => number;
//   setCount: (value: number) => void;
//   getName: () => string;
//   setName: (value: string) => void;
// }

// Definir branded types
declare const brand: unique symbol;

type Brand<T, B> = T & { [brand]: B };

// Criar tipos específicos
type UserId = Brand<string, 'UserId'>;
type PostId = Brand<string, 'PostId'>;
type Email = Brand<string, 'Email'>;

// Funções para criar instâncias validadas
function createUserId(id: string): UserId {
  if (!id.startsWith('user_')) {
    throw new Error('Invalid user ID format');
  }
  return id as UserId;
}

function createEmail(email: string): Email {
  if (!email.includes('@')) {
    throw new Error('Invalid email format');
  }
  return email as Email;
}

// Agora o TypeScript previne erros
function getUser(id: UserId): Promise<User> {
  return fetch(`/api/users/${id}`).then(r => r.json());
}

function getPost(id: PostId): Promise<Post> {
  return fetch(`/api/posts/${id}`).then(r => r.json());
}

const userId = createUserId('user_123');
const postId = 'post_456' as PostId;

getUser(userId); // ✅ OK
getUser(postId); // ❌ Erro! PostId não é UserId

// Estado de requisição assíncrona
type AsyncState<T, E = Error> =
  | { status: 'idle' }
  | { status: 'loading' }
  | { status: 'success'; data: T }
  | { status: 'error'; error: E };

// Uso
function useAsync<T>(): AsyncState<T> {
  // implementação...
}

function renderUser(state: AsyncState<User>) {
  switch (state.status) {
    case 'idle':
      return <p>Click to load</p>;
    case 'loading':
      return <Spinner />;
    case 'success':
      // TypeScript sabe que state.data existe aqui!
      return <UserCard user={state.data} />;
    case 'error':
      // TypeScript sabe que state.error existe aqui!
      return <ErrorMessage error={state.error} />;
  }
}

// Garantir que todos os casos são tratados
function assertNever(x: never): never {
  throw new Error(`Unexpected value: ${x}`);
}

type Action =
  | { type: 'INCREMENT' }
  | { type: 'DECREMENT' }
  | { type: 'RESET'; payload: number };

function reducer(state: number, action: Action): number {
  switch (action.type) {
    case 'INCREMENT':
      return state + 1;
    case 'DECREMENT':
      return state - 1;
    case 'RESET':
      return action.payload;
    default:
      // Se adicionar novo tipo de action e esquecer de tratar,
      // TypeScript vai reclamar aqui!
      return assertNever(action);
  }
}

// Overloads para diferentes tipos de input/output
function parse(input: string): object;
function parse(input: string, reviver: (key: string, value: unknown) => unknown): object;
function parse(input: Buffer): object;
function parse(
  input: string | Buffer,
  reviver?: (key: string, value: unknown) => unknown
): object {
  const str = typeof input === 'string' ? input : input.toString();
  return JSON.parse(str, reviver);
}

// TypeScript infere o tipo correto baseado no input
const obj1 = parse('{"name": "John"}'); // objeto
const obj2 = parse(Buffer.from('{"name": "John"}')); // objeto