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

import MeasurementModel from '../models/measurement';
import ConditionModel from '../models/condition';
import MeasurementTemplateModel from '../models/measurement_template';
import MeasurementValidate from './validate/measurement';
import IdValidate from './validate/id';
import res400 from './validate/res400';
import ParametersValidate from './validate/parameters';


const router = express.Router();

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

  MeasurementModel.findById(req.params.id).lean().exec((err, data) => {
    if (err) return next(err);
    if (!data) {
      return res.status(404).json({status: 'Not found'});
    }

    res.json(MeasurementValidate.output(data));
  });
});

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

  const {error, value: measurement} = MeasurementValidate.input(req.body, 'change');
  if (error) return res400(error, res);

  const data = await MeasurementModel.findById(req.params.id).lean().exec().catch(err => {next(err);}) as any;
  if (data instanceof Error) {
    return;
  }
  if (!data) {
    res.status(404).json({status: 'Not found'});
  }
  // add properties needed for conditionIdCheck
  measurement.measurement_template = data.measurement_template;
  measurement.condition_id = data.condition_id;
  if (measurement.hasOwnProperty('values') && !_.isEqual(measurement.values, data.values)) {
    measurement.status = 0;
  }
  if (!await conditionIdCheck(measurement, req, res, next)) return;
  if (measurement.values) {
    measurement.values = Object.assign(data.values, measurement.values);
  }
  if (!await templateCheck(measurement, 'change', res, next)) return;
  await MeasurementModel.findByIdAndUpdate(req.params.id, measurement, {new: true}).lean().exec((err, data) => {
    if (err) return next(err);
    res.json(MeasurementValidate.output(data));
  });
});

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

  const {error, value: measurement} = MeasurementValidate.input(req.body, 'new');
  if (error) return res400(error, res);

  if (!await conditionIdCheck(measurement, req, res, next)) return;
  if (!await templateCheck(measurement, 'new', res, next)) return;

  measurement.status = 0;
  await new MeasurementModel(measurement).save((err, data) => {
    if (err) return next(err);
    res.json(MeasurementValidate.output(data.toObject()));
  });
});


module.exports = router;


async function conditionIdCheck (measurement, req, res, next) {  // validate condition_id, returns false if invalid
  const sampleData = await ConditionModel.findById(measurement.condition_id).populate('sample_id').lean().exec().catch(err => {next(err); return false;}) as any;
  if (!sampleData) {  // sample_id not found
    res.status(400).json({status: 'Condition id not available'});
    return false
  }
  if (sampleData.sample_id.user_id.toString() !== req.authDetails.id && !req.auth(res, ['maintain', 'admin'], 'basic')) return false;  // sample does not belong to user
  return true;
}

async function templateCheck (measurement, param, res, next) {  // validate measurement_template and values
  const templateData = await MeasurementTemplateModel.findById(measurement.measurement_template).lean().exec().catch(err => {next(err); return false;}) as any;
  if (!templateData) {  // template not found
    res.status(400).json({status: 'Measurement template not available'});
    return false
  }

  // validate values
  const {error, value: ignore} = ParametersValidate.input(measurement.values, templateData.parameters, param);
  console.log(error);
  if (error) {res400(error, res); return false;}
  return true;
}