import type {
  Alova,
  AlovaDefaultCacheAdapter,
  AlovaGenerics,
  AlovaGlobalCacheAdapter,
  AlovaMethodCommonConfig,
  AlovaMethodCreateConfig,
  AlovaOptions,
  AlovaRequestAdapter,
  Method,
  RequestBody,
  RespondedAlovaGenerics,
  RespondedHandler,
  RespondedHandlerRecord,
  ResponseCompleteHandler,
  ResponseErrorHandler,
  StatesExport,
  StatesHook,
} from 'alova';
import type { TokenAuthenticationResult } from 'alova/client';
import type { FetchRequestInit } from 'alova/fetch';
import type { VueHookExportType } from 'alova/vue';

export type AlovaFetchRequestGenerics<
  Responded = unknown,
  Transformed = unknown,
> = AlovaGenerics<
  Responded,
  Transformed,
  FetchRequestInit,
  Response,
  Headers,
  AlovaDefaultCacheAdapter,
  AlovaDefaultCacheAdapter,
  VueHookExportType<unknown>
>;

export type RequestedHandler<AG extends AlovaGenerics> = (
  method: Method<AG>,
) => Promise<void> | void;

/* eslint-disable perfectionist/sort-interfaces */
export interface AlovaClient<AG extends AlovaGenerics> extends Alova<AG> {
  request<Responded = unknown, Transformed = unknown>(
    config: AlovaMethodCommonConfig<AG, Responded, Transformed>,
  ): Method<RespondedAlovaGenerics<AG, Responded, Transformed>>;

  get<Responded = unknown, Transformed = unknown>(
    url: string,
    config?: AlovaMethodCreateConfig<AG, Responded, Transformed>,
  ): Method<RespondedAlovaGenerics<AG, Responded, Transformed>>;

  post<Responded = unknown, Transformed = unknown>(
    url: string,
    data?: RequestBody,
    config?: AlovaMethodCreateConfig<AG, Responded, Transformed>,
  ): Method<RespondedAlovaGenerics<AG, Responded, Transformed>>;

  put<Responded = unknown, Transformed = unknown>(
    url: string,
    data?: RequestBody,
    config?: AlovaMethodCreateConfig<AG, Responded, Transformed>,
  ): Method<RespondedAlovaGenerics<AG, Responded, Transformed>>;

  delete<Responded = unknown, Transformed = unknown>(
    url: string,
    data?: RequestBody,
    config?: AlovaMethodCreateConfig<AG, Responded, Transformed>,
  ): Method<RespondedAlovaGenerics<AG, Responded, Transformed>>;

  head<Responded = unknown, Transformed = unknown>(
    url: string,
    config?: AlovaMethodCreateConfig<AG, Responded, Transformed>,
  ): Method<RespondedAlovaGenerics<AG, Responded, Transformed>>;

  _options<Responded = unknown, Transformed = unknown>(
    url: string,
    config?: AlovaMethodCreateConfig<AG, Responded, Transformed>,
  ): Method<RespondedAlovaGenerics<AG, Responded, Transformed>>;

  patch<Responded = unknown, Transformed = unknown>(
    url: string,
    data?: RequestBody,
    config?: AlovaMethodCreateConfig<AG, Responded, Transformed>,
  ): Method<RespondedAlovaGenerics<AG, Responded, Transformed>>;

  interceptor(type: 'request', fn: RequestedHandler<AG>): () => void;
  interceptor(type: 'success', fn: RespondedHandler<AG>): () => void;
  interceptor(type: 'error', fn: ResponseErrorHandler<AG>): () => void;
  interceptor(type: 'complete', fn: ResponseCompleteHandler<AG>): () => void;
}

export interface ResponseBodyData<D = unknown> {
  code: number;
  data?: D;
  message?: string;
}

export type SimpleAlovaOptions<
  AG extends AlovaGenerics = AlovaFetchRequestGenerics,
> = Pick<AlovaOptions<any>, 'baseURL' | 'id'> & {
  interceptor?: RespondedHandlerRecord<AG>;
  tokenStore?: {
    accessToken?: null | string;
    loginExpired?: boolean;
    refreshToken?: null | string;
  };

  transform?: <Responded = unknown, Transformed = unknown>(
    data: Record<string, any>,
    method: Method<RespondedAlovaGenerics<AG, Responded, Transformed>>,
  ) => ResponseBodyData<Responded>;
};

export interface CreateAlovaClient {
  <
    RequestConfig,
    Response,
    ResponseHeader,
    L1Cache extends AlovaGlobalCacheAdapter = AlovaDefaultCacheAdapter,
    L2Cache extends AlovaGlobalCacheAdapter = AlovaDefaultCacheAdapter,
    SE extends StatesExport<any> = StatesExport<any>,
  >(
    options: Partial<
      Omit<
        AlovaOptions<
          AlovaGenerics<
            any,
            any,
            RequestConfig,
            Response,
            ResponseHeader,
            L1Cache,
            L2Cache,
            SE
          >
        >,
        'beforeRequest' | 'responded'
      > & {
        tokenAuthentication: TokenAuthenticationResult<
          StatesHook<SE>,
          AlovaRequestAdapter<RequestConfig, Response, ResponseHeader>
        >;
      }
    >,
  ): AlovaClient<
    AlovaGenerics<
      any,
      any,
      RequestConfig,
      Response,
      ResponseHeader,
      L1Cache,
      L2Cache,
      SE
    >
  >;
}