import express from 'express';
import _ from 'lodash';

import MaterialValidate from './validate/material';
import MaterialModel from '../models/material'
import SampleModel from '../models/sample';
import MaterialGroupModel from '../models/material_groups';
import MaterialSupplierModel from '../models/material_suppliers';
import IdValidate from './validate/id';
import res400 from './validate/res400';
import mongoose from 'mongoose';
import globals from '../globals';



const router = express.Router();

router.get('/materials', (req, res, next) => {
  if (!req.auth(res, ['read', 'write', 'maintain', 'dev', 'admin'], 'all')) return;

  MaterialModel.find({status:globals.status.validated}).populate('group_id').populate('supplier_id').lean().exec((err, data) => {
    if (err) return next(err);

    res.json(_.compact(data.map(e => MaterialValidate.output(e))));  // validate all and filter null values from validation errors
  });
});

router.get('/materials/:state(new|deleted)', (req, res, next) => {
  if (!req.auth(res, ['maintain', 'admin'], 'basic')) return;

  MaterialModel.find({status: globals.status[req.params.state]}).populate('group_id').populate('supplier_id').lean().exec((err, data) => {
    if (err) return next(err);

    res.json(_.compact(data.map(e => MaterialValidate.output(e))));  // validate all and filter null values from validation errors
  });
});

router.get('/material/' + IdValidate.parameter(), (req, res, next) => {
  if (!req.auth(res, ['read', 'write', 'maintain', 'dev', 'admin'], 'all')) return;

  MaterialModel.findById(req.params.id).populate('group_id').populate('supplier_id').lean().exec((err, data: any) => {
    if (err) return next(err);

    if (!data) {
      return res.status(404).json({status: 'Not found'});
    }

    if (data.status === globals.status.deleted && !req.auth(res, ['maintain', 'admin'], 'all')) return;  // deleted materials only available for maintain/admin
    res.json(MaterialValidate.output(data));
  });
});

router.put('/material/' + IdValidate.parameter(), (req, res, next) => {
  if (!req.auth(res, ['write', 'maintain', 'dev', 'admin'], 'basic')) return;

  let {error, value: material} = MaterialValidate.input(req.body, 'change');
  if (error) return res400(error, res);

  MaterialModel.findById(req.params.id).lean().exec(async (err, materialData: any) => {
    if (!materialData) {
      return res.status(404).json({status: 'Not found'});
    }
    if (materialData.status === globals.status.deleted) {
      return res.status(403).json({status: 'Forbidden'});
    }
    if (material.hasOwnProperty('name') && material.name !== materialData.name) {
      if (!await nameCheck(material, res, next)) return;
    }
    if (material.hasOwnProperty('group')) {
      material = await groupResolve(material, next);
      if (!material) return;
    }
    if (material.hasOwnProperty('supplier')) {
      material = await supplierResolve(material, next);
      if (!material) return;
    }

    // check for changes
    if (!_.isEqual(_.pick(IdValidate.stringify(materialData), _.keys(material)), IdValidate.stringify(material))) {
      material.status = globals.status.new;  // set status to new
    }

    await MaterialModel.findByIdAndUpdate(req.params.id, material, {new: true}).populate('group_id').populate('supplier_id').lean().exec((err, data) => {
      if (err) return next(err);
      res.json(MaterialValidate.output(data));
    });
  });
});

router.delete('/material/' + IdValidate.parameter(), (req, res, next) => {
  if (!req.auth(res, ['write', 'maintain', 'dev', 'admin'], 'basic')) return;

  // check if there are still samples referencing this material
  SampleModel.find({'material_id': new mongoose.Types.ObjectId(req.params.id)}).lean().exec((err, data) => {
    if (err) return next(err);
    if (data.length) {
      return res.status(400).json({status: 'Material still in use'});
    }
    MaterialModel.findByIdAndUpdate(req.params.id, {status:globals.status.deleted}).populate('group_id').populate('supplier_id').lean().exec((err, data) => {
      if (err) return next(err);
      if (data) {
        res.json({status: 'OK'});
      }
      else {
        res.status(404).json({status: 'Not found'});
      }
    });
  });
});

router.put('/material/restore/' + IdValidate.parameter(), (req, res, next) => {
  if (!req.auth(res, ['maintain', 'admin'], 'basic')) return;

  MaterialModel.findByIdAndUpdate(req.params.id, {status: globals.status.new}).lean().exec((err, data) => {
    if (err) return next(err);

    if (!data) {
      return res.status(404).json({status: 'Not found'});
    }
    res.json({status: 'OK'});
  });
});

router.post('/material/new', async (req, res, next) => {
  if (!req.auth(res, ['write', 'maintain', 'dev', 'admin'], 'basic')) return;

  let {error, value: material} = MaterialValidate.input(req.body, 'new');
  if (error) return res400(error, res);

  if (!await nameCheck(material, res, next)) return;
  material = await groupResolve(material, next);
  if (!material) return;
  material = await supplierResolve(material, next);
  if (!material) return;


  material.status = globals.status.new;  // set status to new
  await new MaterialModel(material).save(async (err, data) => {
    if (err) return next(err);
    await data.populate('group_id').populate('supplier_id').execPopulate().catch(err => next(err));
    if (data instanceof Error) return;
    res.json(MaterialValidate.output(data.toObject()));
  });
});

router.get('/material/groups', (req, res, next) => {
  if (!req.auth(res, ['read', 'write', 'maintain', 'dev', 'admin'], 'all')) return;

  MaterialGroupModel.find().lean().exec((err, data: any) => {
    if (err) return next(err);

    res.json(_.compact(data.map(e => MaterialValidate.outputGroups(e.name))));  // validate all and filter null values from validation errors
  });
});

router.get('/material/suppliers', (req, res, next) => {
  if (!req.auth(res, ['read', 'write', 'maintain', 'dev', 'admin'], 'all')) return;

  MaterialSupplierModel.find().lean().exec((err, data: any) => {
    if (err) return next(err);

    res.json(_.compact(data.map(e => MaterialValidate.outputSuppliers(e.name))));  // validate all and filter null values from validation errors
  });
});


module.exports = router;


async function nameCheck (material, res, next) {  // check if name was already taken
  const materialData = await MaterialModel.findOne({name: material.name}).lean().exec().catch(err => next(err)) as any;
  if (materialData instanceof Error) return false;
  if (materialData) {  // could not find material_id
    res.status(400).json({status: 'Material name already taken'});
    return false;
  }
  return true;
}

async function groupResolve (material, next) {
  const groupData = await MaterialGroupModel.findOneAndUpdate({name: material.group}, {name: material.group}, {upsert: true, new: true}).lean().exec().catch(err => next(err)) as any;
  if (groupData instanceof Error) return false;
  material.group_id = groupData._id;
  delete material.group;
  return material;
}

async function supplierResolve (material, next) {
  const supplierData = await MaterialSupplierModel.findOneAndUpdate({name: material.supplier}, {name: material.supplier}, {upsert: true, new: true}).lean().exec().catch(err => next(err)) as any;
  if (supplierData instanceof Error) return false;
  material.supplier_id = supplierData._id;
  delete material.supplier;
  return material;
}