import {
  ProcedureHookError,
  ProcedureError,
  ProcedureValidationError,
} from './errors.js'
import { ProcedureCodes } from './procedure-codes.js'
import { computeSchema } from './schema/compute-schema.js'
import { Prettify, TJSONSchema, TSchemaLib } from './schema/types.js'

export type TNoContextProvided = unknown

export type TLocalContext = {
  error: (
    code: ProcedureCodes & number,
    message: string,
    meta?: object,
  ) => ProcedureError
}

export type TProcedureRegistration<
  TContext = unknown,
  TExtendedConfig = unknown,
> = {
  name: string
  config: {
    description?: string
    hook?: (ctx: TContext, args?: any) => any
    schema?: {
      args?: TJSONSchema
      data?: TJSONSchema
    }
    validation?: {
      args?: (args: any) => { errors?: any[] }
    }
  } & TExtendedConfig

  handler: (ctx: TContext, args?: any) => Promise<any>
}

export function Procedures<
  TContext = TNoContextProvided,
  TExtendedConfig = unknown,
>(
  /**
   * Optionally provided builder to register Procedures
   */
  builder?: {
    onCreate?: (
      procedure: Prettify<{
        name: string
        handler: (ctx: Prettify<TContext>, args?: any) => Promise<any>
        config: Prettify<
          {
            description?: string
            hook?: (
              ctx: Prettify<TContext & TLocalContext>,
              args?: any,
            ) => Promise<any>
            schema?: {
              args?: TJSONSchema
              data?: TJSONSchema
            }
            validation?: {
              args?: (args: any) => { errors?: any[] }
            }
          } & TExtendedConfig
        >
      }>,
    ) => void
  },
) {
  const procedures: Map<
    string,
    {
      name: string
      config: Prettify<
        {
          description?: string
          hook?: (
            ctx: Prettify<TContext & TLocalContext>,
            args?: any,
          ) => Promise<any>
          schema?: {
            args?: TJSONSchema
            data?: TJSONSchema
          }
          validation?: {
            args?: (args: any) => { errors?: any[] }
          }
        } & TExtendedConfig
      >
      handler: (ctx: Prettify<TContext>, args: any) => Promise<any>
    }
  > = new Map()

  function Create<TName extends string, TArgs, TData, TLocalHook>(
    name: TName,
    config: {
      description?: string
      hook?: (
        ctx: Prettify<TContext & TLocalContext>,
        args: TSchemaLib<TArgs>,
      ) => Promise<Prettify<TLocalHook>>
      schema?: {
        args?: TArgs
        data?: TData
      }
    } & TExtendedConfig,
    handler: (
      ctx: Prettify<TContext & TLocalContext & TLocalHook>,
      args: TSchemaLib<TArgs>,
    ) => Promise<TSchemaLib<TData>>,
  ) {
    const { jsonSchema, validations } = computeSchema(name, config.schema)

    const registeredProcedure = {
      name,
      config: {
        // ctx: config.hook, ??? why was this here
        ...config,
        description: config.description,
        schema: jsonSchema,
        validation: {
          args: validations.args,
        },
      },

      handler: async (ctx: Prettify<TContext>, args: TSchemaLib<TArgs>) => {
        try {
          if (validations?.args) {
            const { errors } = validations.args(args)

            if (errors) {
              throw new ProcedureValidationError(
                name,
                `Validation error for ${name} - ${errors.map((e) => e.message).join(', ')}`,
                errors,
              )
            }
          }

          const localCtx: TLocalContext = {
            error: (
              code: ProcedureCodes & number,
              message: string,
              meta?: object,
            ) => {
              return new ProcedureError(name, code, message, meta)
            },
          }

          let computedLocalHook: TLocalHook = {} as TLocalHook

          if (config.hook) {
            try {
              computedLocalHook = (await config.hook(
                { ...localCtx, ...ctx },
                args,
              )) as TLocalHook
            } catch (error: any) {
              if (error instanceof ProcedureError) {
                throw error
              }

              const err = new ProcedureHookError(
                name,
                `Error in hook for ${name} - ${error?.message}`,
              )
              err.stack = error.stack
              throw err
            }
          }

          return handler(
            {
              ...ctx,
              ...localCtx,
              ...computedLocalHook,
            } as Prettify<TContext & TLocalContext & TLocalHook>,
            args,
          )
        } catch (error: any) {
          if (error instanceof ProcedureHookError) {
            throw error
          } else if (error instanceof ProcedureError) {
            throw error
          } else {
            const err = new ProcedureError(
              name,
              ProcedureCodes.INTERNAL_ERROR,
              `Error in handler for ${name} - ${error?.message}`,
            )
            err.stack = error.stack
            throw err
          }
        }
      },
    }

    procedures.set(name, registeredProcedure)

    if (builder?.onCreate) {
      builder.onCreate(registeredProcedure)
    }

    const info = {
      name,
      ...registeredProcedure.config,
    }

    // return so can be called directly (ie: int/unit tests)
    return {
      [name]: registeredProcedure.handler,
      procedure: registeredProcedure.handler,
      info,
    } as {
      [K in TName]: (
        ctx: Prettify<TContext>,
        args: TSchemaLib<TArgs>,
      ) => Promise<TSchemaLib<TData>>
    } & {
      procedure: (
        ctx: Prettify<TContext>,
        args: TSchemaLib<TArgs>,
      ) => Promise<TSchemaLib<TData>>
      info: {
        name: TName
        description?: string
        hook?: (
          ctx: Prettify<TContext & TLocalContext>,
          args: TSchemaLib<TArgs>,
        ) => Promise<Prettify<TLocalHook>>
        schema: {
          args?: TArgs
          data?: TData
        }
        validation?: {
          args?: (args: any) => { errors?: any[] }
        }
      } & TExtendedConfig
    }
  }

  return {
    getProcedures: () => {
      return procedures
    },

    Create,
  }
}