"use strict";

// modules
const express = require('express');
const logger = require('debug')('cc:wars');

// HTTP status codes by name
const codes = require('./http-codes');

const routerHandling = require('../middleware/router-handling');

// Mongoose Model using mongoDB
const LogBudgetModel = require('../models/logs/budget');
const LogRespawnModel = require('../models/logs/respawn');
const LogReviveModel = require('../models/logs/revive');
const LogKillModel = require('../models/logs/kill');
const LogTransportModel = require('../models/logs/transport');
const LogFlagModel = require('../models/logs/flag');
const LogPointsModel = require('../models/logs/points');


const notFoundError = new Error('No logs found');

const logsRouter = express.Router();

// routes **********************
logsRouter.route('/:warId/budget')
  .get((req, res, next) => {
    const filter = {war: req.params.warId};
    if (req.query.fraction) filter['fraction'] = req.query.fraction;
    LogBudgetModel.find(filter, {}, {sort: {time: 1}}, (err, logBudget) => {
      if (err) return next(err);
      if (!logBudget || logBudget.length === 0) {
        const err = notFoundError;
        err.status = codes.notfound;
        return next(err)
      }
      res.locals.items = logBudget;
      next();
    })
  })
  .all(
    routerHandling.httpMethodNotAllowed
  );

logsRouter.route('/:warId/respawn')
  .get((req, res, next) => {
    const filter = {war: req.params.warId};
    if (req.query.player) filter['player'] = req.query.player;
    LogRespawnModel.find(filter, {}, {sort: {time: 1}}, (err, logRespawn) => {
      if (err) return next(err);
      if (!logRespawn || logRespawn.length === 0) {
        const err = notFoundError;
        err.status = codes.notfound;
        return next(err)
      }
      res.locals.items = logRespawn;
      next();
    })
  })
  .all(
    routerHandling.httpMethodNotAllowed
  );

logsRouter.route('/:warId/revive')
  .get((req, res, next) => {
    const filter = {war: req.params.warId};
    if (req.query.medic) filter['medic'] = req.query.medic;
    if (req.query.patient) filter['patient'] = req.query.patient;
    if (req.query.stabilized) filter['stabilized'] = true;
    if (req.query.revive) filter['stabilized'] = false;
    if (req.query.fraction) filter['fraction'] = req.query.fraction;
    LogReviveModel.find(filter, {}, {sort: {time: 1}}, (err, logRevive) => {
      if (err) return next(err);
      if (!logRevive || logRevive.length === 0) {
        const err = notFoundError;
        err.status = codes.notfound;
        return next(err)
      }
      res.locals.items = logRevive;
      next();
    })
  })
  .all(
    routerHandling.httpMethodNotAllowed
  );

logsRouter.route('/:warId/kills')
  .get((req, res, next) => {
    const filter = {war: req.params.warId};
    if (req.query.shooter) filter['shooter'] = req.query.shooter;
    if (req.query.target) filter['target'] = req.query.target;
    if (req.query.friendlyFire) filter['friendlyFire'] = true;
    if (req.query.noFriendlyFire) filter['friendlyFire'] = false;
    if (req.query.fraction) filter['fraction'] = req.query.fraction;
    LogKillModel.find(filter, {}, {sort: {time: 1}}, (err, logKill) => {
      if (err) return next(err);
      if (!logKill || logKill.length === 0) {
        const err = notFoundError;
        err.status = codes.notfound;
        return next(err)
      }
      res.locals.items = logKill;
      next();
    })
  })
  .all(
    routerHandling.httpMethodNotAllowed
  );

logsRouter.route('/:warId/transport')
  .get((req, res, next) => {
    const filter = {war: req.params.warId};
    if (req.query.driver) filter['driver'] = req.query.driver;
    if (req.query.passenger) filter['passenger'] = req.query.passenger;
    if (req.query.fraction) filter['fraction'] = req.query.fraction;
    LogTransportModel.find(filter, {}, {sort: {time: 1}}, (err, logTransport) => {
      if (err) return next(err);
      if (!logTransport || logTransport.length === 0) {
        const err = notFoundError;
        err.status = codes.notfound;
        return next(err)
      }
      res.locals.items = logTransport;
      next();
    })
  })
  .all(
    routerHandling.httpMethodNotAllowed
  );

logsRouter.route('/:warId/flag')
  .get((req, res, next) => {
    const filter = {war: req.params.warId};
    if (req.query.player) filter['player'] = req.query.player;
    if (req.query.capture) filter['capture'] = true;
    if (req.query.defend) filter['capture'] = false;
    if (req.query.fraction) filter['fraction'] = req.query.fraction;
    LogFlagModel.find(filter, {}, {sort: {time: 1}}, (err, logFlag) => {
      if (err) return next(err);
      if (!logFlag || logFlag.length === 0) {
        const err = notFoundError;
        err.status = codes.notfound;
        return next(err)
      }
      res.locals.items = logFlag;
      next();
    })
  })
  .all(
    routerHandling.httpMethodNotAllowed
  );

logsRouter.route('/:warId/points')
  .get((req, res, next) => {
    const filter = {war: req.params.warId};
    if (req.query.fraction) filter['fraction'] = req.query.fraction;
    LogPointsModel.find(filter, {}, {sort: {time: 1}}, (err, logPoints) => {
      if (err) return next(err);
      if (!logPoints || logPoints.length === 0) {
        const err = notFoundError;
        err.status = codes.notfound;
        return next(err)
      }
      res.locals.items = logPoints;
      next();
    })
  })
  .all(
    routerHandling.httpMethodNotAllowed
  );

logsRouter.use(routerHandling.emptyResponse);

module.exports = logsRouter;