// ============================================================================
// Helpers
// ============================================================================

type InternalBuildArray<
  N extends number,
  Acc extends readonly unknown[] = [],
> = Acc["length"] extends N ? Acc : InternalBuildArray<N, [...Acc, unknown]>

type InternalIsGreaterThan<A extends number, B extends number> = A extends B
  ? false
  : InternalBuildArray<A> extends [...InternalBuildArray<B>, ...infer _Rest]
    ? _Rest extends [unknown, ...unknown[]]
      ? true
      : false
    : false

// ============================================================================
// Primitives
// ============================================================================

/**
 * @description Conditional type selector based on a boolean value (ternary operator).
 *
 * @example
 *   ```
 *   // Expect: 'yes'
 *   type Example1 = BooleanIf<true, 'yes', 'no'>
 *   // Expect: 'no'
 *   type Example2 = BooleanIf<false, 'yes', 'no'>
 *   ```
 */
export type BooleanIf<Condition extends boolean, Then, Else> = Condition extends true ? Then : Else

// ============================================================================
// Comparison
// ============================================================================

/**
 * @description Check if two boolean values are equal.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = BooleanIsEqual<true, true>
 *   // Expect: true
 *   type Example2 = BooleanIsEqual<false, false>
 *   // Expect: false
 *   type Example3 = BooleanIsEqual<true, false>
 *   ```
 */
export type BooleanIsEqual<T extends boolean, U extends boolean> = T extends U
  ? U extends T
    ? true
    : false
  : false

/**
 * @description Logical implication (A → B), equivalent to ¬A ∨ B.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = BooleanImplies<true, true>
 *   // Expect: false
 *   type Example2 = BooleanImplies<true, false>
 *   // Expect: true
 *   type Example3 = BooleanImplies<false, true>
 *   // Expect: true
 *   type Example4 = BooleanImplies<false, false>
 *   ```
 */
export type BooleanImplies<T extends boolean, U extends boolean> = T extends true
  ? U extends true
    ? true
    : false
  : true

// ============================================================================
// Query
// ============================================================================

type InternalBooleanCountTrue<
  T extends readonly boolean[],
  Acc extends readonly unknown[] = [],
> = T extends [infer First extends boolean, ...infer Rest extends boolean[]]
  ? First extends true
    ? InternalBooleanCountTrue<Rest, [...Acc, unknown]>
    : InternalBooleanCountTrue<Rest, Acc>
  : Acc["length"]
/**
 * @description Count the number of true values in a boolean tuple.
 *
 * @example
 *   ```
 *   // Expect: 2
 *   type Example1 = BooleanCountTrue<[true, false, true]>
 *   // Expect: 0
 *   type Example2 = BooleanCountTrue<[false, false]>
 *   ```
 */
export type BooleanCountTrue<T extends readonly boolean[]> = InternalBooleanCountTrue<T>

type InternalBooleanCountFalse<
  T extends readonly boolean[],
  Acc extends readonly unknown[] = [],
> = T extends [infer First extends boolean, ...infer Rest extends boolean[]]
  ? First extends false
    ? InternalBooleanCountFalse<Rest, [...Acc, unknown]>
    : InternalBooleanCountFalse<Rest, Acc>
  : Acc["length"]
/**
 * @description Count the number of false values in a boolean tuple.
 *
 * @example
 *   ```
 *   // Expect: 2
 *   type Example1 = BooleanCountFalse<[true, false, false]>
 *   // Expect: 0
 *   type Example2 = BooleanCountFalse<[true, true]>
 *   ```
 */
export type BooleanCountFalse<T extends readonly boolean[]> = InternalBooleanCountFalse<T>

/**
 * @description Count the number of true or false values in a boolean tuple.
 *
 * @example
 *   ```
 *   // Expect: 2
 *   type Example1 = BooleanCount<[true, false, true], true>
 *   // Expect: 1
 *   type Example2 = BooleanCount<[true, false, true], false>
 *   ```
 */
export type BooleanCount<T extends readonly boolean[], Value extends boolean> = Value extends true
  ? BooleanCountTrue<T>
  : BooleanCountFalse<T>

type InternalBooleanFindIndex<
  T extends readonly boolean[],
  Value extends boolean,
  Index extends readonly unknown[] = [],
> = T extends [infer First extends boolean, ...infer Rest extends boolean[]]
  ? First extends Value
    ? Index["length"]
    : InternalBooleanFindIndex<Rest, Value, [...Index, unknown]>
  : -1
/**
 * @description Find the index of the first occurrence of a boolean value in a tuple.
 *
 * @example
 *   ```
 *   // Expect: 1
 *   type Example1 = BooleanFindIndex<[false, true, false], true>
 *   // Expect: 0
 *   type Example2 = BooleanFindIndex<[false, true, false], false>
 *   // Expect: -1
 *   type Example3 = BooleanFindIndex<[false, false], true>
 *   ```
 */
export type BooleanFindIndex<
  T extends readonly boolean[],
  Value extends boolean,
> = InternalBooleanFindIndex<T, Value>

// ============================================================================
// Manipulation
// ============================================================================

