import { generateUuidV4 } from "#Source/identifier/index.ts"
import type { ObjectPrettify } from "#Source/type/index.ts"
import { Ark } from "#Source/validation/index.ts"

import type { ApiCore, ApiCoreStream } from "../api/api-core.ts"
import type { ApiHandlerContext } from "../api/api-handler.ts"
import type { SuccessResultOptions, ErrorResultOptions } from "../api/api-result.ts"
import { SuccessResult, ErrorResult } from "../api/api-result.ts"

export interface JsonSuccessResultOptions<Data> extends SuccessResultOptions<Data> {
  data: Data
}
export class JsonSuccessResult<Data> extends SuccessResult<Data> {
  declare protected options: JsonSuccessResultOptions<Data>

  constructor(options: JsonSuccessResultOptions<Data>) {
    super(options)
    this.logger.setDefaultName("JsonSuccessResult")
  }

  async handle(apiCore: ApiCore): Promise<void> {
    const { data } = this.options

    this.logger.log(`send, ${JSON.stringify(data, null, 2)}`)
    await apiCore.json(data)
    this.logger.log(`end`)
  }
}

export interface CommonSuccessJson<Data> {
  status: "success"
  data: Data
}
export interface CommonJsonSuccessResultOptions<Data> extends Omit<
  JsonSuccessResultOptions<CommonSuccessJson<Data>>,
  "data"
> {
  data: Data
}
export class CommonJsonSuccessResult<Data> extends JsonSuccessResult<CommonSuccessJson<Data>> {
  declare protected options: JsonSuccessResultOptions<CommonSuccessJson<Data>>

  constructor(options: CommonJsonSuccessResultOptions<Data>) {
    super({
      ...options,
      data: {
        status: "success",
        data: options.data,
      },
    })
    this.logger.setDefaultName("CommonJsonSuccessResult")
  }
}
export const commonJsonSuccessResult = <Data>(
  options: CommonJsonSuccessResultOptions<Data>,
): CommonJsonSuccessResult<Data> => {
  return new CommonJsonSuccessResult<Data>(options)
}

export type CommonJsonSuccessResultSchema<Data> = Ark.Type<{
  status: "success"
  data: Data
}>
export type GetDataSchemaFromCommonJsonSuccessResultSchema<Schema extends Ark.Type> =
  Schema extends CommonJsonSuccessResultSchema<infer Data> ? Ark.Type<Data> : never
export type GetDataFromCommonJsonSuccessResultSchema<Schema extends Ark.Type> =
  Schema extends CommonJsonSuccessResultSchema<infer Data> ? Data : never
export const commonJsonSuccessResultSchema = <Data extends Record<string, unknown>>(
  dataSchema: Ark.Type<Data>,
): CommonJsonSuccessResultSchema<Data> => {
  // arktype's instantiated object schema is compatible here but
  // not assignable through its generic facade
  const newResultSchema = Ark.type({
    status: "'success'",
    data: dataSchema,
  }) as CommonJsonSuccessResultSchema<Data>
  return newResultSchema
}

export type StreamWrite = (chunk: Buffer | string, encoding: BufferEncoding) => void | Promise<void>
export type StreamEnd = () => void | Promise<void>
export interface StreamSuccessResultOptions extends SuccessResultOptions<unknown> {
  writeHandler: (write: StreamWrite) => Promise<void>
}
export class StreamSuccessResult extends SuccessResult<unknown> {
  declare protected options: StreamSuccessResultOptions

  protected streamId: string

  constructor(options: StreamSuccessResultOptions) {
    super(options)
    this.logger.setDefaultName("StreamSuccessResult")
    this.streamId = generateUuidV4()
  }

  async handle(apiCore: ApiCore): Promise<void> {
    const apiCoreStream = await apiCore.stream()

    const write = this.wrapWrite(apiCoreStream)
    await this.options.writeHandler(write)
    const end = this.wrapEnd(apiCoreStream)
    await end()
  }

  /**
   * @description 把 write 方法包装一下，以达到注入日志等目的。
   */
  protected wrapWrite(apiCoreStream: ApiCoreStream): StreamWrite {
    return async (chunk, encoding): Promise<void> => {
      this.logger.log(`send, id: ${this.streamId}, data: ${String(chunk)}`)
      await apiCoreStream.write(chunk, encoding)
    }
  }

  /**
   * @description 把 end 方法包装一下，以达到注入日志等目的。
   */
  protected wrapEnd(apiCoreStream: ApiCoreStream): StreamEnd {
    const end = async (): Promise<void> => {
      this.logger.log(`end, id: ${this.streamId}`)
      await apiCoreStream.end()
    }
    return end
  }
}

export type CustomHandler = (apiCore: ApiCore) => Promise<void>
export interface CustomSuccessResultOptions extends SuccessResultOptions<unknown> {
  customHandler: CustomHandler
}
export class CustomSuccessResult extends SuccessResult<unknown> {
  declare protected options: CustomSuccessResultOptions

  constructor(options: CustomSuccessResultOptions) {
    super(options)
    this.logger.setDefaultName("CustomSuccessResult")
  }

  async handle(apiCore: ApiCore): Promise<void> {
    this.logger.log(`send`)
    await this.options.customHandler(apiCore)
    this.logger.log(`end`)
  }
}

// ======================

export interface JsonErrorResultOptions<Data> extends ErrorResultOptions<Data> {
  data: Data
}
export class JsonErrorResult<Data> extends ErrorResult<Data> {
  declare protected options: JsonErrorResultOptions<Data>

  constructor(options: JsonErrorResultOptions<Data>) {
    super(options)
    this.logger.setDefaultName("JsonErrorResult")
  }

