var router = require('express').Router(),
    mongoose = require('mongoose'),
    Jump = mongoose.model('Jump'),
    User = mongoose.model('User');
const auth = require('../auth'),
    queries = require('../queries'),
    utils = require('../utils');

router.get('/aeronefs', auth.required, function (req, res, next) {
    User.findById(req.payload.id).then(function (user) {
        if (!user) {
            return res.status(401).json({ errors: { "Unauthorized": "autentification requise" } });
        }
        let limit = 120;
        let offset = 0;
        if (typeof req.query.limit !== 'undefined') {
            limit = req.query.limit;
        }
        if (typeof req.query.offset !== 'undefined') {
            offset = req.query.offset;
        }
        Promise.all([
            Jump.find({})
                .limit(1)
                .skip(0)
                .sort({ numero: 'desc' })
                .populate('author')
                .populate('files')
                .populate('x2data')
                .exec(),
            Jump.aggregate(queries.getAeronefsByImatQuery(user._id.toString()))
                .skip(Number(offset))
                .limit(Number(limit))
                .exec(),
            Jump.aggregate(queries.getAeronefsByImatByYearQuery(user._id.toString()))
                .skip(Number(offset))
                .limit(Number(limit))
                .exec()
        ]).then(function (results) {
            if (results[0].length) {
                let lastjump = results[0][0].toJSONFor(user);
                let aeronefsByImat = results[1].map(function (data) {
                    return { aeronef: data._id.aeronef, imat: data._id.imat, count: data.count };
                });
                let aeronefsByImatByYear = results[2].map(function (data) {
                    return {
                        aeronef: data._id.aeronef,
                        imat: data._id.imat,
                        year: data._id.year,
                        count: data.count
                    };
                });
                return res.json({
                    aeronefsByImat: aeronefsByImat,
                    aeronefsByImatByYear: aeronefsByImatByYear,
                    lastjump: lastjump
                });
            } else {
                return res.status(422).json({ errors: { lastjump: "Aucun saut enregistré pour le moment" } });
            }
        }).catch(next);
    }).catch(next);
});

router.get('/canopies', auth.required, function (req, res, next) {
    User.findById(req.payload.id).then(function (user) {
        if (!user) {
            return res.status(401).json({ errors: { "Unauthorized": "autentification requise" } });
        }
        let limit = 120;
        let offset = 0;
        if (typeof req.query.limit !== 'undefined') {
            limit = req.query.limit;
        }
        if (typeof req.query.offset !== 'undefined') {
            offset = req.query.offset;
        }
        Promise.all([
            Jump.find({})
                .limit(1)
                .skip(0)
                .sort({ numero: 'desc' })
                .populate('author')
                .populate('files')
                .populate('x2data')
                .exec(),
            Jump.aggregate(queries.getCanopiesBySizeQuery(user._id.toString()))
                .skip(Number(offset))
                .limit(Number(limit))
                .exec(),
            Jump.aggregate(queries.getCanopiesBySizeByYearQuery(user._id.toString()))
                .skip(Number(offset))
                .limit(Number(limit))
                .exec(),
            Jump.aggregate(queries.getCanopiesBySizeByModelQuery(user._id.toString()))
                .skip(Number(offset))
                .limit(Number(limit))
                .exec(),
            Jump.aggregate(queries.getCanopiesBySizeByModelByYearQuery(user._id.toString()))
                .skip(Number(offset))
                .limit(Number(limit))
                .exec()
        ]).then(function (results) {
            if (results[0].length) {
                let lastjump = results[0][0].toJSONFor(user);
                let canopiesBySize = results[1].map(function (data) {
                    return { taille: data._id.taille, count: data.count };
                });
                let canopiesBySizeByYear = results[2].map(function (data) {
                    return {
                        taille: data._id.taille,
                        year: data._id.year,
                        count: data.count
                    };
                });
                let canopiesBySizeByModel = results[3].map(function (data) {
                    return {
                        taille: data._id.taille,
                        voile: data._id.voile,
                        count: data.count
                    };
                });
                let canopiesBySizeByModelByYear = results[4].map(function (data) {
                    return {
                        taille: data._id.taille,
                        voile: data._id.voile,
                        year: data._id.year,
                        count: data.count
                    };
                });
                return res.json({
                    canopiesBySize: canopiesBySize,
                    canopiesBySizeByYear: canopiesBySizeByYear,
                    canopiesBySizeByModel: canopiesBySizeByModel,
                    canopiesBySizeByModelByYear: canopiesBySizeByModelByYear,
                    lastjump: lastjump
                });
            } else {
                return res.status(422).json({ errors: { lastjump: "Aucun saut enregistré pour le moment" } });
            }
        }).catch(next);
    }).catch(next);
});

