import type * as Exit from "effect/Exit"
import * as SchemaTransformation from "effect/SchemaTransformation"
import { type GetContextConfig, type RpcContextMap } from "../rpc/RpcContextMap.js"
import * as S from "../Schema.js"
import { AST } from "../Schema.js"
import type { ClientForOptions } from "./clientFor.js"

/**
 * Minimal structural shape for an rpc-client middleware tag.
 * Captures only what `makeRpcClient` and routing/client factory consume from it
 * (no `Default` layer required — that is provided to `makeRouter`).
 */
export interface ClientMiddleware<RequestContextMap extends Record<string, RpcContextMap.Any>> {
  readonly requestContextMap: RequestContextMap
  readonly requestContext: unknown
  readonly provides?: unknown
  readonly requires?: unknown
}

const merge = (a: any, b: Array<any>) =>
  a !== undefined && b.length ? S.Union([a, ...b]) : a !== undefined ? a : b.length ? S.Union(b) : S.Never

/**
 * Whatever the input, we will only decode or encode to void
 */
export const ForceVoid = S
  .declare((_: unknown): _ is unknown => true)
  .pipe(
    S.decodeTo(S.Any, SchemaTransformation.transform<unknown, unknown>({ decode: () => void 0, encode: () => void 0 }))
  )

type SchemaOrFields<T> = T extends S.Top ? T : T extends S.Struct.Fields ? S.Struct<T> : S.Void

type TaggedRequestSchema<Tag extends string, Payload extends S.Struct.Fields> = S.Struct<
  { readonly _tag: S.tag<Tag> } & Payload
>

type QueryOnlyRequests<Resource> = {
  [K in keyof Resource as Resource[K] extends { readonly type: "query" } ? K : never]: Resource[K]
}

type QueryOnlyResources<Resources> = {
  [K in keyof Resources]: QueryOnlyRequests<Resources[K]>
}

type InputFromPayload<Payload extends S.Struct.Fields> = keyof Payload extends never ? void
  : S.Schema.Type<S.Struct<Payload>>

type OutputFromSuccess<Success extends S.Top> = Success extends typeof ForceVoid ? void : S.Schema.Type<Success>

type InvalidationResources = Record<string, Record<string, unknown>>

/**
 * An invalidation instruction returned from `invalidatesQueries`. One of:
 *  - a raw query key (`ReadonlyArray<string>`)
 *  - an RPC handler object (`{ id, options? }`) — query key derived from `id`
 *  - the raw `{ filters, options }` tanstack-query shape
 *
 * `Filters` / `Options` are widened to `Record<string, unknown>` by default so
 * the effect-app core has no dependency on `@tanstack/vue-query`. The vue
 * adapter narrows them via the `InvalidationEntry` alias.
 */
export type InvalidateQueryInstruction<
  Filters = Record<string, unknown>,
  Options = Record<string, unknown>
> =
  | ReadonlyArray<string>
  | {
    readonly id: string
    readonly options?: ClientForOptions
  }
  | {
    readonly filters?: Filters
    readonly options?: Options
  }

export type InvalidationCallback<Resources, Input = unknown, Success = unknown, Failure = unknown> = (
  queryKey: readonly string[],
  resources: QueryOnlyResources<Resources>,
  ...args: [Input] extends [void] ? [exit: Exit.Exit<Success, Failure>]
    : [input: Input, exit: Exit.Exit<Success, Failure>]
) => ReadonlyArray<InvalidateQueryInstruction>

export type InvalidationConfig<Resources, Input = unknown, Success = unknown, Failure = unknown> = {
  readonly invalidatesQueries: InvalidationCallback<Resources, Input, Success, Failure>
  readonly invalidationResources?: Resources
}

type InvalidationConfigForCommand<
  Resources,
  Payload extends S.Struct.Fields,
  Success extends S.Top,
  Error extends S.Top
> = InvalidationConfig<
  Resources,
  InputFromPayload<Payload>,
  OutputFromSuccess<Success>,
  S.Schema.Type<Error>
>

