//create server.js
const { Server } = require('@teclone/r-server'); // import rserver
const server = new Server(); // create server instance

// add some route
server.get('/', (req, res) => {
  return res.end('Hello from RServer');
});

// export server to run it via cli (Recommended).
module.exports = server;

// or start the server by yourself
server.listen(3000).then(() => console.log('Running and ready'));

const { Server } = require('@teclone/r-server'); // import rserver
const server = new Server(); // create server instance

server.put('users/{userId}/profile-picture', (req, res) => {
  const picture = req.files.picture;

  return res.json({
    status: 'success',
    message: 'got your file',
    fileSize: picture.size,
    mimeType: picture.type,
    filename: picture.name,
    fileTempLocation: picture.path,
  });
});

server.listen().then(() => console.log('listening'));

const { Server, Router } = require('@teclone/r-server'); // import rserver
const server = new Server(); // create server instance

/** get route */
server.get(url, callback, options);

/** post route */
server.post(url, callback, options);

/** put route */
server.put(url, callback, options);

/** head route */
server.head(url, callback, options);

/** delete route */
server.delete(url, callback, options);

/** options route */
server.options(url, callback, options);

/** all method route */
server.all(url, callback, options);

//no data type enforcement
server.get('users/{userId}', (req, res, { userId }) => {
  userId = /^\d+$/.test(userId) ? Number.parseInt(userId) : 0;
  if (userId !== 0) {
    return res.status(200).json({
      data: {
        id: userId,
        name: 'User Name',
      },
    });
  } else {
    return res.status(400).json({
      errors: {
        userId: 'user id not recognised',
      },
    });
  }
});

//enforce data type
server.get('users/{int:userId}', (req, res, { userId }) => {
  if (userId !== 0) {
    return res.status(200).json({
      data: {
        id: userId,
        name: 'User Name',
      },
    });
  } else {
    return res.status(400).json({
      errors: {
        userId: 'user id not recognised',
      },
    });
  }
});

const { Server } = require('@teclone/r-server'); // import rserver
const server = new Server(); // create server instance

server.route('users/{int:userId}')

    .put((req, res, params) => {
        //update user profile
    });

    .delete((req, res, {userId}) => {
        //delete user
    });

    .get((req, res, {userId}) => {
        //retrieve user
    });

const { Server } = require('@teclone/r-server'); // import rserver
const server = new Server(); // create server instance

//examples
server.setBasePath('api/v2.0');

//this route will be called when post request is made on the endpoint /api/v2.0/auth
server.post('auth', (req, res)=> {
    return res.end('received');
}));

const { Server } = require('@teclone/r-server'); // import rserver
const server = new Server(); // create server instance

//runs on all request paths, and methods
server.use('*', (req, res, next) => {
  //check if auth token is present in the header and set the req.user property
  return next(); //execute next to pass control to next middleware
});

//runs on root domain and only on post requests
server.use('/', (req, res, next) => next(), {method: 'post'};

// runs on all request paths starting with users/{userId}, inclusive, and all methods
server.use('users/{userId}/*', (req, res, next, {userId}) => next());

//route localized middleware
server.get('auth/login', (req, res) => {
  return res.end('login form will be served :)');
}, (req, res, next) => {
  //redirect user to homepage if user is logged in
  if (req.user) {
      return res.redirect('/');
  }
  else {
      return next();
  }
});

// or
server.get('auth/login', (req, res) => {
  return res.end('login form will be served :)');
}, {
    use: [
      (req, res, next) => {
        //redirect user to homepage if user is logged in
        if (req.user) {
            return res.redirect('/');
        }
        else {
            return next();
        }
      },

      // ...more middlewares if you like
    ]
  }
});

const { Router } = require('@teclone/r-server'); // import rserver
const authRoutes = new Router(true); // create a mountable router, inherit middleware options is set as true.

//define specific middlewares for auth
authRoutes.use('*', (req, res, next) => {
  // if user is logged in, redirect to homepage
  if (req.user) {
    return res.redirect('/');
  } else {
    return next();
  }
});

authRoutes.post('signup', (req, res) => {
  // process account creation
});

authRoutes.post('login', (req, res) => {
  //process login
});

authRoutes.post('reset-password', (req, res) => {
  // process password reset
});

export default Authroutes;

const { App } = require('@teclone/r-server');
const authRoutes = require('./routes/authRoutes');

const server = RServer.create();

server.get('/', (req, res) => {
  return res.end('Welcome');
});

server.mount('/auth', authRoutes);

server.listen().then(() => console.log('listening'));

/**
 * ends the response with optional response data, and optional data encoding
 */
end(data?, encoding?: string): Promise<boolean>;

/**
 * sets response header
 */
setHeader(name: string, value: string | number | string[]): this;

/**
 * sets multiple response headers
 */
setHeaders(headers: {[p: string]: string | number | string[]}): this;

/**
 * removes a single set response header at a time. function is chainable
 */
removeHeader(name: string): this;

/**
 * remove response headers that are already set. function is chainable
 */
removeHeaders(...names: string[]): this;

/**
 * sets response status code
 */
status(code: number): this;

/**
 * sends json response back to the client.
 */
json(data: object | string): Promise<boolean>;

/**
 * Redirect client to the given url
 */
redirect(path: string, status: number = 302): Promise<boolean>;

/**
 * sends a file download attachment to the client
 */
download(filePath: string, filename?: string): Promise<boolean>;