/**
 * @description Logical NOT operation.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = BooleanNot<false>
 *   // Expect: false
 *   type Example2 = BooleanNot<true>
 *   ```
 */
export type BooleanNot<T extends boolean> = T extends true ? false : true

/**
 * @description Logical AND operation.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = BooleanAnd<true, true>
 *   // Expect: false
 *   type Example2 = BooleanAnd<true, false>
 *   // Expect: false
 *   type Example3 = BooleanAnd<false, true>
 *   // Expect: false
 *   type Example4 = BooleanAnd<false, false>
 *   ```
 */
export type BooleanAnd<T extends boolean, U extends boolean> = T extends true
  ? U extends true
    ? true
    : false
  : false

/**
 * @description Logical NAND operation (NOT AND).
 *
 * @example
 *   ```
 *   // Expect: false
 *   type Example1 = BooleanNand<true, true>
 *   // Expect: true
 *   type Example2 = BooleanNand<true, false>
 *   // Expect: true
 *   type Example3 = BooleanNand<false, true>
 *   // Expect: true
 *   type Example4 = BooleanNand<false, false>
 *   ```
 */
export type BooleanNand<T extends boolean, U extends boolean> = T extends true
  ? U extends true
    ? false
    : true
  : true

/**
 * @description Logical OR operation.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = BooleanOr<true, false>
 *   // Expect: false
 *   type Example2 = BooleanOr<false, false>
 *   // Expect: true
 *   type Example3 = BooleanOr<false, true>
 *   // Expect: true
 *   type Example4 = BooleanOr<true, true>
 *   ```
 */
export type BooleanOr<T extends boolean, U extends boolean> = T extends true
  ? true
  : U extends true
    ? true
    : false

/**
 * @description Logical NOR operation (NOT OR).
 *
 * @example
 *   ```
 *   // Expect: false
 *   type Example1 = BooleanNor<true, false>
 *   // Expect: true
 *   type Example2 = BooleanNor<false, false>
 *   // Expect: false
 *   type Example3 = BooleanNor<false, true>
 *   // Expect: false
 *   type Example4 = BooleanNor<true, true>
 *   ```
 */
export type BooleanNor<T extends boolean, U extends boolean> = T extends true
  ? false
  : U extends true
    ? false
    : true

/**
 * @description Logical XOR operation (exclusive OR).
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = BooleanXor<true, false>
 *   // Expect: false
 *   type Example2 = BooleanXor<false, false>
 *   // Expect: true
 *   type Example3 = BooleanXor<false, true>
 *   // Expect: false
 *   type Example4 = BooleanXor<true, true>
 *   ```
 */
export type BooleanXor<T extends boolean, U extends boolean> = T extends true
  ? U extends true
    ? false
    : true
  : U extends true
    ? true
    : false

/**
 * @description Logical XNOR operation (exclusive NOR).
 *
 * @example
 *   ```
 *   // Expect: false
 *   type Example1 = BooleanXnor<true, false>
 *   // Expect: true
 *   type Example2 = BooleanXnor<false, false>
 *   // Expect: false
 *   type Example3 = BooleanXnor<false, true>
 *   // Expect: true
 *   type Example4 = BooleanXnor<true, true>
 *   ```
 */
export type BooleanXnor<T extends boolean, U extends boolean> = T extends true
  ? U extends true
    ? true
    : false
  : U extends true
    ? false
    : true

/**
 * @description Check if all boolean values in a tuple are true.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = BooleanAll<[true, true, true]>
 *   // Expect: false
 *   type Example2 = BooleanAll<[true, false, true]>
 *   // Expect: true
 *   type Example3 = BooleanAll<[]>
 *   ```
 */
export type BooleanAll<T extends readonly boolean[]> = T extends [
  infer First extends boolean,
  ...infer Rest extends boolean[],
]
  ? First extends true
    ? BooleanAll<Rest>
    : false
  : true

/**
 * @description Alias for BooleanAll.
 */
export type BooleanEvery<T extends readonly boolean[]> = BooleanAll<T>

/**
 * @description Check if any boolean value in a tuple is true.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = BooleanAny<[false, true, false]>
 *   // Expect: false
 *   type Example2 = BooleanAny<[false, false, false]>
 *   // Expect: false
 *   type Example3 = BooleanAny<[]>
 *   ```
 */
export type BooleanAny<T extends readonly boolean[]> = T extends [
  infer First extends boolean,
  ...infer Rest extends boolean[],
]
  ? First extends true
    ? true
    : BooleanAny<Rest>
  : false

/**
 * @description Alias for BooleanAny.
 */
export type BooleanSome<T extends readonly boolean[]> = BooleanAny<T>

/**
 * @description Check if all boolean values in a tuple are false.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = BooleanNone<[false, false, false]>
 *   // Expect: false
 *   type Example2 = BooleanNone<[false, true, false]>
 *   // Expect: true
 *   type Example3 = BooleanNone<[]>
 *   ```
 */