export const configureInvalidation = <Resources>() =>
<Input, Success, Failure>(
  invalidatesQueries: InvalidationCallback<Resources, NoInfer<Input>, NoInfer<Success>, NoInfer<Failure>>
): InvalidationConfig<Resources, Input, Success, Failure> => ({ invalidatesQueries })

export const configureInvalidationCallback = <Resources>() =>
<Input, Success, Failure>(
  invalidatesQueries: InvalidationCallback<Resources, NoInfer<Input>, NoInfer<Success>, NoInfer<Failure>>
): InvalidationCallback<Resources, Input, Success, Failure> => invalidatesQueries

export const configureInvalidationResources = <Resources>() =>
  ({}) as Pick<InvalidationConfig<Resources>, "invalidationResources">

type TaggedRequestForResult<
  Self,
  Tag extends string,
  Payload extends S.Struct.Fields,
  Success extends S.Top,
  Error extends S.Top,
  Config,
  ModuleName extends string,
  Type extends "command" | "query",
  Stream extends boolean,
  Resources = never,
  Final extends S.Top = never,
  Middleware = unknown
> =
  & S.Opaque<Self, S.ExtendedSchemaNoEncoded, TaggedRequestSchema<Tag, Payload>, {}>
  & {
    readonly fields: TaggedRequestSchema<Tag, Payload>["fields"]
    readonly _tag: Tag
    readonly success: Success
    readonly error: Error
    readonly config: Config
    readonly id: `${ModuleName}.${Tag}`
    readonly moduleName: ModuleName
    readonly type: Type
    readonly stream: Stream
    readonly middleware?: Middleware
    readonly "~invalidationResources"?: Resources
  }
  & ([Final] extends [never] ? {} : { readonly final: Final })

export const makeRpcClient = <
  Middleware extends ClientMiddleware<Record<string, RpcContextMap.Any>>,
  GeneralErrors extends S.Top = never
