import {
  HttpResponse,
  HttpResponseOk,
  RequestError
} from "@gnu-taler/web-util/browser";
import { AmlExchangeBackend } from "../types.js";
// FIX default import https://github.com/microsoft/TypeScript/issues/49189
import _useSWR, { SWRHook, useSWRConfig } from "swr";
import { AccountId } from "../account.js";
import { usePublicBackend } from "./useBackend.js";
const useSWR = _useSWR as unknown as SWRHook;

export function useCaseDetails(
  account: AccountId,
  paytoHash: string,
  signature: string | undefined,
): HttpResponse<
  AmlExchangeBackend.AmlDecisionDetails,
  AmlExchangeBackend.AmlError
> {
  const { fetcher } = usePublicBackend();

  const { data, error } = useSWR<
  HttpResponseOk<AmlExchangeBackend.AmlDecisionDetails>,
  RequestError<AmlExchangeBackend.AmlError>
>(    [
  `aml/${account}/decision/${(paytoHash)}`,
  signature,
],
fetcher, {
    refreshInterval: 0,
    refreshWhenHidden: false,
    revalidateOnFocus: false,
    revalidateOnReconnect: false,
    refreshWhenOffline: false,
    errorRetryCount: 0,
    errorRetryInterval: 1,
    shouldRetryOnError: false,
    keepPreviousData: true,
  });

  if (data) return data;
  if (error) return error.cause;
  return { loading: true };
}

const example1: AmlExchangeBackend.AmlDecisionDetails = {
  aml_history: [
    {
      justification: "Lack of documentation",
      decider_pub: "ASDASDASD",
      decision_time: {
        t_s: Date.now() / 1000,
      },
      new_state: 2,
      new_threshold: "USD:0",
    },
    {
      justification: "Doing a transfer of high amount",
      decider_pub: "ASDASDASD",
      decision_time: {
        t_s: Date.now() / 1000 - 60 * 60 * 24 * 30 * 6,
      },
      new_state: 1,
      new_threshold: "USD:2000",
    },
    {
      justification: "Account is known to the system",
      decider_pub: "ASDASDASD",
      decision_time: {
        t_s: Date.now() / 1000 - 60 * 60 * 24 * 30 * 9,
      },
      new_state: 0,
      new_threshold: "USD:100",
    },
  ],
  kyc_attributes: [
    {
      collection_time: {
        t_s: Date.now() / 1000 - 60 * 60 * 24 * 30 * 8,
      },
      expiration_time: {
        t_s: Date.now() / 1000 - 60 * 60 * 24 * 30 * 4,
      },
      provider_section: "asdasd",
      attributes: {
        name: "Sebastian",
      },
    },
    {
      collection_time: {
        t_s: Date.now() / 1000 - 60 * 60 * 24 * 30 * 5,
      },
      expiration_time: {
        t_s: Date.now() / 1000 - 60 * 60 * 24 * 30 * 2,
      },
      provider_section: "asdasd",
      attributes: {
        creditCard: "12312312312",
      },
    },
  ],
};

export const exampleResponse: HttpResponse<AmlExchangeBackend.AmlDecisionDetails,AmlExchangeBackend.AmlError> = {
  ok: true,
  data: example1,
}


export function useAmlCasesAPI(): AmlCaseAPI {
  const { request } = usePublicBackend();
  const mutateAll = useMatchMutate();

  const updateDecision = async (
    officer: AccountId,
    data: AmlExchangeBackend.AmlDecision,
  ): Promise<HttpResponseOk<void>> => {
    const res = await request<void>(`aml/${officer}/decision`, {
      method: "POST",
      data,
      contentType: "json",
    });
    await mutateAll(/.*aml.*/);
    return res;
  };

  return {
    updateDecision,
  };
}

export interface AmlCaseAPI {
  updateDecision: (
    officer: AccountId,
    data: AmlExchangeBackend.AmlDecision,
  ) => Promise<HttpResponseOk<void>>;
}


function useMatchMutate(): (
  re: RegExp,
  value?: unknown,
) => Promise<any> {
  const { cache, mutate } = useSWRConfig();

  if (!(cache instanceof Map)) {
    throw new Error(
      "matchMutate requires the cache provider to be a Map instance",
    );
  }

  return function matchRegexMutate(re: RegExp, value?: unknown) {
    const allKeys = Array.from(cache.keys());
    const keys = allKeys.filter((key) => re.test(key));
    const mutations = keys.map((key) => {
      return mutate(key, value, true);
    });
    return Promise.all(mutations);
  };
}