import { Either, Left, Right } from "./either.ts"

export class Controller<L, R> {
  static isLeft<L, R>(target: unknown): target is Left<L, R> {
    return Either.isLeft(target)
  }

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

  protected promise: Promise<Either<L, R>>
  protected resolve: (value: Either<L, R>) => void
  protected reject: (value: L) => void

  constructor() {
    let _resolve: (value: Either<L, R>) => void
    let _reject: (value: L) => void
    this.promise = new Promise((resolve, reject) => {
      _resolve = resolve
      _reject = reject
    })
    this.resolve = _resolve!
    this.reject = _reject!
  }

  get value(): Promise<Either<L, R>> {
    return this.promise
  }

  async returnRight(value: R): Promise<Right<L, R>> {
    const right = new Right<L, R>(value)
    this.resolve(right)
    return await Promise.resolve(right)
  }

  async returnLeft(value: L): Promise<Left<L, R>> {
    const left = new Left<L, R>(value)
    this.resolve(left)
    return await Promise.resolve(left)
  }

  // oxlint-disable-next-line require-await
  async throw(value: L): Promise<void> {
    const left = new Left<L, R>(value)
    this.resolve(left)
    // oxlint-disable-next-line typescript/only-throw-error
    throw left
  }
}

type GetLeft<E> = E extends Either<infer L, infer _> ? L : never
type GetRight<E> = E extends Either<infer _, infer R> ? R : never
export const controllerFromEitherType = <E extends Either<unknown, unknown>>(): Controller<
  GetLeft<E>,
  GetRight<E>
> => {
  return new Controller<GetLeft<E>, GetRight<E>>()
}