// @ts-nocheck
/**
 *  This is an auto generate file from fireback project.
 *  You can use this in order to communicate in backend, it gives you available actions,
 *  and their types
 *  Module: workspaces
 */

import { FormikHelpers } from "formik";
import React, { useCallback } from "react";
import {
  useMutation,
  useQuery,
  useQueryClient,
  QueryClient,
} from "react-query";
import { WorkspaceActions } from "./workspace-actions";
import * as workspaces from "./index";
import {
  execApiFn,
  RemoteRequestOption,
  IDeleteResponse,
  core,
  IResponse,
  ExecApi,
  mutationErrorsToFormik,
  IResponseList,
} from "../../core/http-tools";
/**
 * Gives you formik forms, all mutations, submit actions, and error handling,
 * and provides internal store for all changes happens through this
 * for modules
 */
export function useWorkspaces(
  { options, query, execFn }: { options: RemoteRequestOption; query?: any },
  queryClient: QueryClient,
  execFn?: ExecApi
) {
  const caller = execFn
    ? WorkspaceActions.fnExec(execFn(options))
    : WorkspaceActions.fn(options);
  const Q = () =>
    caller
      .startIndex(query?.startIndex)
      .deep(query?.deep)
      .itemsPerPage(query?.itemsPerPage)
      .query(query?.query);

  // post workspace/invite

  const mutationPostWorkspaceInvite = useMutation<
    IResponse<workspaces.WorkspaceInviteEntity>,
    IResponse<workspaces.WorkspaceInviteEntity>,
    workspaces.WorkspaceInviteEntity
  >((entity) => {
    return Q().postWorkspaceInvite(entity);
  });

  // Only entities are having a store in front-end

  const fnPostWorkspaceInviteUpdater = (
    data: IResponseList<workspaces.WorkspaceInviteEntity> | undefined,
    item: IResponse<workspaces.WorkspaceInviteEntity>
  ) => {
    return [];

    if (!data) {
      return {
        data: { items: [] },
      };
    }

    if (data?.data?.items && item.data) {
      data.data.items = data.data.items.map((t) => {
        if (
          item.data !== undefined &&
          WorkspaceActions.isWorkspaceInviteEntityEqual(t, item.data)
        ) {
          return item.data;
        }

        return t;
      });
    } else if (data?.data && item.data) {
      data.data.items = [item.data, ...(data?.data?.items || [])];
    }

    return data;
  };

  const submitPostWorkspaceInvite = (
    values: workspaces.WorkspaceInviteEntity,
    formikProps?: FormikHelpers<workspaces.WorkspaceInviteEntity>
  ): Promise<IResponse<workspaces.WorkspaceInviteEntity>> => {
    return new Promise((resolve, reject) => {
      mutationPostWorkspaceInvite.mutate(values, {
        onSuccess(response: IResponse<workspaces.WorkspaceInviteEntity>) {
          queryClient.setQueriesData<
            IResponseList<workspaces.WorkspaceInviteEntity>
          >("*[]workspaces.WorkspaceInviteEntity", (data: any) => {
            if (!(data?.data?.items?.length > 0)) {
              return data;
            }

            data.data.items = data.data.items.map(
              (item: workspaces.WorkspaceInviteEntity) => {
                if (item.uniqueId === response.data?.uniqueId) {
                  return response.data;
                }

                return item;
              }
            );

            return data;
          });

          resolve(response);
        },

        onError(error: any) {
          formikProps?.setErrors(mutationErrorsToFormik(error));

          reject(error);
        },
      });
    });
  };

  const workspaceByUniqueIdQuery = useQuery(
    ["*workspaces.WorkspaceEntity", options],
    (uniqueId: string) => Q().getWorkspaceByUniqueId(uniqueId),
    {
      cacheTime: 1000,
      enabled: !!options?.headers?.authorization,
    }
  );

  // patch workspace

  const mutationPatchWorkspace = useMutation<
    IResponse<workspaces.WorkspaceEntity>,
    IResponse<workspaces.WorkspaceEntity>,
    workspaces.WorkspaceEntity
  >((entity) => {
    return Q().patchWorkspace(entity);
  });

  // Only entities are having a store in front-end

  const fnPatchWorkspaceUpdater = (
    data: IResponseList<workspaces.WorkspaceEntity> | undefined,
    item: IResponse<workspaces.WorkspaceEntity>
  ) => {
    return [];

    if (!data) {
      return {
        data: { items: [] },
      };
    }

    if (data?.data?.items && item.data) {
      data.data.items = data.data.items.map((t) => {
        if (
          item.data !== undefined &&
          WorkspaceActions.isWorkspaceEntityEqual(t, item.data)
        ) {
          return item.data;
        }

        return t;
      });
    } else if (data?.data && item.data) {
      data.data.items = [item.data, ...(data?.data?.items || [])];
    }

    return data;
  };

  const submitPatchWorkspace = (
    values: workspaces.WorkspaceEntity,
    formikProps?: FormikHelpers<workspaces.WorkspaceEntity>
  ): Promise<IResponse<workspaces.WorkspaceEntity>> => {
    return new Promise((resolve, reject) => {
      mutationPatchWorkspace.mutate(values, {
        onSuccess(response: IResponse<workspaces.WorkspaceEntity>) {
          queryClient.setQueriesData<IResponseList<workspaces.WorkspaceEntity>>(
            "*[]workspaces.WorkspaceEntity",
            (data: any) => {
              if (!(data?.data?.items?.length > 0)) {
                return data;
              }

              data.data.items = data.data.items.map(
                (item: workspaces.WorkspaceEntity) => {
                  if (item.uniqueId === response.data?.uniqueId) {
                    return response.data;
                  }

                  return item;
                }
              );

              return data;
            }
          );

          resolve(response);
        },

        onError(error: any) {
          formikProps?.setErrors(mutationErrorsToFormik(error));

          reject(error);
        },
      });
    });
  };

  // patch workspace/invite

  const mutationPatchWorkspaceInvite = useMutation<
    IResponse<workspaces.WorkspaceEntity>,
    IResponse<workspaces.WorkspaceEntity>,
    workspaces.WorkspaceEntity
  >((entity) => {
    return Q().patchWorkspaceInvite(entity);
  });

  // Only entities are having a store in front-end

  const fnPatchWorkspaceInviteUpdater = (
    data: IResponseList<workspaces.WorkspaceEntity> | undefined,
    item: IResponse<workspaces.WorkspaceEntity>
  ) => {
    return [];

    if (!data) {
      return {
        data: { items: [] },
      };
    }

    if (data?.data?.items && item.data) {
      data.data.items = data.data.items.map((t) => {
        if (
          item.data !== undefined &&
          WorkspaceActions.isWorkspaceEntityEqual(t, item.data)
        ) {
          return item.data;
        }

        return t;
      });
    } else if (data?.data && item.data) {
      data.data.items = [item.data, ...(data?.data?.items || [])];
    }

    return data;
  };

  const submitPatchWorkspaceInvite = (
    values: workspaces.WorkspaceEntity,
    formikProps?: FormikHelpers<workspaces.WorkspaceEntity>
  ): Promise<IResponse<workspaces.WorkspaceEntity>> => {
    return new Promise((resolve, reject) => {
      mutationPatchWorkspaceInvite.mutate(values, {
        onSuccess(response: IResponse<workspaces.WorkspaceEntity>) {
          queryClient.setQueriesData<IResponseList<workspaces.WorkspaceEntity>>(
            "*[]workspaces.WorkspaceEntity",
            (data: any) => {
              if (!(data?.data?.items?.length > 0)) {
                return data;
              }

              data.data.items = data.data.items.map(
                (item: workspaces.WorkspaceEntity) => {
                  if (item.uniqueId === response.data?.uniqueId) {
                    return response.data;
                  }

                  return item;
                }
              );

              return data;
            }
          );

          resolve(response);
        },

        onError(error: any) {
          formikProps?.setErrors(mutationErrorsToFormik(error));

          reject(error);
        },
      });
    });
  };

  // post workspace/acceptInvite

  const mutationPostWorkspaceAcceptInvite = useMutation<
    IResponse<core.OkayResponse>,
    IResponse<core.OkayResponse>,
    workspaces.AcceptInviteDto
  >((entity) => {
    return Q().postWorkspaceAcceptInvite(entity);
  });

  // Only entities are having a store in front-end

  const submitPostWorkspaceAcceptInvite = (
    values: workspaces.AcceptInviteDto,
    formikProps?: FormikHelpers<workspaces.AcceptInviteDto>
  ): Promise<IResponse<core.OkayResponse>> => {
    return new Promise((resolve, reject) => {
      mutationPostWorkspaceAcceptInvite.mutate(values, {
        onSuccess(response: IResponse<core.OkayResponse>) {
          queryClient.setQueriesData<IResponseList<workspaces.AcceptInviteDto>>(
            "*[]workspaces.AcceptInviteDto",
            (data: any) => {
              if (!(data?.data?.items?.length > 0)) {
                return data;
              }

              data.data.items = data.data.items.map(
                (item: workspaces.AcceptInviteDto) => {
                  if (item.uniqueId === response.data?.uniqueId) {
                    return response.data;
                  }

                  return item;
                }
              );

              return data;
            }
          );

          resolve(response);
        },

        onError(error: any) {
          formikProps?.setErrors(mutationErrorsToFormik(error));

          reject(error);
        },
      });
    });
  };

  const workspacesQuery = useQuery(
    ["*[]workspaces.WorkspaceEntity", options],
    () => Q().getWorkspaces(),
    {
      cacheTime: 1000,
      enabled: !!options?.headers?.authorization,
    }
  );

  const userRoleWorkspacesQuery = useQuery(
    ["*[]workspaces.UserRoleWorkspace", options],
    () => Q().getUserRoleWorkspaces(),
    {
      cacheTime: 1000,
      enabled: !!options?.headers?.authorization,
    }
  );

  // post workspace

  const mutationPostWorkspace = useMutation<
    IResponse<workspaces.WorkspaceEntity>,
    IResponse<workspaces.WorkspaceEntity>,
    workspaces.WorkspaceEntity
  >((entity) => {
    return Q().postWorkspace(entity);
  });

  // Only entities are having a store in front-end

  const fnPostWorkspaceUpdater = (
    data: IResponseList<workspaces.WorkspaceEntity> | undefined,
    item: IResponse<workspaces.WorkspaceEntity>
  ) => {
    return [];

    if (!data) {
      return {
        data: { items: [] },
      };
    }

    if (data?.data?.items && item.data) {
      data.data.items = data.data.items.map((t) => {
        if (
          item.data !== undefined &&
          WorkspaceActions.isWorkspaceEntityEqual(t, item.data)
        ) {
          return item.data;
        }

        return t;
      });
    } else if (data?.data && item.data) {
      data.data.items = [item.data, ...(data?.data?.items || [])];
    }

    return data;
  };

  const submitPostWorkspace = (
    values: workspaces.WorkspaceEntity,
    formikProps?: FormikHelpers<workspaces.WorkspaceEntity>
  ): Promise<IResponse<workspaces.WorkspaceEntity>> => {
    return new Promise((resolve, reject) => {
      mutationPostWorkspace.mutate(values, {
        onSuccess(response: IResponse<workspaces.WorkspaceEntity>) {
          queryClient.setQueriesData<IResponseList<workspaces.WorkspaceEntity>>(
            "*[]workspaces.WorkspaceEntity",
            (data: any) => {
              if (!(data?.data?.items?.length > 0)) {
                return data;
              }

              data.data.items = data.data.items.map(
                (item: workspaces.WorkspaceEntity) => {
                  if (item.uniqueId === response.data?.uniqueId) {
                    return response.data;
                  }

                  return item;
                }
              );

              return data;
            }
          );

          resolve(response);
        },

        onError(error: any) {
          formikProps?.setErrors(mutationErrorsToFormik(error));

          reject(error);
        },
      });
    });
  };

  // patch workspace/config

  const mutationPatchWorkspaceConfig = useMutation<
    IResponse<workspaces.WorkspaceConfigDto>,
    IResponse<workspaces.WorkspaceConfigDto>,
    workspaces.WorkspaceConfigDto
  >((entity) => {
    return Q().patchWorkspaceConfig(entity);
  });

  // Only entities are having a store in front-end

  const submitPatchWorkspaceConfig = (
    values: workspaces.WorkspaceConfigDto,
    formikProps?: FormikHelpers<workspaces.WorkspaceConfigDto>
  ): Promise<IResponse<workspaces.WorkspaceConfigDto>> => {
    return new Promise((resolve, reject) => {
      mutationPatchWorkspaceConfig.mutate(values, {
        onSuccess(response: IResponse<workspaces.WorkspaceConfigDto>) {
          queryClient.setQueriesData<
            IResponseList<workspaces.WorkspaceConfigDto>
          >("*[]workspaces.WorkspaceConfigDto", (data: any) => {
            if (!(data?.data?.items?.length > 0)) {
              return data;
            }

            data.data.items = data.data.items.map(
              (item: workspaces.WorkspaceConfigDto) => {
                if (item.uniqueId === response.data?.uniqueId) {
                  return response.data;
                }

                return item;
              }
            );

            return data;
          });

          resolve(response);
        },

        onError(error: any) {
          formikProps?.setErrors(mutationErrorsToFormik(error));

          reject(error);
        },
      });
    });
  };

  const workspaceConfigQuery = useQuery(
    ["*workspaces.WorkspaceConfigDto", options],
    () => Q().getWorkspaceConfig(),
    {
      cacheTime: 1000,
      enabled: !!options?.headers?.authorization,
    }
  );

  // Deleting an entity
  const mutationDeleteWorkspace = useMutation<
    IDeleteResponse,
    IDeleteResponse,
    core.DeleteRequest
  >(() => {
    return Q().deleteWorkspace();
  });

  const fnDeleteWorkspaceUpdater = (
    data: IResponseList<workspaces.WorkspaceEntity> | undefined,
    deleteItemsList: string[]
  ) => {
    if (!data) {
      return {
        data: { items: [] },
      };
    }

    if (data?.data?.items) {
      data.data.items = data.data.items.filter((t) => {
        const key = WorkspaceActions.getWorkspaceEntityPrimaryKey(t);

        if (!deleteItemsList.includes(key)) {
          return true;
        }

        return false;
      });
    }

    return data;
  };

  const submitDeleteWorkspace = (
    values: string[],
    formikProps?: FormikHelpers<workspaces.WorkspaceEntity>
  ) => {
    return new Promise((resolve, reject) => {
      mutationDeleteWorkspace.mutate(values, {
        onSuccess(response: IDeleteResponse) {
          queryClient.setQueryData<IResponseList<workspaces.WorkspaceEntity>>(
            "*[]workspaces.WorkspaceEntity",
            (data) => fnDeleteWorkspaceUpdater(data, values)
          );

          resolve(response);
        },

        onError(error: any) {
          formikProps?.setErrors(mutationErrorsToFormik(error));

          reject(error);
        },
      });
    });
  };

  // Deleting an entity
  const mutationDeleteWorkspaceInvite = useMutation<
    IDeleteResponse,
    IDeleteResponse,
    core.DeleteRequest
  >(() => {
    return Q().deleteWorkspaceInvite();
  });

  const fnDeleteWorkspaceInviteUpdater = (
    data: IResponseList<workspaces.WorkspaceEntity> | undefined,
    deleteItemsList: string[]
  ) => {
    if (!data) {
      return {
        data: { items: [] },
      };
    }

    if (data?.data?.items) {
      data.data.items = data.data.items.filter((t) => {
        const key = WorkspaceActions.getWorkspaceEntityPrimaryKey(t);

        if (!deleteItemsList.includes(key)) {
          return true;
        }

        return false;
      });
    }

    return data;
  };

  const submitDeleteWorkspaceInvite = (
    values: string[],
    formikProps?: FormikHelpers<workspaces.WorkspaceEntity>
  ) => {
    return new Promise((resolve, reject) => {
      mutationDeleteWorkspaceInvite.mutate(values, {
        onSuccess(response: IDeleteResponse) {
          queryClient.setQueryData<IResponseList<workspaces.WorkspaceEntity>>(
            "*[]workspaces.WorkspaceEntity",
            (data) => fnDeleteWorkspaceInviteUpdater(data, values)
          );

          resolve(response);
        },

        onError(error: any) {
          formikProps?.setErrors(mutationErrorsToFormik(error));

          reject(error);
        },
      });
    });
  };

  const workspaceInvitesQuery = useQuery(
    ["*[]workspaces.WorkspaceInviteEntity", options],
    () => Q().getWorkspaceInvites(),
    {
      cacheTime: 1000,
      enabled: !!options?.headers?.authorization,
    }
  );

  const userInvitesQuery = useQuery(
    ["*[]workspaces.PendingWorkspaceInvite", options],
    () => Q().getUserInvites(),
    {
      cacheTime: 1000,
      enabled: !!options?.headers?.authorization,
    }
  );

  return {
    queryClient,
    mutationPostWorkspaceInvite,
    submitPostWorkspaceInvite,
    workspaceByUniqueIdQuery,
    mutationPatchWorkspace,
    submitPatchWorkspace,
    mutationPatchWorkspaceInvite,
    submitPatchWorkspaceInvite,
    mutationPostWorkspaceAcceptInvite,
    submitPostWorkspaceAcceptInvite,
    workspacesQuery,
    userRoleWorkspacesQuery,
    mutationPostWorkspace,
    submitPostWorkspace,
    mutationPatchWorkspaceConfig,
    submitPatchWorkspaceConfig,
    workspaceConfigQuery,
    mutationDeleteWorkspace,
    submitDeleteWorkspace,
    mutationDeleteWorkspaceInvite,
    submitDeleteWorkspaceInvite,
    workspaceInvitesQuery,
    userInvitesQuery,
  };
}