router.get('/dropzones', auth.required, function (req, res, next) {
    User.findById(req.payload.id).then(function (user) {
        if (!user) {
            return res.status(401).json({ errors: { "Unauthorized": "autentification requise" } });
        }
        let limit = 120;
        let offset = 0;
        if (typeof req.query.limit !== 'undefined') {
            limit = req.query.limit;
        }
        if (typeof req.query.offset !== 'undefined') {
            offset = req.query.offset;
        }
        Promise.all([
            Jump.find({})
                .limit(1)
                .skip(0)
                .sort({ numero: 'desc' })
                .populate('author')
                .populate('files')
                .populate('x2data')
                .exec(),
            Jump.aggregate(queries.getDropZonesByOaciQuery(user._id.toString()))
                .skip(Number(offset))
                .limit(Number(limit))
                .exec(),
            Jump.aggregate(queries.getDropZonesByOaciByYearQuery(user._id.toString()))
                .skip(Number(offset))
                .limit(Number(limit))
                .exec()
        ]).then(function (results) {
            if (results[0].length) {
                let lastjump = results[0][0].toJSONFor(user);
                let dropZonesByOaci = results[1].map(function (data) {
                    return { lieu: data._id.lieu, oaci: data._id.oaci, count: data.count };
                });
                let dropZonesByOaciByYear = results[2].map(function (data) {
                    return {
                        lieu: data._id.lieu,
                        oaci: data._id.oaci,
                        year: data._id.year,
                        count: data.count
                    };
                });
                return res.json({
                    dropZonesByOaci: dropZonesByOaci,
                    dropZonesByOaciByYear: dropZonesByOaciByYear,
                    lastjump: lastjump
                });
            } else {
                return res.status(422).json({ errors: { lastjump: "Aucun saut enregistré pour le moment" } });
            }
        }).catch(next);
    }).catch(next);
});

router.get('/jumps', auth.required, function (req, res, next) {
    User.findById(req.payload.id).then(function (user) {
        if (!user) {
            return res.status(401).json({ errors: { "Unauthorized": "autentification requise" } });
        }
        let limit = 120;
        let offset = 0;
        if (typeof req.query.limit !== 'undefined') {
            limit = req.query.limit;
        }
        if (typeof req.query.offset !== 'undefined') {
            offset = req.query.offset;
        }
        Promise.all([
            Jump.find({})
                .limit(1)
                .skip(0)
                .sort({ numero: 'desc' })
                .populate('author')
                .populate('files')
                .populate('x2data')
                .exec(),
            Jump.aggregate(queries.getJumpByYearsQuery(user._id.toString()))
                .skip(Number(offset))
                .limit(Number(limit))
                .exec(),
            Jump.aggregate(queries.getJumpsByCategoryQuery(user._id.toString()))
                .skip(Number(offset))
                .limit(Number(limit))
                .exec(),
            Jump.aggregate(queries.getJumpsByModuleQuery(user._id.toString()))
                .skip(Number(offset))
                .limit(Number(limit))
                .exec(),
            Jump.aggregate(queries.getJumpsByDateQuery(user._id.toString()))
                .skip(Number(offset))
                .limit(Number(limit))
                .exec(),
            Jump.aggregate(queries.getJumpsByModuleByDateQuery(user._id.toString()))
                .skip(Number(offset))
                .limit(Number(limit))
                .exec()
            //utils.fetchSkydiverIdApi('jumps')
        ]).then(function (results) {
            if (results[0].length) {
                let lastjump = results[0][0].toJSONFor(user);
                let jumpsByYears = results[1].map(function (data) {
                    return { year: data._id.year, count: data.count };
                });
                let jumpsByCategory = results[2].map(function (data) {
                    return { categorie: data._id.categorie, count: data.count };
                });
                let jumpsByModule = results[3].map(function (data) {
                    return { categorie: data._id.categorie, module: data._id.module, count: data.count };
                });
                let jumpsByDate = results[4].map(function (data) {
                    return { year: data._id.year, month: data._id.month, count: data.count };
                });
                let jumpsByDateByModule = results[5].map(function (data) {
                    return {
                        categorie: data._id.categorie,
                        module: data._id.module,
                        year: data._id.year,
                        month: data._id.month,
                        count: data.count
                    };
                });
                //let jumpsFromSkydiverIdApi = results[6];
                return res.json({
                    jumpsByCategory: jumpsByCategory,
                    jumpsByDate: jumpsByDate,
                    jumpsByDateByModule: jumpsByDateByModule,
                    jumpsByModule: jumpsByModule,
                    jumpsByYears: jumpsByYears,
                    //jumpsFromSkydiverIdApi: jumpsFromSkydiverIdApi,
                    lastjump: lastjump
                });
            } else {
                return res.status(422).json({ errors: { lastjump: "Aucun saut enregistré pour le moment" } });
            }
        }).catch(next);
    }).catch(next);
});

module.exports = router;