import restify from 'restify';
import nano from 'nano';
import yup from 'yup';

import validationFactory from './modules/validations.js';
import dbWrapper from './modules/db.js';
import logger from './modules/logging.js';

function setupRoute(routeFactory, dbs, server, log) {
  const route = routeFactory({ dbs, yup, log });
  const handlers = route.schema ? [validationFactory(route, log), ...route.handlers] : route.handlers;

  switch (route.verb) {
    case 'get':
      server.get(route.path, ...handlers);
      break;
    case 'post':
      server.post(route.path, ...handlers);
      break;
    default:
      throw new Error();
  }
}

async function connectDbs(client, dbs) {
  return dbs.reduce(async (wrappedDbs, dbName) => ({ ...wrappedDbs, [dbName]: await dbWrapper(client, dbName) }), {});
}

async function start({ routes, host, port, middlewares, couchDbOpts, restifyOpts }) {
  try {
    const connStr = `${couchDbOpts.protocol}://${couchDbOpts.username}:${couchDbOpts.password}@${couchDbOpts.host}:${couchDbOpts.port}`;
    const client = await nano(connStr);
    const dbs = await connectDbs(client, couchDbOpts.dbs);

    logger.info('connected to db, starting server...');
    const server = restify.createServer(restifyOpts);

    middlewares.forEach(middlewareFactory => {
      server.use(middlewareFactory({ server, restify }));
    });

    routes.forEach(routeFactory => {
      setupRoute(routeFactory, dbs, server, logger);
    });

    server.listen(port, host, () => {
      logger.info(`${server.name} listening at ${server.url}`);
    });
  } catch (e) {
    throw new Error(e);
  }
}

export default start;