  async handle(apiCore: ApiCore): Promise<void> {
    const { data } = this.options

    this.logger.log(`send, ${JSON.stringify(data, null, 2)}`)
    await apiCore.json(data)
    this.logger.log(`end`)
  }
}

export interface CommonErrorJsonData<Reason extends string> {
  reason: Reason
  reasonDetail?: string | undefined
}
export interface CommonErrorJson<Reason extends string> {
  status: "error"
  data: CommonErrorJsonData<Reason>
}
export interface CommonJsonErrorResultOptions<Reason extends string> extends Omit<
  JsonErrorResultOptions<CommonErrorJson<Reason>>,
  "data"
> {
  data: CommonErrorJsonData<Reason>
}
export class CommonJsonErrorResult<const Reason extends string> extends JsonErrorResult<
  CommonErrorJson<Reason>
> {
  declare protected options: JsonErrorResultOptions<CommonErrorJson<Reason>>

  constructor(options: CommonJsonErrorResultOptions<Reason>) {
    super({
      ...options,
      data: {
        status: "error",
        data: options.data,
      },
    })
    this.logger.setDefaultName("CommonJsonErrorResult")
  }
}
export const commonJsonErrorResult = <const Reason extends string>(
  options: CommonJsonErrorResultOptions<Reason>,
): CommonJsonErrorResult<Reason> => {
  return new CommonJsonErrorResult<Reason>(options)
}

export type CommonJsonErrorResultSchema<
  Data extends {
    reason: string
    reasonDetail?: string | undefined
  },
> = Ark.Type<{
  status: "error"
  data: ObjectPrettify<
    Data & {
      reasonDetail?: string | undefined
    }
  >
}>
export type GetDataSchemaFromCommonJsonErrorResultSchema<Schema extends Ark.Type> =
  Schema extends CommonJsonErrorResultSchema<infer Data> ? Ark.Type<Data> : never
export type GetDataFromCommonJsonErrorResultSchema<Schema extends Ark.Type> =
  Schema extends CommonJsonErrorResultSchema<infer Data> ? Data : never
export type GetReasonFromCommonJsonErrorResultSchema<Schema extends Ark.Type> =
  Schema extends CommonJsonErrorResultSchema<infer Data>
    ? Data extends { reason: infer Reason }
      ? Reason
      : never
    : never
export const commonJsonErrorResultSchema = <
  Data extends {
    reason: string
    reasonDetail?: string | undefined
  },
>(
  dataSchema: Ark.Type<Data>,
): CommonJsonErrorResultSchema<Data> => {
  const newResultSchema = Ark.type({
    status: "'error'",
    data: Ark.type.and(
      dataSchema as Ark.Type<{
        reason: string
        reasonDetail?: string | undefined
      }>,
      {
        reasonDetail: Ark.type.string,
      },
    ),
  }) as CommonJsonErrorResultSchema<Data>
  return newResultSchema
}

// ======================

export type ContextWithResultHandler<
  Path extends string,
  Method extends "get" | "post",
  InputQuerySchema extends Ark.Type,
  InputBodySchema extends Ark.Type,
  OutputErrorSchema extends Ark.Type,
  OutputSuccessSchema extends Ark.Type,
> = ObjectPrettify<
  ApiHandlerContext<
    Path,
    Method,
    InputQuerySchema,
    InputBodySchema,
    OutputErrorSchema,
    OutputSuccessSchema
  > & {
    commonJsonErrorResult: (
      options: ObjectPrettify<
        Omit<
          CommonJsonErrorResultOptions<GetReasonFromCommonJsonErrorResultSchema<OutputErrorSchema>>,
          "data"
        > &
          CommonJsonErrorResultOptions<
            GetReasonFromCommonJsonErrorResultSchema<OutputErrorSchema>
          >["data"]
      >,
    ) => CommonJsonErrorResult<GetReasonFromCommonJsonErrorResultSchema<OutputErrorSchema>>
    commonJsonSuccessResult: (
      options: ObjectPrettify<
        Omit<
          CommonJsonSuccessResultOptions<
            GetDataFromCommonJsonSuccessResultSchema<OutputSuccessSchema>
          >,
          "data"
        > &
          CommonJsonSuccessResultOptions<
            GetDataFromCommonJsonSuccessResultSchema<OutputSuccessSchema>
          >["data"]
      >,
    ) => CommonJsonSuccessResult<GetDataFromCommonJsonSuccessResultSchema<OutputSuccessSchema>>
  }
>

export const withResultHandler = <
  Path extends string,
  Method extends "get" | "post",
  InputQuerySchema extends Ark.Type,
  InputBodySchema extends Ark.Type,
  OutputErrorSchema extends Ark.Type,
  OutputSuccessSchema extends Ark.Type,
>(
  context: ApiHandlerContext<
    Path,
    Method,
    InputQuerySchema,
    InputBodySchema,
    OutputErrorSchema,
    OutputSuccessSchema
  >,
): ContextWithResultHandler<
  Path,
  Method,
  InputQuerySchema,
  InputBodySchema,
  OutputErrorSchema,
  OutputSuccessSchema
> => {
  return {
    ...context,
    commonJsonErrorResult: (options) => {
      const { logger, ...rest } = options
      return commonJsonErrorResult({
        logger: logger ?? context.logger.derive(),
        data: rest,
      })
    },
    commonJsonSuccessResult: (options) => {
      const { logger, ...rest } = options
      return commonJsonSuccessResult({
        logger: logger ?? context.logger.derive(),
        data: rest,
      }) as CommonJsonSuccessResult<GetDataFromCommonJsonSuccessResultSchema<OutputSuccessSchema>>
    },
  }
}