// oxlint-disable-next-line typescript/no-explicit-any
export type AnyEither = Either<any, any>
export type GetLeft<T> = T extends Either<infer Left, unknown> ? Left : never
export type GetRight<T> = T extends Either<unknown, infer Right> ? Right : never
export type GetRights<Eithers> = Eithers extends []
  ? []
  : Eithers extends [infer Item, ...infer xs]
    ? Item extends Either<unknown, infer Right>
      ? [Right, ...GetRights<xs>]
      : never
    : never
export type GetLefts<Eithers> = Eithers extends []
  ? []
  : Eithers extends [infer Item, ...infer xs]
    ? Item extends Either<infer Left, unknown>
      ? [Left, ...GetLefts<xs>]
      : never
    : never
type TupleToUnion<Tuple> = Tuple extends unknown[] ? Tuple[number] : never

export abstract class Either<L, R> {
  static isEither<L, R>(target: unknown): target is Either<L, R> {
    return target instanceof Either
  }

  static isLeft<L, R>(target: unknown): target is Left<L, R> {
    return target instanceof Left
  }

  static isRight<L, R>(target: unknown): target is Right<L, R> {
    return target instanceof Right
  }

  static left<L>(value: L): Either<L, never>
  static left<L, R>(value: L): Either<L, R>
  static left<L, R>(value: L): Either<L, R> {
    return new Left(value)
  }

  static right<R>(value: R): Either<never, R>
  static right<L, R>(value: R): Either<L, R>
  static right<L, R>(value: R): Either<L, R> {
    return new Right(value)
  }

  static pure<R>(value: R): Either<never, R>
  static pure<L, R>(value: R): Either<L, R>
  static pure<L, R>(value: R): Either<L, R> {
    return new Right(value)
  }

  static lift<NewR, Eithers extends AnyEither[]>(
    eithers: [...Eithers],
    map: (eitherRights: GetRights<Eithers>) => NewR,
  ): Either<TupleToUnion<GetLefts<Eithers>>, NewR> {
    const firstLeft = eithers.find((either) => either.isLeft())
    if (firstLeft !== undefined) {
      return firstLeft as Either<TupleToUnion<GetLefts<Eithers>>, NewR>
    }
    const rights = eithers.map((either) => {
      // oxlint-disable-next-line typescript/no-unsafe-return
      return either.assertRight().getRight()
    }) as GetRights<Eithers>
    const newRightValue = map(rights)
    return Either.pure(newRightValue)
  }

  abstract getValue(): L | R

  abstract getLeft(): L
  abstract getRight(): R
  abstract getRightOr(or: R): R

  abstract isLeft(): this is Left<L, R>
  abstract isRight(): this is Right<L, R>

  abstract assertLeft(): Left<L, R>
  abstract assertRight(): Right<L, R>

  abstract tap(effects: {
    left?: ((value: L) => void) | undefined
    right?: ((value: R) => void) | undefined
  }): Either<L, R>
  abstract tapLeft(effect: (value: L) => void): Either<L, R>
  abstract tapRight(effect: (value: R) => void): Either<L, R>

  abstract mapLeft<NewL>(map: (value: L) => NewL): Either<NewL, R>
  abstract mapRight<NewR>(map: (value: R) => NewR): Either<L, NewR>
  abstract bimap<NewL, NewR>(mappers: {
    left: (value: L) => NewL
    right: (value: R) => NewR
  }): Either<NewL, NewR>
  abstract bind<NewL, NewR>(bind: (value: R) => Either<NewL, NewR>): Either<L | NewL, NewR>
  abstract bindAsync<NewL, NewR>(
    bind: (value: R) => Promise<Either<NewL, NewR>>,
  ): Promise<Either<L | NewL, NewR>>

  abstract fold<X>(matchers: { left: (value: L) => X; right: (value: R) => X }): X
  abstract foldAsync<X>(matchers: {
    left: (value: L) => Promise<X>
    right: (value: R) => Promise<X>
  }): Promise<X>