export type BooleanNone<T extends readonly boolean[]> = T extends [
  infer First extends boolean,
  ...infer Rest extends boolean[],
]
  ? First extends false
    ? BooleanNone<Rest>
    : false
  : true

/**
 * @description Filter a boolean tuple to keep only specified value (true or false).
 *
 * @example
 *   ```
 *   // Expect: [true, true]
 *   type Example1 = BooleanFilter<[true, false, true, false], true>
 *   // Expect: [false, false]
 *   type Example2 = BooleanFilter<[true, false, true, false], false>
 *   ```
 */
export type BooleanFilter<T extends readonly boolean[], Value extends boolean> = T extends [
  infer First extends boolean,
  ...infer Rest extends boolean[],
]
  ? First extends Value
    ? [First, ...BooleanFilter<Rest, Value>]
    : BooleanFilter<Rest, Value>
  : []

/**
 * @description Map a boolean tuple by applying NOT operation to each element.
 *
 * @example
 *   ```
 *   // Expect: [false, true, false]
 *   type Example1 = BooleanMapNot<[true, false, true]>
 *   ```
 */
export type BooleanMapNot<T extends readonly boolean[]> = T extends [
  infer First extends boolean,
  ...infer Rest extends boolean[],
]
  ? [BooleanNot<First>, ...BooleanMapNot<Rest>]
  : []

type InternalBooleanReverse<
  T extends readonly boolean[],
  Acc extends readonly boolean[] = [],
> = T extends [infer First extends boolean, ...infer Rest extends boolean[]]
  ? InternalBooleanReverse<Rest, [First, ...Acc]>
  : Acc
/**
 * @description Reverse a boolean tuple.
 *
 * @example
 *   ```
 *   // Expect: [false, true, true]
 *   type Example1 = BooleanReverse<[true, true, false]>
 *   ```
 */
export type BooleanReverse<T extends readonly boolean[]> = InternalBooleanReverse<T>

/**
 * @description Partition a boolean tuple into two groups: true values and false values.
 *
 * @example
 *   ```
 *   // Expect: [[true, true], [false, false]]
 *   type Example1 = BooleanPartition<[true, false, true, false]>
 *   ```
 */
export type BooleanPartition<T extends readonly boolean[]> = [
  BooleanFilter<T, true>,
  BooleanFilter<T, false>,
]

/**
 * @description Majority function - returns true if more than half of the values are true.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = BooleanMajority<[true, true, false]>
 *   // Expect: false
 *   type Example2 = BooleanMajority<[true, false, false]>
 *   // Expect: false
 *   type Example3 = BooleanMajority<[true, false]>
 *   ```
 */
export type BooleanMajority<T extends readonly boolean[]> =
  BooleanCountTrue<T> extends infer TrueCount extends number
    ? T["length"] extends infer Total extends number
      ? TrueCount extends 0
        ? false
        : Total extends 0
          ? false
          : // Compare TrueCount * 2 > Total by building arrays
            [
                ...InternalBuildArray<TrueCount>,
                ...InternalBuildArray<TrueCount>,
              ]["length"] extends infer Double extends number
            ? InternalIsGreaterThan<Double, Total> extends true
              ? true
              : false
            : false
      : false
    : false

/**
 * @description Parity function - returns true if an odd number of values are true.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = BooleanParity<[true, false, false]>
 *   // Expect: false
 *   type Example2 = BooleanParity<[true, true, false]>
 *   // Expect: true
 *   type Example3 = BooleanParity<[true]>
 *   ```
 */
export type BooleanParity<T extends readonly boolean[]> = T extends [
  infer First extends boolean,
  ...infer Rest extends boolean[],
]
  ? First extends true
    ? BooleanNot<BooleanParity<Rest>>
    : BooleanParity<Rest>
  : false

/**
 * @description Threshold function - returns true if at least N values are true.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = BooleanThreshold<[true, true, false], 2>
 *   // Expect: false
 *   type Example2 = BooleanThreshold<[true, false, false], 2>
 *   // Expect: true
 *   type Example3 = BooleanThreshold<[true, true, true], 2>
 *   ```
 */
export type BooleanThreshold<T extends readonly boolean[], N extends number> =
  BooleanCountTrue<T> extends infer TrueCount extends number
    ? InternalBuildArray<TrueCount> extends [...InternalBuildArray<N>, ...unknown[]]
      ? true
      : false
    : false

// ============================================================================
// Boolean Conversion
// ============================================================================

/**
 * @description Convert a boolean value to a number literal (true → 1, false → 0).
 *
 * @example
 *   ```
 *   // Expect: 1
 *   type Example1 = BooleanToNumber<true>
 *   // Expect: 0
 *   type Example2 = BooleanToNumber<false>
 *   ```
 */
export type BooleanToNumber<T extends boolean> = T extends true ? 1 : 0

/**
 * @description Convert a boolean value to a string literal.
 *
 * @example
 *   ```
 *   // Expect: 'true'
 *   type Example1 = BooleanToString<true>
 *   // Expect: 'false'
 *   type Example2 = BooleanToString<false>
 *   ```
 */
export type BooleanToString<T extends boolean> = T extends true ? "true" : "false"