import { WorkflowError, handleIfProtocolError } from '../../utils/errors.js';
import { formatGrantedAccess } from '../../utils/formatGrantedAccess.js';
import {
  addressSchema,
  booleanSchema,
  numberBetweenSchema,
  positiveNumberSchema,
  throwIfMissing,
} from '../../utils/validators.js';
import {
  GetGrantedAccessParams,
  GrantedAccessResponse,
} from '../types/index.js';
import { IExecConsumer } from '../types/internalTypes.js';

export const getGrantedAccess = async ({
  iexec = throwIfMissing(),
  protectedData,
  authorizedApp,
  authorizedUser,
  isUserStrict = false,
  page,
  pageSize,
  bulkOnly = false,
}: IExecConsumer & GetGrantedAccessParams): Promise<GrantedAccessResponse> => {
  const vProtectedData = addressSchema()
    .label('protectedData')
    .validateSync(protectedData);
  const vAuthorizedApp = addressSchema()
    .label('authorizedApp')
    .validateSync(authorizedApp);
  const vAuthorizedUser = addressSchema()
    .label('authorizedUser')
    .validateSync(authorizedUser);
  const vIsUserStrict = booleanSchema()
    .label('isUserStrict')
    .validateSync(isUserStrict);
  const vPage = positiveNumberSchema().label('page').validateSync(page);
  const vPageSize = numberBetweenSchema(10, 1000)
    .label('pageSize')
    .validateSync(pageSize);
  const vBulkOnly = booleanSchema().label('bulkOnly').validateSync(bulkOnly);

  try {
    const { count, orders } = await iexec.orderbook.fetchDatasetOrderbook({
      dataset: vProtectedData || 'any',
      app: vAuthorizedApp || 'any',
      requester: vAuthorizedUser || 'any',
      isRequesterStrict: vIsUserStrict,
      isAppStrict: true,
      page: vPage,
      pageSize: vPageSize,
      bulkOnly: vBulkOnly,
    });
    const grantedAccess = orders?.map((order) =>
      formatGrantedAccess(order.order, order.remaining)
    );
    return { count, grantedAccess };
  } catch (e) {
    handleIfProtocolError(e);
    throw new WorkflowError({
      message: 'Failed to fetch granted access',
      errorCause: e,
    });
  }
};