>(middleware: Middleware, generalErrors?: GeneralErrors) => {
  // Long way around Context/C extends etc to support actual jsdoc from passed in RequestConfig etc... (??)
  type ServiceMap = {
    success: S.Top | S.Struct.Fields // SchemaOrFields will make a Schema type out of Struct.Fields
    error: S.Top | S.Struct.Fields // SchemaOrFields will make a Schema type out of Struct.Fields
    final?: S.Top | S.Struct.Fields // optional final-value schema for stream requests
    stream?: boolean // request metadata — stripped from stored config
  }

  type RequestConfig = GetContextConfig<Middleware["requestContextMap"]>

  // Errors raised by RPC middleware (e.g. `NotLoggedInError` from auth) used to
  // be merged into `resource.error` here so they would surface in the wire
  // failure schema. That merging is gone — the canonical source for middleware
  // errors is now the middleware tag attached to the rpc on both server and
  // client (see `ApiClientFactory.makeFor({ middleware })`). `Rpc.exitSchema`
  // unions in `rpc.middlewares[*].error` automatically.
  type MergeError<E> = [GeneralErrors] extends [never] ? SchemaOrFields<E> : S.Union<[SchemaOrFields<E>, GeneralErrors]>
  type ErrorResult<C> = C extends { error: infer E } ? MergeError<E>
    : [GeneralErrors] extends [never] ? typeof S.Never
    : GeneralErrors

  function makeRequestClass<Tag extends string, Fields extends S.Struct.Fields, C extends Partial<ServiceMap>>(
    tag: Tag,
    fields: Fields,
    config?: C
  ) {
    const failureSchema = merge(
      config?.error ? S.isSchema(config.error) ? config.error : S.Struct(config.error) : undefined,
      [generalErrors].filter(Boolean)
    )
    const successSchema = config?.success
      ? S.isSchema(config.success)
        ? AST.isVoid(config.success.ast) ? ForceVoid : config.success
        : S.Struct(config.success)
      : ForceVoid

    const finalConfig = (config as any)?.final
    const finalSchema = finalConfig && S.isSchema(finalConfig) ? finalConfig : undefined

    // Strip stream from the stored config — it's request metadata, not handler config
    const { stream: _stream, ...restConfig } = config ?? ({} as C)

    const RequestClass = S.Opaque()(S.TaggedStruct(tag, fields))
    Object.assign(RequestClass, {
      _tag: tag,
      success: successSchema,
      error: failureSchema,
      ...(finalSchema !== undefined ? { final: finalSchema } : {}),
      config: restConfig
    })

    return RequestClass
  }

  function makeTaggedRequestWithMeta<
    ModuleName extends string,
    Type extends "command" | "query"
  >(
    moduleName: ModuleName,
    type: Type
  ) {
    function TaggedRequestWithMeta<Self, Resources extends InvalidationResources = never>(): {
      // ─── stream: true overloads (must come before non-stream so TypeScript picks them) ───────────
      <
        Tag extends string,
        Payload extends S.Struct.Fields,
        Success extends S.Top | S.Struct.Fields,
        Error extends S.Top | S.Struct.Fields,
        Final extends S.Top | S.Struct.Fields = never,
        C extends RequestConfig & Record<string, any> = RequestConfig & Record<string, any>
      >(
        tag: Tag,
        fields: Payload,
        config:
          & Omit<C, "invalidatesQueries">
          & { stream: true; success: Success; error: Error; final?: Final },
        invalidatesQueries?: InvalidationCallback<
          Resources,
          InputFromPayload<Payload>,
          OutputFromSuccess<SchemaOrFields<Success>>,
          S.Schema.Type<ErrorResult<C & { success: Success; error: Error }>>
        >
      ): TaggedRequestForResult<
        Self,
        Tag,
        Payload,
        SchemaOrFields<Success>,
        ErrorResult<C & { success: Success; error: Error }>,
        Omit<
          & Omit<C, "invalidatesQueries">
          & {
            success: Success
            error: Error
          }
          & Partial<
            InvalidationConfigForCommand<
              Resources,
              Payload,
              SchemaOrFields<Success>,
              ErrorResult<C & { success: Success; error: Error }>
            >
          >,
          "success" | "error" | "stream"
        >,
        ModuleName,
        Type,
        true,
        Resources,
        [Final] extends [never] ? never : SchemaOrFields<Final>,
        Middleware
      >
      <
        Tag extends string,
        Payload extends S.Struct.Fields,
        Success extends S.Top | S.Struct.Fields,
        Final extends S.Top | S.Struct.Fields = never,
        C extends RequestConfig & Record<string, any> & { error?: never } =
          & RequestConfig
          & Record<string, any>
          & { error?: never }
      >(
        tag: Tag,
        fields: Payload,
        config:
          & Omit<C, "invalidatesQueries">
          & { stream: true; success: Success; final?: Final },
        invalidatesQueries?: InvalidationCallback<
          Resources,
          InputFromPayload<Payload>,
          OutputFromSuccess<SchemaOrFields<Success>>,
          S.Schema.Type<ErrorResult<C & { success: Success }>>
        >
      ): TaggedRequestForResult<
        Self,
        Tag,
        Payload,
        SchemaOrFields<Success>,
        ErrorResult<C & { success: Success }>,
        Omit<
          & Omit<C, "invalidatesQueries">
          & { success: Success }
          & Partial<
            InvalidationConfigForCommand<
              Resources,
              Payload,
              SchemaOrFields<Success>,
              ErrorResult<C & { success: Success }>
            >
          >,
          "success" | "error" | "stream"
        >,
        ModuleName,
        Type,
        true,
        Resources,
        [Final] extends [never] ? never : SchemaOrFields<Final>,
        Middleware
      >
      // ─── stream: true without `success` overloads ────────────────────────────────────────────────
      <
        Tag extends string,
        Payload extends S.Struct.Fields,
        Error extends S.Top | S.Struct.Fields,
        C extends RequestConfig & Record<string, any> & { success?: never } =
          & RequestConfig
          & Record<string, any>
          & { success?: never }
      >(
        tag: Tag,
        fields: Payload,
        config:
          & Omit<C, "invalidatesQueries">
          & { stream: true; error: Error },
        invalidatesQueries?: InvalidationCallback<
          Resources,
          InputFromPayload<Payload>,
          void,
          S.Schema.Type<ErrorResult<C & { error: Error }>>
        >
      ): TaggedRequestForResult<
        Self,
        Tag,
        Payload,
        typeof ForceVoid,
        ErrorResult<C & { error: Error }>,
        Omit<
          & Omit<C, "invalidatesQueries">
          & { error: Error }
          & Partial<
            InvalidationConfigForCommand<
              Resources,
              Payload,
              typeof ForceVoid,
              ErrorResult<C & { error: Error }>
            >
          >,
          "success" | "error" | "stream"
        >,
        ModuleName,
        Type,
        true,
        Resources,
        never,
        Middleware
      >
      <
        Tag extends string,
        Payload extends S.Struct.Fields,
        C extends RequestConfig & Record<string, any> & { success?: never; error?: never } =
          & RequestConfig
          & Record<string, any>
          & { success?: never; error?: never }
      >(
        tag: Tag,
        fields: Payload,
        config:
          & Omit<C, "invalidatesQueries">
          & { stream: true },
        invalidatesQueries?: InvalidationCallback<
          Resources,
          InputFromPayload<Payload>,
          void,
          S.Schema.Type<ErrorResult<C>>
        >
      ): TaggedRequestForResult<
        Self,
        Tag,
        Payload,
        typeof ForceVoid,
        ErrorResult<C>,
        Omit<
          & Omit<C, "invalidatesQueries">
          & Partial<InvalidationConfigForCommand<Resources, Payload, typeof ForceVoid, ErrorResult<C>>>,
          "success" | "error" | "stream"
        >,
        ModuleName,
        Type,
        true,
        Resources,
        never,
        Middleware
      >
      // ─── non-stream overloads ────────────────────────────────────────────────────────────────────
      <
        Tag extends string,
        Payload extends S.Struct.Fields,
        Success extends S.Top | S.Struct.Fields,
        Error extends S.Top | S.Struct.Fields,
        Final extends S.Top | S.Struct.Fields = never,
        C extends RequestConfig & Record<string, any> = RequestConfig & Record<string, any>
      >(
        tag: Tag,
        fields: Payload,
        config:
          & Omit<C, "invalidatesQueries">
          & { success: Success; error: Error; final?: Final },
        invalidatesQueries?: InvalidationCallback<
          Resources,
          InputFromPayload<Payload>,
          OutputFromSuccess<SchemaOrFields<Success>>,
          S.Schema.Type<ErrorResult<C & { success: Success; error: Error }>>
        >
      ): TaggedRequestForResult<
        Self,
        Tag,
        Payload,
        SchemaOrFields<Success>,
        ErrorResult<C & { success: Success; error: Error }>,
        Omit<
          & Omit<C, "invalidatesQueries">
          & {
            success: Success
            error: Error
          }
          & Partial<
            InvalidationConfigForCommand<
              Resources,
              Payload,
              SchemaOrFields<Success>,
              ErrorResult<C & { success: Success; error: Error }>
            >
          >,
          "success" | "error" | "stream"
        >,
        ModuleName,
        Type,
        false,
        Resources,
        [Final] extends [never] ? never : SchemaOrFields<Final>,
        Middleware
      >
      <
        Tag extends string,
        Payload extends S.Struct.Fields,
        Success extends S.Top | S.Struct.Fields,
        Final extends S.Top | S.Struct.Fields = never,
        C extends RequestConfig & Record<string, any> & { error?: never } =
          & RequestConfig
          & Record<string, any>
          & {
            error?: never
          }
      >(
        tag: Tag,
        fields: Payload,
        config:
          & Omit<C, "invalidatesQueries">
          & { success: Success; final?: Final },
        invalidatesQueries?: InvalidationCallback<
          Resources,
          InputFromPayload<Payload>,
          OutputFromSuccess<SchemaOrFields<Success>>,
          S.Schema.Type<ErrorResult<C & { success: Success }>>
        >
      ): TaggedRequestForResult<
        Self,
        Tag,
        Payload,
        SchemaOrFields<Success>,
        ErrorResult<C & { success: Success }>,
        Omit<
          & Omit<C, "invalidatesQueries">
          & {
            success: Success
          }
          & Partial<
            InvalidationConfigForCommand<
              Resources,
              Payload,
              SchemaOrFields<Success>,
              ErrorResult<C & { success: Success }>
            >
          >,
          "success" | "error" | "stream"
        >,
        ModuleName,
        Type,
        false,
        Resources,
        [Final] extends [never] ? never : SchemaOrFields<Final>,
        Middleware
      >
      <
        Tag extends string,
        Payload extends S.Struct.Fields,
        Error extends S.Top | S.Struct.Fields,
        C extends RequestConfig & Record<string, any> & { success?: never }
      >(
        tag: Tag,
        fields: Payload,
        config:
          & Omit<C, "invalidatesQueries">
          & { error: Error },
        invalidatesQueries?: InvalidationCallback<
          Resources,
          InputFromPayload<Payload>,
          void,
          S.Schema.Type<ErrorResult<C & { error: Error }>>
        >
      ): TaggedRequestForResult<
        Self,
        Tag,
        Payload,
        typeof ForceVoid,
        ErrorResult<C & { error: Error }>,
        Omit<
          & Omit<C, "invalidatesQueries">
          & {
            error: Error
          }
          & Partial<
            InvalidationConfigForCommand<
              Resources,
              Payload,
              typeof ForceVoid,
              ErrorResult<C & { error: Error }>
            >
          >,
          "success" | "error" | "stream"
        >,
        ModuleName,
        Type,
        false,
        Resources,
        never,
        Middleware
      >
      <
        Tag extends string,
        Payload extends S.Struct.Fields,
        C extends RequestConfig & Record<string, any> & { success?: never; error?: never }
      >(
        tag: Tag,
        fields: Payload,
        config: Omit<C, "invalidatesQueries">,
        invalidatesQueries?: InvalidationCallback<
          Resources,
          InputFromPayload<Payload>,
          void,
          S.Schema.Type<ErrorResult<C>>
        >
      ): TaggedRequestForResult<
        Self,
        Tag,
        Payload,
        typeof ForceVoid,
        ErrorResult<C>,
        Omit<
          & Omit<C, "invalidatesQueries">
          & Partial<InvalidationConfigForCommand<Resources, Payload, typeof ForceVoid, ErrorResult<C>>>,
          "success" | "error" | "stream"
        >,
        ModuleName,
        Type,
        false,
        Resources,
        never,
        Middleware
      >
      <Tag extends string, Payload extends S.Struct.Fields>(
        tag: Tag,
        fields: Payload
      ): TaggedRequestForResult<
        Self,
        Tag,
        Payload,
        typeof ForceVoid,
        ErrorResult<{}>,
        Record<string, never>,
        ModuleName,
        Type,
        false,
        never,
        never,
        Middleware
      >
    } {
      return (<Tag extends string, Fields extends S.Struct.Fields, C extends ServiceMap>(
        tag: Tag,
        fields: Fields,
        config?: C,
        invalidatesQueries?: InvalidationCallback<Resources>
      ) => {
        const isStream = (config as any)?.stream === true
        const requestConfig = invalidatesQueries === undefined ? config : { ...config, invalidatesQueries }
        const cls = makeRequestClass(tag, fields, requestConfig)
        Object.assign(cls, {
          id: `${moduleName}.${tag}`,
          moduleName,
          type,
          stream: isStream,
          middleware
        })
        return cls
      }) as any
    }
    return Object.assign(TaggedRequestWithMeta, { moduleName, type } as const)
  }

  function TaggedRequestFor<ModuleName extends string>(moduleName: ModuleName) {
    const Query = makeTaggedRequestWithMeta(moduleName, "query")
    const Command = makeTaggedRequestWithMeta(moduleName, "command")

    return {
      moduleName,
      /**
       * Create query request classes for this module.
       * Queries read state and should not mutate server state.
       * Pass `stream: true` in the config to produce a Stream of `success` values (QueryStream behaviour).
       */
      Query,
      /**
       * Create command request classes for this module.
       * Commands mutate state and should avoid returning complex read models.
       * Pass `stream: true` in the config to produce a Stream of `success` values (CommandStream behaviour).
       */
      Command
    } as const
  }

  return {
    TaggedRequestFor
  }
}