  abstract match<LX, RX>(matchers: { left: (value: L) => LX; right: (value: R) => RX }): LX | RX
  abstract matchAsync<LX, RX>(matchers: {
    left: (value: L) => Promise<LX>
    right: (value: R) => Promise<RX>
  }): Promise<LX | RX>

  abstract mplus(either: Either<L, R>): Either<L, R>

  abstract [Symbol.iterator](): Generator<Either<L, R>, R, R>
  // Async consumers can fall back to Symbol.iterator, but we still expose the
  // same semantics explicitly so Either remains self-descriptive as an async iterable.
  abstract [Symbol.asyncIterator](): AsyncGenerator<Either<L, R>, R, unknown>
}

export class Left<L, R> extends Either<L, R> {
  protected value: L

  constructor(value: L) {
    super()
    this.value = value
  }

  getValue(): L | R {
    return this.value
  }

  getLeft(): L {
    return this.value
  }

  getRight(): R {
    throw new Error("Cannot get right value from Left")
  }

  getRightOr(or: R): R {
    return or
  }

  isLeft(): this is Left<L, R> {
    return true
  }

  isRight(): this is Right<L, R> {
    return false
  }

  assertLeft(): this {
    return this
  }

  assertRight(): Right<L, R> {
    throw new Error("Assert failed")
  }

  tap(effects: {
    left?: ((value: L) => void) | undefined
    right?: ((value: R) => void) | undefined
  }): Either<L, R> {
    if (effects.left !== undefined) {
      effects.left(this.value)
    }
    return this
  }

  tapLeft(effect: (value: L) => void): Either<L, R> {
    effect(this.value)
    return this
  }

  tapRight(_effect: (value: R) => void): Either<L, R> {
    return this
  }

  mapLeft<NewL>(map: (value: L) => NewL): Either<NewL, R> {
    return new Left(map(this.value))
  }

  mapRight<NewR>(_map: (value: R) => NewR): Either<L, NewR> {
    return new Left(this.value)
  }

  bimap<NewL, NewR>(mappers: {
    left: (value: L) => NewL
    right: (value: R) => NewR
  }): Either<NewL, NewR> {
    return new Left(mappers.left(this.value))
  }

  bind<NewL, NewR>(_map: (value: R) => Either<NewL, NewR>): Either<L | NewL, NewR> {
    return new Left(this.value) as Either<L | NewL, NewR>
  }

  async bindAsync<NewL, NewR>(
    _bind: (value: R) => Promise<Either<NewL, NewR>>,
  ): Promise<Either<L | NewL, NewR>> {
    return await Promise.resolve(new Left(this.value) as Either<L | NewL, NewR>)
  }

  fold<X>(matchers: { left: (value: L) => X; right: (value: R) => X }): X {
    return matchers.left(this.value)
  }

  async foldAsync<X>(matchers: {
    left: (value: L) => Promise<X>
    right: (value: R) => Promise<X>
  }): Promise<X> {
    return await matchers.left(this.value)
  }

  match<LX, RX>(matchers: { left: (value: L) => LX; right: (value: R) => RX }): LX | RX {
    return matchers.left(this.value)
  }

  async matchAsync<LX, RX>(matchers: {
    left: (value: L) => Promise<LX>
    right: (value: R) => Promise<RX>
  }): Promise<LX | RX> {
    return await matchers.left(this.value)
  }

  mplus(either: Either<L, R>): Either<L, R> {
    return either
  }

  *[Symbol.iterator](): Generator<Either<L, R>, R, R> {
    yield this
    throw new Error("Cannot extract right value from Left")
  }

  // This mirrors the sync iterator exactly; it is explicit protocol support,
  // not a requirement for async yield* fallback.
  async *[Symbol.asyncIterator](): AsyncGenerator<Either<L, R>, R, unknown> {
    await Promise.resolve()
    yield this
    throw new Error("Cannot extract right value from Left")
  }
}

export class Right<L, R> extends Either<L, R> {
  protected value: R

  constructor(value: R) {
    super()
    this.value = value
  }

  getValue(): L | R {
    return this.value
  }

  getLeft(): L {
    throw new Error("Cannot get left value from Right")
  }

