export function handleRequestError(friend: User, e: Error, log: any, looped?: boolean, reply?: h.IReply) {
	let code: number = 500; // Default value
	let message: string = ''; // Default value
	if(e instanceof r.RequestError) {
		code = e.error.code;
	} else if(e instanceof r.StatusCodeError) {
		code = e.statusCode;
	}
	
	if(e instanceof r.StatusCodeError && e.statusCode === 400) {
		message = 'This usually means the API was badly implemented either on the current instance or on the friend\'s.';
	} else if(e instanceof r.StatusCodeError && e.statusCode === 401) {
		message = 'This can happen because of a bad implementation of the Vinimay API on either side, or because of an instance domain mismatch between the two instances\' databases.';
	} else if(e instanceof r.StatusCodeError && e.statusCode === 500) {
		message = 'This can happen because of a bug in the remote instance\'s code or a bad implentation of the Vinimay API on its side.'
	} else if(e instanceof r.StatusCodeError) {
		// Some errors are thrown willingly to be sent to the client
		if(reply && !looped) return reply(b.create(e.statusCode));
		else return;
	} else if(!(e instanceof r.RequestError)) {
		log.error(e);
		if(reply && !looped) return reply(b.wrap(e));
		else return;
	}

	// Default behaviour
	if(code) log.warn('Got a ' + code + ' when querying ' + friend)
	else log.error(e);
	if(message.length) log.warn(message);
	if(reply && !looped) reply(b.serverUnavailable());
}

    handler: async (request, reply) => {
      const timings = {
        esRequestSent: Date.now(),
        esResponseProcessed: 0,
      };

      try {
        const search = <Hit>(params: SearchParams) =>
          callWithRequest<Hit>(request, 'search', params);

        const searchResults = await fetchSearchResultsBetween(
          search,
          request.payload.indices,
          request.payload.fields,
          request.payload.start,
          request.payload.end,
          request.payload.query
        );

        timings.esResponseProcessed = Date.now();

        return reply({
          results: searchResults,
          timings,
        });
      } catch (requestError) {
        return reply(Boom.wrap(requestError));
      }
    },

        authenticate: async (request, reply) =>
        {
            function unauthorized()
            {
                const response = request.generateResponse().redirect(AuthRoutes.GetLogin);
                

                // Response is ignored if error is passed in as first param
                return reply(null, response);
            }

            let auth: {credentials: AuthCredentials; artifacts: AuthArtifacts};

            try
            {
                auth = await getUserAuth(request);
            }
            catch (e)
            {
                if (e.status === 404)
                {
                    return unauthorized();
                }

                return reply(boom.wrap(e));
            }

            if (!auth)
            {
                return unauthorized();
            }
            
            return reply.continue(auth);
        }

 .catch((err) => {
   if (err.name && err.name === 'SequelizeValidationError') {
     rep(badRequest(err.errors[0].message));
   }
   else {
     rep(wrap(err));
   }
 });

    transporter.sendMail(message, (error, info) =>
    {
        if (error)
        {
            return reply(boom.wrap(error));
        }

        return reply.redirect(Routes.GetResetSent);
    });

            transporter.sendMail(message as any, (error, info) => {
                if (error) {
                    return next(boom.wrap(error));
                };

                res.json({});

                return next();
            });

    app.use(function (err: Error | BoomError, req: express.Request, res: express.Response, next: Function) {
        const fullError = isBoomError(err) ? err : wrap(err);

        if (fullError.output.statusCode >= 500) {
            inspect(`Error in ${req.url}`, err);
        }

        res.status(fullError.output.statusCode).json(fullError.output.payload);

        return next();
    });

    handler: async (request, reply) => {
      const timings = {
        esRequestSent: Date.now(),
        esResponseProcessed: 0,
      };

      try {
        const search = <Hit>(params: SearchParams) =>
          callWithRequest<Hit, any>(request, 'search', params);

        const latestTime = await fetchLatestTime(
          search,
          request.payload.indices,
          request.payload.fields.time
        );
        const searchResultsAfterTarget = await fetchSearchResults(
          search,
          request.payload.indices,
          request.payload.fields,
          {
            tiebreaker: request.payload.target.tiebreaker - 1,
            time: request.payload.target.time,
          },
          request.payload.after,
          'asc',
          request.payload.query,
          request.payload.target.time + INITIAL_HORIZON_OFFSET,
          latestTime
        );
        const searchResultsBeforeTarget = (await fetchSearchResults(
          search,
          request.payload.indices,
          request.payload.fields,
          request.payload.target,
          request.payload.before,
          'desc',
          request.payload.query,
          request.payload.target.time - INITIAL_HORIZON_OFFSET
        )).reverse();

        timings.esResponseProcessed = Date.now();

        return reply({
          results: {
            after: searchResultsAfterTarget,
            before: searchResultsBeforeTarget,
          },
          timings,
        });
      } catch (requestError) {
        return reply(Boom.wrap(requestError));
      }
    },

export async function updateAccount(server: Server, request: Request, reply: IReply)
{
    const id = request.params["id"];
    const apiKey = request.auth.credentials.apiKey;
    const accountToUpdate: Account = request.payload;
    let dbAccount: Account;

    // Get the original account
    try
    {
        dbAccount = await Accounts.findByApiKey(apiKey);

        // Only update the account if the ApiKey and Id match.
        if (!dbAccount || dbAccount._id !== id || dbAccount.apiKey !== apiKey)
        {
            return reply(notFound("No account find with that id and API key combination."));
        }
    }
    catch (e)
    {
        console.error("Failed to retrieve account when updating.", e);

        return reply(boom(e));
    }

    // Transfer update props to the dbAccount
    for (let prop in accountToUpdate)
    {
        dbAccount[prop] = accountToUpdate[prop];
    }

    // Never update the account's ID or apiKey
    dbAccount._id = id;
    dbAccount.apiKey = apiKey;

    try
    {
        const update = await Accounts.Database.put(accountToUpdate);

        if (!update.ok)
        {
            console.error("Failed to update account.", update);

            return reply(expectationFailed("Failed to update account."));
        }
        
        dbAccount._rev = update.rev;
    }
    catch (e)
    {
        console.error("Failed to update account.", e);

        return reply(boom(e));
    }

    return reply(dbAccount);
}