import type { LoggerFriendly, LoggerFriendlyOptions } from "#Source/log/logger.ts"
import { Logger } from "#Source/log/logger.ts"

import type { ApiCore } from "./api-core.ts"

export type ApiCoreHandler = (apiCore: ApiCore) => void | Promise<void>
export interface ApiHostStartResult {
  urlList: string[]
}

export interface ApiHostOptions extends LoggerFriendlyOptions {
  port: number
}
export abstract class ApiHost<Server> implements LoggerFriendly {
  protected readonly options: ApiHostOptions

  readonly logger: Logger
  protected server: Server | undefined
  protected startResult: ApiHostStartResult | undefined

  constructor(options: ApiHostOptions) {
    this.options = options

    this.logger = Logger.fromOptions(options).setDefaultName("ApiHost")
    this.server = undefined
    this.startResult = undefined
  }

  getServerOrThrow(): Server {
    if (this.server === undefined) {
      throw new Error("Server is not running.")
    }
    return this.server
  }

  getStartResultOrThrow(): ApiHostStartResult {
    if (this.startResult === undefined) {
      throw new Error("Server is not running.")
    }

    return structuredClone(this.startResult)
  }

  protected setRunningServer(server: Server, startResult: ApiHostStartResult): void {
    this.server = server
    this.startResult = structuredClone(startResult)
  }

  protected clearRunningServer(server?: Server): void {
    if (server !== undefined && this.server !== undefined && this.server !== server) {
      return
    }

    this.server = undefined
    this.startResult = undefined
  }

  isRunning(): boolean {
    if (this.server === undefined) {
      return false
    }
    return true
  }

  abstract attachApiCoreHandler(apiCoreHandler: ApiCoreHandler): void
  abstract detachApiCoreHandler(): void
  abstract start(): Promise<ApiHostStartResult>
  abstract close(): Promise<void>
}

// oxlint-disable-next-line typescript/no-explicit-any
export type AnyApiHost = ApiHost<any>