  getRight(): R {
    return this.value
  }

  getRightOr(_or: R): R {
    return this.value
  }

  isLeft(): this is Left<L, R> {
    return false
  }

  isRight(): this is Right<L, R> {
    return true
  }

  assertLeft(): Left<L, R> {
    throw new Error("Assert failed")
  }

  assertRight(): this {
    return this
  }

  tap(effects: {
    left?: ((value: L) => void) | undefined
    right?: ((value: R) => void) | undefined
  }): Either<L, R> {
    if (effects.right !== undefined) {
      effects.right(this.value)
    }
    return this
  }

  tapLeft(_effect: (value: L) => void): Either<L, R> {
    return this
  }

  tapRight(effect: (value: R) => void): Either<L, R> {
    effect(this.value)
    return this
  }

  mapLeft<NewL>(_map: (value: L) => NewL): Either<NewL, R> {
    return new Right(this.value)
  }

  mapRight<NewR>(map: (value: R) => NewR): Either<L, NewR> {
    return new Right(map(this.value))
  }

  bimap<NewL, NewR>(mappers: {
    left: (value: L) => NewL
    right: (value: R) => NewR
  }): Either<NewL, NewR> {
    return new Right(mappers.right(this.value))
  }

  bind<NewL, NewR>(map: (value: R) => Either<NewL, NewR>): Either<L | NewL, NewR> {
    return map(this.value) as Either<L | NewL, NewR>
  }

  async bindAsync<NewL, NewR>(
    bind: (value: R) => Promise<Either<NewL, NewR>>,
  ): Promise<Either<L | NewL, NewR>> {
    return (await bind(this.value)) as Either<L | NewL, NewR>
  }

  fold<X>(matchers: { left: (value: L) => X; right: (value: R) => X }): X {
    return matchers.right(this.value)
  }

  async foldAsync<X>(matchers: {
    left: (value: L) => Promise<X>
    right: (value: R) => Promise<X>
  }): Promise<X> {
    return await matchers.right(this.value)
  }

  match<LX, RX>(matchers: { left: (value: L) => LX; right: (value: R) => RX }): LX | RX {
    return matchers.right(this.value)
  }

  async matchAsync<LX, RX>(matchers: {
    left: (value: L) => Promise<LX>
    right: (value: R) => Promise<RX>
  }): Promise<LX | RX> {
    return await matchers.right(this.value)
  }

  mplus(_either: Either<L, R>): Either<L, R> {
    return this
  }

  *[Symbol.iterator](): Generator<Either<L, R>, R, R> {
    return this.value
  }

  // This mirrors the sync iterator exactly; async consumers could fall back to
  // Symbol.iterator, but the explicit async form keeps the contract obvious.
  async *[Symbol.asyncIterator](): AsyncGenerator<Either<L, R>, R, unknown> {
    await Promise.resolve()
    return this.value
  }
}

export const isEither = <L, R>(target: unknown): target is Either<L, R> => {
  return Either.isEither(target)
}

export const isLeft = <L, R>(target: unknown): target is Left<L, R> => {
  return Either.isLeft(target)
}

export const isRight = <L, R>(target: unknown): target is Right<L, R> => {
  return Either.isRight(target)
}

type LeftFunction = {
  <L>(value: L): Either<L, never>
  <L, R>(value: L): Either<L, R>
}
export const left = (<L, R>(value: L): Either<L, R> => {
  return Either.left<L, R>(value)
}) as LeftFunction

type RightFunction = {
  <R>(value: R): Either<never, R>
  <L, R>(value: R): Either<L, R>
}
export const right = (<L, R>(value: R): Either<L, R> => {
  return Either.right<L, R>(value)
}) as RightFunction

export type TupleOfEither<Left, Right> = [undefined, Right] | [Left, undefined]
export const eitherToTuple = <L, R>(either: Either<L, R>): TupleOfEither<L, R> => {
  const left = either.isLeft() ? either.getLeft() : undefined
  const right = either.isRight() ? either.getRight() : undefined
  return [left, right] as TupleOfEither<L, R>
}