import type { LoggerFriendly, LoggerFriendlyOptions } from "#Source/log/index.ts"
import { Logger } from "#Source/log/index.ts"
import type {
  Controller,
  Either,
  EitherAsyncGenerator,
  EitherSyncGenerator,
  GetEitherGeneratorResult,
  TupleOfEither,
} from "#Source/result/index.ts"
import { controllerFromEitherType, eitherToTuple, gen } from "#Source/result/index.ts"
import type { ObjectPrettify } from "#Source/type/index.ts"

export type ServiceRunContext<Options = unknown> = ObjectPrettify<LoggerFriendlyOptions & Options>
export type ServiceRunResult<Left, Right> = Either<Left, Right>

export interface ServiceOptions extends LoggerFriendlyOptions {}
/**
 * @description 通过继承此基类实现业务逻辑，与使用函数实现业务逻辑相比，具有以下优势：
 * 1. 依赖管理：统一注入所有通用依赖，如 logger 等，避免在每个函数实现中重复声明。
 * 2. 暂时想不到了。
 */
export abstract class Service<
  Context extends ServiceRunContext,
  Left,
  Right,
> implements LoggerFriendly {
  readonly logger: Logger
  protected controller: Controller<Left, Right>

  constructor(options: ServiceOptions) {
    this.logger = Logger.fromOptions(options).setDefaultName("Service")
    this.controller = controllerFromEitherType<Either<Left, Right>>()
  }

  protected gen<Yield extends Either<Left, unknown>, Return extends Either<Left, Right>>(
    generatorFunction: (this: this) => EitherSyncGenerator<Yield, Return>,
  ): GetEitherGeneratorResult<Yield, Return>
  protected gen<Yield extends Either<Left, unknown>, Return extends Either<Left, Right>>(
    generatorFunction: (this: this) => EitherAsyncGenerator<Yield, Return>,
  ): Promise<GetEitherGeneratorResult<Yield, Return>>
  protected gen<Yield extends Either<Left, unknown>, Return extends Either<Left, Right>>(
    generatorFunction:
      | ((this: this) => EitherSyncGenerator<Yield, Return>)
      | ((this: this) => EitherAsyncGenerator<Yield, Return>),
  ): GetEitherGeneratorResult<Yield, Return> | Promise<GetEitherGeneratorResult<Yield, Return>> {
    return gen(generatorFunction as never, this)
  }

  protected loggerForRun(context: Context): Logger {
    const { logger } = context
    if (logger !== undefined) {
      return logger
    } else {
      return this.logger.derive().setDefaultName("Run")
    }
  }

  protected abstract run(context: Context): Promise<ServiceRunResult<Left, Right>>

  async runToEither(context: Context): Promise<Either<Left, Right>> {
    return await this.run(context)
  }

  async runToTuple(context: Context): Promise<TupleOfEither<Left, Right>> {
    const result = await this.run(context)
    return eitherToTuple(result)
  }
}

export const isService = <Context extends ServiceRunContext, Left, Right>(
  target: unknown,
): target is Service<Context, Left, Right> => {
  return target instanceof Service
}

// eslint-disable-next-line @typescript-eslint/no-explicit-any
export type AnyServiceInstance = Service<any, any, any>
// eslint-disable-next-line @typescript-eslint/no-explicit-any
export type AnyServiceConstructor = new (...args: any[]) => AnyServiceInstance
export type GetServiceInstance<T extends AnyServiceConstructor> = T extends new (
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  ...args: any[]
) => infer Instance
  ? Instance
  : never
export type GetServiceOptions<T extends AnyServiceConstructor> = T extends new (
  options: infer Options,
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  ...args: any[]
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
) => any
  ? Options
  : never
export type GetServiceRunContext<T extends AnyServiceConstructor> =
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  GetServiceInstance<T> extends Service<infer Options, any, any> ? Options : never
export type GetServiceRunLeft<T extends AnyServiceConstructor> =
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  GetServiceInstance<T> extends Service<any, infer Left, any> ? Left : never
export type GetServiceRunRight<T extends AnyServiceConstructor> =
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  GetServiceInstance<T> extends Service<any, any, infer Right> ? Right : never

export const createService = <ServiceConstructor extends AnyServiceConstructor>(
  ServiceConstructor: ServiceConstructor,
  constructorOptions: GetServiceOptions<ServiceConstructor>,
): GetServiceInstance<ServiceConstructor> => {
  return new ServiceConstructor(constructorOptions) as GetServiceInstance<ServiceConstructor>
}

export type RunToEither<ServiceConstructor extends AnyServiceConstructor> = (
  runContext: ServiceRunContext<GetServiceRunContext<ServiceConstructor>>,
) => Promise<Either<GetServiceRunLeft<ServiceConstructor>, GetServiceRunRight<ServiceConstructor>>>
export const createServiceRunToEither = <ServiceConstructor extends AnyServiceConstructor>(
  ServiceConstructor: ServiceConstructor,
  constructorOptions: GetServiceOptions<ServiceConstructor>,
): RunToEither<ServiceConstructor> => {
  const service = createService(ServiceConstructor, constructorOptions)
  const run: RunToEither<ServiceConstructor> = async (runContext) => {
    const result = await service.runToEither(runContext)
    return result
  }
  return run
}

export type RunToTuple<ServiceConstructor extends AnyServiceConstructor> = (
  runContext: ServiceRunContext<GetServiceRunContext<ServiceConstructor>>,
) => Promise<
  TupleOfEither<GetServiceRunLeft<ServiceConstructor>, GetServiceRunRight<ServiceConstructor>>
>
export const createServiceRunToTuple = <ServiceConstructor extends AnyServiceConstructor>(
  ServiceConstructor: ServiceConstructor,
  constructorOptions: GetServiceOptions<ServiceConstructor>,
): RunToTuple<ServiceConstructor> => {
  const service = createService(ServiceConstructor, constructorOptions)
  const run: RunToTuple<ServiceConstructor> = async (runContext) => {
    const result = await service.runToTuple(runContext)
    return result
  }
  return run
}

export const createServiceAndRunToEither = async <ServiceConstructor extends AnyServiceConstructor>(
  ServiceConstructor: ServiceConstructor,
  constructorOptions: GetServiceOptions<ServiceConstructor>,
  runContext: ServiceRunContext<GetServiceRunContext<ServiceConstructor>>,
): Promise<
  Either<GetServiceRunLeft<ServiceConstructor>, GetServiceRunRight<ServiceConstructor>>
> => {
  const service = createService(ServiceConstructor, constructorOptions)
  const result = await service.runToEither(runContext)
  return result
}

export const createServiceAndRunToTuple = async <ServiceConstructor extends AnyServiceConstructor>(
  ServiceConstructor: ServiceConstructor,
  constructorOptions: GetServiceOptions<ServiceConstructor>,
  runContext: ServiceRunContext<GetServiceRunContext<ServiceConstructor>>,
): Promise<
  TupleOfEither<GetServiceRunLeft<ServiceConstructor>, GetServiceRunRight<ServiceConstructor>>
> => {
  const service = createService(ServiceConstructor, constructorOptions)
  const result = await service.runToTuple(runContext)
  return result
}