require('dotenv').config({ silent: true });
const log = new (require('./logger'))('index');

const http = require('http');
const Koa = require('koa');
const app = new Koa();
const _io = require('socket.io');
const fs = require('fs');
const path = require('path');
const router = require('koa-better-router')().loadMethods();
const Roleypoly = require('./Roleypoly');
const ksuid = require('ksuid');

// monkey patch async-reduce because F U T U R E
Array.prototype.areduce = async function(predicate, acc = []) {
  // eslint-disable-line
  for (let i of this) {
    acc = await predicate(acc, i);
  }

  return acc;
};

Array.prototype.filterNot =
  Array.prototype.filterNot ||
  function(predicate) {
    return this.filter(v => !predicate(v));
  };

// Create the server and socket.io server
const server = http.createServer(app.callback());
const io = _io(server, { transports: ['websocket'], path: '/api/socket.io' });

const M = new Roleypoly(router, io, app); // eslint-disable-line no-unused-vars

app.keys = [process.env.APP_KEY];

const DEVEL = process.env.NODE_ENV === 'development';

async function start() {
  await M.awaitServices();

  // body parser
  const bodyParser = require('koa-bodyparser');
  app.use(bodyParser({ types: ['json'] }));

  // Compress
  const compress = require('koa-compress');
  app.use(compress());

  // SPA + Static
  if (process.env.NODE_ENV === 'production') {
    const pub = path.resolve(path.join(__dirname, 'public'));
    log.info('public path', pub);

    const staticFiles = require('koa-static');
    // app.use(staticFiles(pub, { defer: true, gzip: true, br: true }))

    const send = require('koa-send');
    app.use(async (ctx, next) => {
      if (ctx.path.startsWith('/api')) {
        log.info('api breakout');
        return next();
      }

      const chkPath = path.resolve(path.join(pub, ctx.path));
      log.info('chkPath', chkPath);
      if (!chkPath.startsWith(pub)) {
        return next();
      }

      try {
        fs.statSync(chkPath);
        log.info('sync pass');
        ctx.body = fs.readFileSync(chkPath);
        ctx.type = path.extname(ctx.path);
        log.info('body sent');
        ctx.status = 200;
        return next();
      } catch (e) {
        log.warn('failed');
        if (ctx.path.startsWith('/static/')) {
          return next();
        }
        try {
          ctx.body = fs.readFileSync(path.join(pub, 'index.html'), { encoding: 'utf-8' });
        } catch (e) {
          ctx.body = e.stack || e.trace;
          ctx.status = 500;
        }
        log.info('index sent');
        ctx.status = 200;
        return next();
      }

      // try {
      //   await next()
      // } catch (e) {
      //   send(ctx, 'index.html', { root: pub })
      // }
    });
    // const sendOpts = {root: pub, index: 'index.html'}
    // // const sendOpts = {}
    // app.use(async (ctx, next) => {
    //   if (ctx.path.startsWith('/api')) {
    //     return await next()
    //   }

    //   try {
    //     log.info('pass 1', ctx.path, __dirname+'/public'+ctx.path)
    //     await send(ctx, __dirname+'/public'+ctx.path, sendOpts)
    //   } catch (error) {
    //     try {
    //       log.info('pass 2 /', ctx.path, __dirname+'/public/index.html')
    //       await send(ctx, __dirname+'/public/index.html', sendOpts)
    //     } catch (error) {
    //       log.info('exit to next', ctx.path)
    //       await next()
    //     }
    //   }
    // })
  }

  // Request logger
  app.use(async (ctx, next) => {
    let timeStart = new Date();
    try {
      await next();
    } catch (e) {
      log.error(e);
      ctx.status = ctx.status || 500;
      if (DEVEL) {
        ctx.body = ctx.body || e.stack;
      } else {
        ctx.body = {
          err: 'something terrible happened.',
        };
      }
    }
    let timeElapsed = new Date() - timeStart;

    log.request(
      `${ctx.status} ${ctx.method} ${ctx.url} - ${ctx.ip} - took ${timeElapsed}ms`
    );
    // return null
  });

  const session = require('koa-session');
  app.use(
    session(
      {
        key: 'roleypoly:sess',
        maxAge: 'session',
        siteOnly: true,
        store: M.ctx.sessions,
        genid: () => {
          return ksuid.randomSync().string;
        },
      },
      app
    )
  );

  await M.mountRoutes();

  // SPA server

  log.info(`starting HTTP server on ${process.env.APP_PORT || 6769}`);
  server.listen(process.env.APP_PORT || 6769);
}

start().catch(e => {
  log.fatal('app failed to start', e);
});