export const getErrorStringOrDefault = (
  errors: Linode.ApiFieldError[] | AxiosError | string,
  defaultError: string = 'An unexpected error occurred.'
): string => {
  if (typeof errors === 'string') {
    return errors;
  }
  const apiErrors = pathOr(errors, ['response', 'data', 'errors'], errors);
  return pathOr<string>(defaultError, [0, 'reason'], apiErrors);
};

export const hasGrant = (state: any, grant: Linode.GlobalGrantTypes) => {
  return pathOr(
    false,
    ['__resources', 'profile', 'data', 'grants', 'global', grant],
    state
  );
};

export const enableAutoEnroll: EnableAutoEnrollThunk = () => (dispatch, getState) => {
  const state = getState();
  const { backups } = state;
  const hasBackupsEnabled = pathOr(false,
    ['__resources', 'accountSettings', 'data', 'backups_enabled'], state);
  const shouldEnableBackups = Boolean(backups.autoEnroll);

  /** If the selected toggle setting matches the setting already on the user's account,
   * don't bother the API.
   */
  if (hasBackupsEnabled === shouldEnableBackups) { dispatch(enableAllBackups()); return; }

  dispatch(handleAutoEnroll());
  updateAccountSettings({ backups_enabled: shouldEnableBackups })
    .then((response) => {
      dispatch(handleAutoEnrollSuccess());
      dispatch(enableAllBackups());
      // Have to let the rest of the store know that the backups setting has been updated.
      dispatch(handleUpdate(response));
    })
    .catch((errors) => {
      const defaultError = "Your account settings could not be updated. Please try again.";
      const finalError = pathOr(defaultError, ['response', 'data', 'errors', 0, 'reason'], errors);
      dispatch(handleAutoEnrollError(finalError));
    });
}

export const unnest = (categories: Category[]): Category[] => {
  const children = R.groupBy(R.pathOr('root', ['parent', 'name']), categories);

  return children.root.map(category => ({
    ...category,
    children: children[category.name] || []
  }))
}

 .catch((error) => {
   const reason = pathOr('Backups could not be enabled for this Linode.',
     ['response', 'data', 'errors', 0, 'reason'], error);
   return {
     ...accumulator,
     errors: [...accumulator.errors, { linodeId: linode.id, reason }]
   }
 })

export const getQueryParam = (
  str: string,
  paramName: string,
  defaultValue: string = ''
) => {
  const params = parseQueryParams(str);
  return pathOr(defaultValue, [paramName], params);
};

export const getErrorText = (error: any) => {
  const reason = pathOr('', ['data', 'errors', 0, 'reason'], error);

  if (reason === 'Unauthorized') {
    return 'You are not authorized to view StackScripts for this account.';
  }
  return 'There was an error loading your StackScripts. Please try again later.';
}

 .catch((err) => {
   const ApiError = pathOr(
     [{ reason: "There was an error retrieving your Images." }],
     ['response', 'data', 'errors'],
     err
   )
   dispatch(getImagesFailure(ApiError))
   return err;
 })

 .catch((err) => {
   const errors: Linode.ApiFieldError[] = pathOr(
     [{ reason: 'There was an issue rebooting your Linode' }],
     ['response', 'data', 'errors'],
     err
   );
   errors.forEach(e => sendToast && sendToast(e.reason, {
     variant: 'error'
   }));
 });