import formatAxiosErrors, {
  formatMessageErrors,
  formatResponse,
  formatYupErrors,
} from "../utils/formatResponse";
import { AxiosInstance } from "axios";
import keysMock from "../mocks/keys";
import yup from "../config/yup";
import { PAGINATION_LIMIT, KEYTYPES } from "../utils/constants";
import keyTypeValidator from "../utils/keyTypeValidator";

export interface Post {
  key: string | number;
  type: number;
  bank_account: number;
}

export type GetReturn = {
  id: number;
  created_date: string;
} & Post;

export type PostReturn = GetReturn;

export type DeleteReturn = GetReturn;

export type Put = {
  type_origin_account?: string;
};

export type PutReturn = GetReturn;

const PayloadSchema = yup.object().shape({
  type: yup.mixed().oneOf(KEYTYPES).required(),
  key: yup.string().test("key-error", "", function (value: string) {
    const { type } = this.parent;
    const { path, createError } = this;

    const isValid = keyTypeValidator(type, value);

    return (
      isValid ||
      createError({
        path,
        message: `Chave do tipo ${type} não está no formato válido`,
      })
    );
  }),
  bank_account: yup.number().required(),
});

const initializeService = (fetcher: AxiosInstance, isMock: boolean) => {
  const get = async () => {
    // MOCK TRUE
    if (isMock) {
      return formatResponse<any[]>(keysMock, false, "Listado com sucesso");
    }
    // MOCK FALSE
    try {
      const response = await fetcher.request<GetReturn[]>({
        url: `/key/`,
        method: "get",
        params: {
          limit: PAGINATION_LIMIT,
          ordering: "-id",
        },
      });

      if (!response.data) {
        return formatMessageErrors("Erro de api");
      }

      if (
        response.status === 401 ||
        response.status === 400 ||
        response.status === 500
      ) {
        return formatResponse<any>(response.data, true, "Erro na chamada");
      }

      return formatResponse<GetReturn[]>(
        response.data,
        false,
        "Listado com sucesso"
      );
    } catch (err) {
      return formatAxiosErrors(err);
    }
  };

  const post = async (payload: Post) => {
    // YUP VALIDATION
    if (!PayloadSchema.isValidSync(payload)) {
      const validationResult = await PayloadSchema.validate(payload, {
        abortEarly: false,
      }).catch((err) => err);
      return formatYupErrors(validationResult);
    }

    // MOCK TRUE
    if (isMock) {
      return formatResponse<any>(
        {
          ...keysMock[0],
        },
        false,
        "Criado com sucesso"
      );
    }

    // MOCK FALSE
    try {
      const response = await fetcher.request<PostReturn>({
        url: `/key/`,
        method: "post",
        data: payload,
      });

      if (!response.data) {
        return formatMessageErrors("Erro na chamada");
      }

      if (
        response.status === 401 ||
        response.status === 400 ||
        response.status === 500
      ) {
        return formatResponse<PostReturn>(
          response.data,
          true,
          "Erro na chamada"
        );
      }

      return formatResponse<PostReturn>(
        response.data,
        false,
        "Criado com sucesso"
      );
    } catch (err) {
      return formatAxiosErrors(err);
    }
  };

  const put = async (key_id: number | string, payload: any) => {
    /* const PayloadSchemaUpdate = yup.object().shape({
      type_origin_account: yup.mixed().oneOf(ACCOUNTTYPES),
    }); */

    // YUP VALIDATION
    /* if (!PayloadSchemaUpdate.isValidSync(payload)) {
      const validationResult = await PayloadSchemaUpdate.validate(payload, {
        abortEarly: false,
      }).catch((err) => err);
      return formatYupErrors(validationResult);
    } */

    // MOCK TRUE
    if (isMock) {
      return formatResponse<any>(
        {
          ...keysMock[0],
          ...payload,
          id: key_id,
        },
        false,
        "Atualizado com sucesso"
      );
    }

    // MOCK FALSE
    try {
      const response = await fetcher.request<PutReturn>({
        url: `/key/${key_id}/`,
        method: "put",
        data: payload,
      });

      if (!response.data) {
        return formatMessageErrors("Erro na chamada");
      }

      if (
        response.status === 401 ||
        response.status === 400 ||
        response.status === 500
      ) {
        return formatResponse<PutReturn>(
          response.data,
          true,
          "Erro na chamada"
        );
      }

      return formatResponse<PutReturn>(
        response.data,
        false,
        "Criado com sucesso"
      );
    } catch (err) {
      return formatAxiosErrors(err);
    }
  };

  const remove = async (key_id: number | string) => {
    // MOCK TRUE
    if (isMock) {
      return formatResponse<any>(
        {
          ...keysMock[0],
          id: key_id,
        },
        false,
        "Deletado com sucesso"
      );
    }

    // MOCK FALSE
    try {
      const { data } = await fetcher.request<DeleteReturn>({
        url: `/key/${key_id}/`,
        method: "delete",
      });

      if (!data) {
        return formatMessageErrors("Erro na chamada");
      }

      return formatResponse<DeleteReturn>(data, false, "Deletado com sucesso");
    } catch (err) {
      return formatAxiosErrors(err);
    }
  };

  return {
    get,
    post,
    put,
    remove,
  };
};

export default initializeService;