type Context = object;
type NextFunction = (e: any) => Promise<void>;
type ExpressMiddlewareHandler = (request: object, response: object, next: NextFunction) => Promise<void>;
type RabbitMQMiddlewareHandler = (context: Context, message: object) => Promise<void>;

type ClaimOptions = {
  applicationToken: string,
  internalToken: any,
  decodedUser: any,
  cacheManager: any
};

type CheckClaimOptions = {
  applicationToken: string,
  cacheManager: any
};

type CSPKeys = 'companyCode' | 'state' | 'product';
type CSPFilter = {
  [key: CSPKeys]: any
};

type MongoCspFilter = {
  $or: CSPFilter[][]
}

type MongoConditionFilter = {
  [key: string]: {
    $in: any[]
  }
};

type ExpressJwtOptions = {
  /** Overrides the AUTH0_AUDIENCE environment variable. A comma delimited string or an array. */
  audience?: string | string[]
};

export type ServiceResourceRights = 'READ' | 'UPDATE' | 'INSERT';
export interface ServiceResource {
  code: string,
  service: string,
  name: string,
  uri: string,
  allowedRights: ServiceResourceRights[]
}
export interface UserServiceResource extends ServiceResource {
  mongoFilter: {
    $and: MongoConditionFilter | MongoCspFilter
  }
};

type ResourceValidator = {
  getValidUserResourceList: (user: object, serviceResource: ServiceResource) => UserServiceResource[]
};

function checkClaim(context: Context, accessKey: string, options: ClaimOptions): Promise<void>
function checkClaimMiddleware(options: CheckClaimOptions): { express: ExpressMiddlewareHandler, mq: RabbitMQMiddlewareHandler }
function contextUserMiddleware(context: Context, options: ClaimOptions): Promise<void>
function redbirdJwtMiddleware(context: Context, request: object, response: object, next: NextFunction): Promise<void>
function setupUserSecurityResourceRpcMiddleware(serviceResource: ServiceResource[]): RabbitMQMiddlewareHandler
function createSystemToken(context: Context): Promise<any>;

/**
 * @description (Middleware) Express middleware that populates a resource list that belongs to a user based on
 * the security resources from the service
 */
function setupUserSecurityResourceMiddleware(serviceResource: ServiceResource[]): ExpressMiddlewareHandler;

/**
 * @description (Middleware) Exframe Context that populates a resource list that belongs to a user based on
 * the security resources from the service
 */
function setupContextUserSecurityResourceMiddleware(serviceResource: ServiceResource[]): (context: Context) => Promise<void>;

/**
 * @description (Middleware) express middleware that validates that a user has access to a given resource right pair
 * @param {string} resourceUri the resource to validate
 * @param {string} right the right against the resource to validate
 * @returns {function} middleware that will process the request
 */
function checkResourceAccessMiddleware(resourceUri: string, right: string): ExpressMiddlewareHandler;

/**
 * @description (Middleware) Express middleware that gets the user profile from Falcon using the access key
 * based on the access key that is passed from the request.
 */
const falconSecurityMiddleware: ExpressMiddlewareHandler;
const falconSecurityRpcMiddleware: RabbitMQMiddlewareHandler;
/**
 * @description (Middleware) Express middleware that validates the RS256 JWT token on the request and
 * populates `req.user`. Can be used directly as middleware, or called with options to override the
 * AUTH0_AUDIENCE environment variable (e.g. `expressJwtMiddleware({ audience: 'my-audience' })`).
 */
interface ExpressJwtMiddleware {
  (request: object, response: object, next: NextFunction): Promise<void>;
  (options?: ExpressJwtOptions): ExpressMiddlewareHandler;
}
const expressJwtMiddleware: ExpressJwtMiddleware;
const resourceValidator: ResourceValidator;

interface JwksClient {
  constructor(options: any);
  getJwks(): Promise<any>;
  getSigningKeys(): any[];
  getSigningKey(kid: string): Promise<any>;
}

export class JwksClient implements JwksClient {};

const ExframeSecurity = {
  checkClaim,
  checkClaimMiddleware,
  checkResourceAccessMiddleware,
  contextUserMiddleware,
  createSystemToken,
  expressJwtMiddleware,
  falconSecurityMiddleware,
  falconSecurityRpcMiddleware,
  JwksClient,
  resourceValidator,
  redbirdJwtMiddleware,
  setupUserSecurityResourceMiddleware,
  setupUserSecurityResourceRpcMiddleware,
  setupContextUserSecurityResourceMiddleware
};

export default ExframeSecurity;