import { mustFixError } from "#Source/exception/error/must-fix.ts"

import type { AnyEither, GetLeft, GetRight } from "./either.ts"
import { Either } from "./either.ts"

export type EitherSyncGenerator<Yield extends AnyEither, Return extends AnyEither> = Generator<
  Yield,
  Return,
  unknown
>
export type EitherAsyncGenerator<
  Yield extends AnyEither,
  Return extends AnyEither,
> = AsyncGenerator<Yield, Return, unknown>

export type GetEitherGeneratorResult<Yield extends AnyEither, Return extends AnyEither> = Either<
  GetLeft<Yield> | GetLeft<Return>,
  GetRight<Return>
>

export const runSyncGenerator = <Yield extends AnyEither, Return extends AnyEither>(
  generator: EitherSyncGenerator<Yield, Return>,
): GetEitherGeneratorResult<Yield, Return> => {
  let iteratorResult: IteratorResult<Yield, Return>
  try {
    iteratorResult = generator.next()
  } catch (exception) {
    throw mustFixError("Generator threw an exception", { cause: exception })
  }

  if (Either.isEither(iteratorResult.value) === false) {
    throw mustFixError("Generator yielded a non-Either value", { cause: iteratorResult.value })
  }

  if (iteratorResult.done === false) {
    try {
      generator.return?.(undefined as never)
    } catch (exception) {
      throw mustFixError("Generator threw an exception during cleanup", { cause: exception })
    }
  }

  return iteratorResult.value
}

export const runAsyncGenerator = async <Yield extends AnyEither, Return extends AnyEither>(
  generator: EitherAsyncGenerator<Yield, Return>,
): Promise<GetEitherGeneratorResult<Yield, Return>> => {
  let iteratorResult: IteratorResult<Yield, Return>
  try {
    iteratorResult = await generator.next()
  } catch (exception) {
    throw mustFixError("Generator threw an exception", { cause: exception })
  }

  if (Either.isEither(iteratorResult.value) === false) {
    throw mustFixError("Generator yielded a non-Either value", { cause: iteratorResult.value })
  }

  if (iteratorResult.done === false) {
    try {
      await generator.return?.(undefined as never)
    } catch (exception) {
      throw mustFixError("Generator threw an exception during cleanup", { cause: exception })
    }
  }

  return iteratorResult.value
}

export interface GenSync {
  <Yield extends AnyEither, Return extends AnyEither>(
    generatorFunction: () => EitherSyncGenerator<Yield, Return>,
  ): GetEitherGeneratorResult<Yield, Return>
  <Yield extends AnyEither, Return extends AnyEither, This>(
    generatorFunction: (this: This) => EitherSyncGenerator<Yield, Return>,
    thisArg: This,
  ): GetEitherGeneratorResult<Yield, Return>
}
export const genSync: GenSync = <Yield extends AnyEither, Return extends AnyEither, This>(
  generatorFunction:
    | (() => EitherSyncGenerator<Yield, Return>)
    | ((this: This) => EitherSyncGenerator<Yield, Return>),
  thisArg?: This | undefined,
): GetEitherGeneratorResult<Yield, Return> => {
  let generator: EitherSyncGenerator<Yield, Return>
  if (thisArg !== undefined) {
    generator = (generatorFunction as (this: This) => EitherSyncGenerator<Yield, Return>).call(
      thisArg,
    )
  } else {
    generator = (generatorFunction as () => EitherSyncGenerator<Yield, Return>)()
  }
  const result = runSyncGenerator(generator)
  return result
}

export interface GenAsync {
  <Yield extends AnyEither, Return extends AnyEither>(
    generatorFunction: () => EitherAsyncGenerator<Yield, Return>,
  ): Promise<GetEitherGeneratorResult<Yield, Return>>
  <Yield extends AnyEither, Return extends AnyEither, This>(
    generatorFunction: (this: This) => EitherAsyncGenerator<Yield, Return>,
    thisArg: This,
  ): Promise<GetEitherGeneratorResult<Yield, Return>>
}
export const genAsync: GenAsync = async <Yield extends AnyEither, Return extends AnyEither, This>(
  generatorFunction:
    | (() => EitherAsyncGenerator<Yield, Return>)
    | ((this: This) => EitherAsyncGenerator<Yield, Return>),
  thisArg?: This | undefined,
): Promise<GetEitherGeneratorResult<Yield, Return>> => {
  let generator: EitherAsyncGenerator<Yield, Return>
  if (thisArg !== undefined) {
    generator = (generatorFunction as (this: This) => EitherAsyncGenerator<Yield, Return>).call(
      thisArg,
    )
  } else {
    generator = (generatorFunction as () => EitherAsyncGenerator<Yield, Return>)()
  }
  const result = await runAsyncGenerator(generator)
  return result
}

export interface Gen extends GenSync, GenAsync {}
export const gen = (<Yield extends AnyEither, Return extends AnyEither, This>(
  generatorFunction:
    | (() => EitherSyncGenerator<Yield, Return>)
    | ((thisArg: This) => EitherSyncGenerator<Yield, Return>)
    | (() => EitherAsyncGenerator<Yield, Return>)
    | ((thisArg: This) => EitherAsyncGenerator<Yield, Return>),
  thisArg?: This | undefined,
): GetEitherGeneratorResult<Yield, Return> | Promise<GetEitherGeneratorResult<Yield, Return>> => {
  let generator: EitherSyncGenerator<Yield, Return> | EitherAsyncGenerator<Yield, Return>
  if (thisArg !== undefined) {
    generator = (
      generatorFunction as (
        this: This,
      ) => EitherSyncGenerator<Yield, Return> | EitherAsyncGenerator<Yield, Return>
    ).call(thisArg)
  } else {
    generator = (
      generatorFunction as () =>
        | EitherSyncGenerator<Yield, Return>
        | EitherAsyncGenerator<Yield, Return>
    )()
  }
  if (Symbol.asyncIterator in generator) {
    return runAsyncGenerator(generator)
  }
  if (Symbol.iterator in generator) {
    return runSyncGenerator(generator)
  }
  throw new TypeError("Invalid generator function")
}) as Gen

export const genAwait = async function* <Left, Right>(
  promise: Promise<Either<Left, Right>>,
): AsyncGenerator<Either<Left, Right>, Right, unknown> {
  const either = await promise
  const result = yield* either
  return result
}