import should from 'should/as-function';
import TemplateTreatmentModel from '../models/treatment_template';
import TemplateMeasurementModel from '../models/measurement_template';
import TestHelper from "../helpers/test";


describe('/template', () => {
  let server;
  before(done => TestHelper.before(done));
  beforeEach(done => server = TestHelper.beforeEach(server, done));
  afterEach(done => TestHelper.afterEach(server, done));

  describe('/template/treatment', () => {
    describe('GET /template/treatments', () => {
      it('returns all treatment templates', done => {
        TestHelper.request(server, done, {
          method: 'get',
          url: '/template/treatments',
          auth: {basic: 'janedoe'},
          httpStatus: 200
        }).end((err, res) => {
          if (err) return done(err);
          const json = require('../test/db.json');
          should(res.body).have.lengthOf(json.collections.treatment_templates.length);
          should(res.body).matchEach(treatment => {
            should(treatment).have.only.keys('_id', 'name', 'parameters');
            should(treatment).have.property('_id').be.type('string');
            should(treatment).have.property('name').be.type('string');
            should(treatment.parameters).matchEach(number => {
              should(number).have.only.keys('name', 'range');
              should(number).have.property('name').be.type('string');
              should(number).have.property('range').be.type('object');
            });
          });
          done();
        });
      });
      it('rejects an API key', done => {
        TestHelper.request(server, done, {
          method: 'get',
          url: '/template/treatments',
          auth: {key: 'janedoe'},
          httpStatus: 401
        });
      });
      it('rejects unauthorized requests', done => {
        TestHelper.request(server, done, {
          method: 'get',
          url: '/template/treatments',
          httpStatus: 401
        });
      });
    });

    describe('GET /template/treatment/{name}', () => {
      it('returns the right treatment template', done => {
        TestHelper.request(server, done, {
          method: 'get',
          url: '/template/treatment/heat%20treatment',
          auth: {basic: 'janedoe'},
          httpStatus: 200,
          res: {_id: '200000000000000000000001', name: 'heat treatment', parameters: [{name: 'material', range: {values: ['copper', 'hot air']}}, {name: 'weeks', range: {min: 1, max: 10}}]}
        });
      });
      it('rejects an API key', done => {
        TestHelper.request(server, done, {
          method: 'get',
          url: '/template/treatment/heat%20treatment',
          auth: {key: 'janedoe'},
          httpStatus: 401
        });
      });
      it('rejects an unknown name', done => {
        TestHelper.request(server, done, {
          method: 'get',
          url: '/template/treatment/xxx',
          auth: {basic: 'janedoe'},
          httpStatus: 404
        });
      });
      it('rejects unauthorized requests', done => {
        TestHelper.request(server, done, {
          method: 'get',
          url: '/template/treatment/heat%20treatment',
          httpStatus: 401
        });
      });
    });

    describe('PUT /template/treatment/{name}', () => {
      it('returns the right treatment template', done => {
        TestHelper.request(server, done, {
          method: 'put',
          url: '/template/treatment/heat%20treatment',
          auth: {basic: 'admin'},
          httpStatus: 200,
          req: {},
          res: {_id: '200000000000000000000001', name: 'heat treatment', parameters: [{name: 'material', range: {values: ['copper', 'hot air']}}, {name: 'weeks', range: {min: 1, max: 10}}]}
        });
      });
      it('keeps unchanged properties', done => {
        TestHelper.request(server, done, {
          method: 'put',
          url: '/template/treatment/heat%20treatment',
          auth: {basic: 'admin'},
          httpStatus: 200,
          req: {name: 'heat treatment', parameters: [{name: 'material', range: {values: ['copper', 'hot air']}}, {name: 'weeks', range: {min: 1, max: 10}}]},
          res: {_id: '200000000000000000000001', name: 'heat treatment', parameters: [{name: 'material', range: {values: ['copper', 'hot air']}}, {name: 'weeks', range: {min: 1, max: 10}}]}
        });
      });
      it('changes the given properties', done => {
        TestHelper.request(server, done, {
          method: 'put',
          url: '/template/treatment/heat%20treatment',
          auth: {basic: 'admin'},
          httpStatus: 200,
          req: {name: 'heat aging', parameters: [{name: 'time', range: {min: 1}}]}
        }).end((err, res) => {
            if (err) return done(err);
            should(res.body).be.eql({_id: '200000000000000000000001', name: 'heat aging', parameters: [{name: 'time', range: {min: 1}}]});
            TemplateTreatmentModel.find({name: 'heat aging'}).lean().exec((err, data:any) => {
              if (err) return done(err);
              should(data).have.lengthOf(1);
              should(data[0]).have.only.keys('_id', 'name', 'parameters');
              should(data[0]).have.property('name', 'heat aging');
              should(data[0]).have.property('parameters').have.lengthOf(1);
              should(data[0].parameters[0]).have.property('name', 'time');
              should(data[0].parameters[0]).have.property('range');
              should(data[0].parameters[0].range).have.property('min', 1);
              done();
            });
          });
      });
      it('supports values ranges', done => {
        TestHelper.request(server, done, {
          method: 'put',
          url: '/template/treatment/heat%20treatment',
          auth: {basic: 'admin'},
          httpStatus: 200,
          req: {parameters: [{name: 'time', range: {values: [1, 2, 5]}}]},
          res: {_id: '200000000000000000000001', name: 'heat treatment', parameters: [{name: 'time', range: {values: [1, 2, 5]}}]}
        });
      });
      it('supports min max ranges', done => {
        TestHelper.request(server, done, {
          method: 'put',
          url: '/template/treatment/heat%20treatment',
          auth: {basic: 'admin'},
          httpStatus: 200,
          req: {parameters: [{name: 'time', range: {min: 1, max: 11}}]},
          res: {_id: '200000000000000000000001', name: 'heat treatment', parameters: [{name: 'time', range: {min: 1, max: 11}}]}
        });
      });
      it('supports empty ranges', done => {
        TestHelper.request(server, done, {
          method: 'put',
          url: '/template/treatment/heat%20treatment',
          auth: {basic: 'admin'},
          httpStatus: 200,
          req: {parameters: [{name: 'time', range: {}}]},
          res: {_id: '200000000000000000000001', name: 'heat treatment', parameters: [{name: 'time', range: {}}]}
        });
      });
      it('adds a new template for an unknown name', done => {
        TestHelper.request(server, done, {
          method: 'put',
          url: '/template/treatment/heat%20aging',
          auth: {basic: 'admin'},
          httpStatus: 200,
          req: {name: 'heat aging', parameters: [{name: 'time', range: {min: 1}}]}
        }).end(err => {
          if (err) return done(err);
          TemplateTreatmentModel.find({name: 'heat aging'}).lean().exec((err, data:any) => {
            if (err) return done(err);
            should(data).have.lengthOf(1);
            should(data[0]).have.only.keys('_id', 'name', 'parameters', '__v');
            should(data[0]).have.property('name', 'heat aging');
            should(data[0].parameters[0]).have.property('name', 'time');
            should(data[0].parameters[0]).have.property('range');
            should(data[0].parameters[0].range).have.property('min', 1);
            done();
          });
        });
      });
      it('rejects a missing name for a new name', done => {
        TestHelper.request(server, done, {
          method: 'put',
          url: '/template/treatment/heat%20aging',
          auth: {basic: 'admin'},
          httpStatus: 400,
          req: {parameters: [{name: 'time', range: {min: 1}}]},
          res: {status: 'Invalid body format', details: '"name" is required'}
        });
      });
      it('rejects missing parameters for a new name', done => {
        TestHelper.request(server, done, {
          method: 'put',
          url: '/template/treatment/heat%20aging',
          auth: {basic: 'admin'},
          httpStatus: 400,
          req: {name: 'heat aging'},
          res: {status: 'Invalid body format', details: '"parameters" is required'}
        });
      });
      it('rejects a missing parameter name for a new name', done => {
        TestHelper.request(server, done, {
          method: 'put',
          url: '/template/treatment/heat%20aging',
          auth: {basic: 'admin'},
          httpStatus: 400,
          req: {name: 'heat aging', parameters: [{range: {min: 1}}]},
          res: {status: 'Invalid body format', details: '"parameters[0].name" is required'}
        });
      });
      it('rejects a missing parameter range for a new name', done => {
        TestHelper.request(server, done, {
          method: 'put',
          url: '/template/treatment/heat%20aging',
          auth: {basic: 'admin'},
          httpStatus: 400,
          req: {name: 'heat aging', parameters: [{name: 'time'}]},
          res: {status: 'Invalid body format', details: '"parameters[0].range" is required'}
        });
      });
      it('rejects a an invalid parameter range property for a new name', done => {
        TestHelper.request(server, done, {
          method: 'put',
          url: '/template/treatment/heat%20aging',
          auth: {basic: 'admin'},
          httpStatus: 400,
          req: {name: 'heat aging', parameters: [{name: 'time', range: {xx: 1}}]},
          res: {status: 'Invalid body format', details: '"parameters[0].range.xx" is not allowed'}
        });
      });
      it('rejects already existing names', done => {
        TestHelper.request(server, done, {
          method: 'put',
          url: '/template/treatment/heat%20treatment',
          auth: {basic: 'admin'},
          httpStatus: 400,
          req: {name: 'heat treatment 2', parameters: [{name: 'time', range: {min: 1}}]},
          res: {status: 'Template name already taken'}
        });
      });
      it('rejects wrong properties', done => {
        TestHelper.request(server, done, {
          method: 'put',
          url: '/template/treatment/heat%20aging',
          auth: {basic: 'admin'},
          httpStatus: 400,
          req: {parameters: [{name: 'time'}], xx: 33},
          res: {status: 'Invalid body format', details: '"name" is required'}
        });
      });
      it('rejects an API key', done => {
        TestHelper.request(server, done, {
          method: 'put',
          url: '/template/treatment/heat%20treatment',
          auth: {key: 'admin'},
          httpStatus: 401,
          req: {}
        });
      });
      it('rejects requests from a write user', done => {
        TestHelper.request(server, done, {
          method: 'put',
          url: '/template/treatment/heat%20treatment',
          auth: {basic: 'janedoe'},
          httpStatus: 403,
          req: {}
        });
      });
      it('rejects unauthorized requests', done => {
        TestHelper.request(server, done, {
          method: 'put',
          url: '/template/treatment/heat%20treatment',
          httpStatus: 401,
          req: {}
        });
      });
    });

    describe('DELETE /template/treatment/{name}', () => {
      it('deletes the template', done => {
        TestHelper.request(server, done, {
          method: 'delete',
          url: '/template/treatment/heat%20treatment',
          auth: {basic: 'admin'},
          httpStatus: 200
        }).end((err, res) => {
          if (err) return done(err);
          should(res.body).be.eql({status: 'OK'});
          TemplateTreatmentModel.find({name: 'heat treatment'}).lean().exec((err, data:any) => {
            if (err) return done(err);
            should(data).have.lengthOf(0);
            done();
          });
        });
      });
      it('rejects deleting a template still in use');
      it('rejects an API key', done => {
        TestHelper.request(server, done, {
          method: 'delete',
          url: '/template/treatment/heat%20treatment',
          auth: {key: 'admin'},
          httpStatus: 401
        });
      });
      it('rejects requests from a write user', done => {
        TestHelper.request(server, done, {
          method: 'delete',
          url: '/template/treatment/heat%20treatment',
          auth: {basic: 'janedoe'},
          httpStatus: 403
        })
      });
      it('returns 404 for an unknown name', done => {
        TestHelper.request(server, done, {
          method: 'delete',
          url: '/template/treatment/xxx',
          auth: {basic: 'admin'},
          httpStatus: 404
        })
      });
      it('rejects unauthorized requests', done => {
        TestHelper.request(server, done, {
          method: 'delete',
          url: '/template/treatment/heat%20treatment',
          httpStatus: 401
        })
      });
    });
  });

  describe('/template/measurement', () => {
    describe('GET /template/measurements', () => {
      it('returns all measurement templates', done => {
        TestHelper.request(server, done, {
          method: 'get',
          url: '/template/measurements',
          auth: {basic: 'janedoe'},
          httpStatus: 200
        }).end((err, res) => {
          if (err) return done(err);
          const json = require('../test/db.json');
          should(res.body).have.lengthOf(json.collections.measurement_templates.length);
          should(res.body).matchEach(measurement => {
            should(measurement).have.only.keys('_id', 'name', 'parameters');
            should(measurement).have.property('_id').be.type('string');
            should(measurement).have.property('name').be.type('string');
            should(measurement.parameters).matchEach(number => {
              should(number).have.only.keys('name', 'range');
              should(number).have.property('name').be.type('string');
              should(number).have.property('range').be.type('object');
            });
          });
          done();
        });
      });
      it('rejects an API key', done => {
        TestHelper.request(server, done, {
          method: 'get',
          url: '/template/measurements',
          auth: {key: 'janedoe'},
          httpStatus: 401
        });
      });
      it('rejects unauthorized requests', done => {
        TestHelper.request(server, done, {
          method: 'get',
          url: '/template/measurements',
          httpStatus: 401
        });
      });
    });

    describe('GET /template/measurement/{name}', () => {
      it('returns the right measurement template', done => {
        TestHelper.request(server, done, {
          method: 'get',
          url: '/template/measurement/spectrum',
          auth: {basic: 'janedoe'},
          httpStatus: 200,
          res: {_id: '300000000000000000000001', name: 'spectrum', parameters: [{name: 'dpt', range: {}}]}
        });
      });
      it('rejects an API key', done => {
        TestHelper.request(server, done, {
          method: 'get',
          url: '/template/measurement/spectrum',
          auth: {key: 'janedoe'},
          httpStatus: 401
        });
      });
      it('rejects an unknown name', done => {
        TestHelper.request(server, done, {
          method: 'get',
          url: '/template/measurement/xxx',
          auth: {basic: 'janedoe'},
          httpStatus: 404
        });
      });
      it('rejects unauthorized requests', done => {
        TestHelper.request(server, done, {
          method: 'get',
          url: '/template/measurement/spectrum',
          httpStatus: 401
        });
      });
    });

    describe('PUT /template/measurement/{name}', () => {
      it('returns the right measurement template', done => {
        TestHelper.request(server, done, {
          method: 'put',
          url: '/template/measurement/spectrum',
          auth: {basic: 'admin'},
          httpStatus: 200,
          req: {},
          res: {_id: '300000000000000000000001', name: 'spectrum', parameters: [{name: 'dpt', range: {}}]}
        });
      });
      it('keeps unchanged properties', done => {
        TestHelper.request(server, done, {
          method: 'put',
          url: '/template/measurement/spectrum',
          auth: {basic: 'admin'},
          httpStatus: 200,
          req: {name: 'spectrum', parameters: [{name: 'dpt', range: {}}]},
          res: {_id: '300000000000000000000001', name: 'spectrum', parameters: [{name: 'dpt', range: {}}]}
        });
      });
      it('changes the given properties', done => {
        TestHelper.request(server, done, {
          method: 'put',
          url: '/template/measurement/spectrum',
          auth: {basic: 'admin'},
          httpStatus: 200,
          req: {name: 'IR spectrum', parameters: [{name: 'data point table', range: {min: 0, max: 1000}}]},
        }).end((err, res) => {
          if (err) return done(err);
          should(res.body).be.eql({_id: '300000000000000000000001', name: 'IR spectrum', parameters: [{name: 'data point table', range: {min: 0, max: 1000}}]});
          TemplateMeasurementModel.find({name: 'IR spectrum'}).lean().exec((err, data:any) => {
            if (err) return done(err);
            should(data).have.lengthOf(1);
            should(data[0]).have.only.keys('_id', 'name', 'parameters');
            should(data[0]).have.property('name', 'IR spectrum');
            should(data[0]).have.property('parameters').have.lengthOf(1);
            should(data[0].parameters[0]).have.property('name', 'data point table');
            should(data[0].parameters[0]).have.property('range');
            should(data[0].parameters[0].range).have.property('min', 0);
            should(data[0].parameters[0].range).have.property('max', 1000);
            done();
          });
        });
      });
      it('supports values ranges', done => {
        TestHelper.request(server, done, {
          method: 'put',
          url: '/template/measurement/spectrum',
          auth: {basic: 'admin'},
          httpStatus: 200,
          req: {parameters: [{name: 'dpt', range: {values: [1, 2, 5]}}]},
          res: {_id: '300000000000000000000001', name: 'spectrum', parameters: [{name: 'dpt', range: {values: [1, 2, 5]}}]}
        });
      });
      it('supports min max ranges', done => {
        TestHelper.request(server, done, {
          method: 'put',
          url: '/template/measurement/spectrum',
          auth: {basic: 'admin'},
          httpStatus: 200,
          req: {parameters: [{name: 'dpt', range: {min: 0, max: 1000}}]},
          res: {_id: '300000000000000000000001', name: 'spectrum', parameters: [{name: 'dpt', range: {min: 0, max: 1000}}]}
        });
      });
      it('supports empty ranges', done => {
        TestHelper.request(server, done, {
          method: 'put',
          url: '/template/measurement/kf',
          auth: {basic: 'admin'},
          httpStatus: 200,
          req: {parameters: [{name: 'weight %', range: {}}]},
          res: {_id: '300000000000000000000002', name: 'kf', parameters: [{name: 'weight %', range: {}}]}
        });
      });
      it('adds a new template for an unknown name', done => {
        TestHelper.request(server, done, {
          method: 'put',
          url: '/template/measurement/vz',
          auth: {basic: 'admin'},
          httpStatus: 200,
          req: {name: 'vz', parameters: [{name: 'vz', range: {min: 1}}]}
        }).end(err => {
          if (err) return done(err);
          TemplateMeasurementModel.find({name: 'vz'}).lean().exec((err, data:any) => {
            if (err) return done(err);
            should(data).have.lengthOf(1);
            should(data[0]).have.only.keys('_id', 'name', 'parameters', '__v');
            should(data[0]).have.property('name', 'vz');
            should(data[0]).have.property('parameters').have.lengthOf(1);
            should(data[0].parameters[0]).have.property('name', 'vz');
            should(data[0].parameters[0]).have.property('range');
            should(data[0].parameters[0].range).have.property('min', 1);
            done();
          });
        });
      });
      it('rejects a missing name for a new name', done => {
        TestHelper.request(server, done, {
          method: 'put',
          url: '/template/measurement/spectrum2',
          auth: {basic: 'admin'},
          httpStatus: 400,
          req: {parameters: [{name: 'data point table', range: {min: 0, max: 1000}}]},
          res: {status: 'Invalid body format', details: '"name" is required'}
        });
      });
      it('rejects missing parameters for a new name', done => {
        TestHelper.request(server, done, {
          method: 'put',
          url: '/template/measurement/spectrum2',
          auth: {basic: 'admin'},
          httpStatus: 400,
          req: {name: 'IR spectrum'},
          res: {status: 'Invalid body format', details: '"parameters" is required'}
        });
      });
      it('rejects a missing parameter name for a new name', done => {
        TestHelper.request(server, done, {
          method: 'put',
          url: '/template/measurement/spectrum2',
          auth: {basic: 'admin'},
          httpStatus: 400,
          req: {name: 'IR spectrum', parameters: [{range: {min: 0, max: 1000}}]},
          res: {status: 'Invalid body format', details: '"parameters[0].name" is required'}
        });
      });
      it('rejects a missing parameter range for a new name', done => {
        TestHelper.request(server, done, {
          method: 'put',
          url: '/template/measurement/spectrum2',
          auth: {basic: 'admin'},
          httpStatus: 400,
          req: {name: 'IR spectrum', parameters: [{name: 'data point table'}]},
          res: {status: 'Invalid body format', details: '"parameters[0].range" is required'}
        });
      });
      it('rejects a an invalid parameter range property for a new name', done => {
        TestHelper.request(server, done, {
          method: 'put',
          url: '/template/measurement/spectrum2',
          auth: {basic: 'admin'},
          httpStatus: 400,
          req: {name: 'IR spectrum', parameters: [{name: 'data point table', range: {xx: 0}}]},
          res: {status: 'Invalid body format', details: '"parameters[0].range.xx" is not allowed'}
        });
      });
      it('rejects already existing names', done => {
        TestHelper.request(server, done, {
          method: 'put',
          url: '/template/measurement/spectrum',
          auth: {basic: 'admin'},
          httpStatus: 400,
          req: {name: 'kf', parameters: [{name: 'dpt', range: {min: 1}}]},
          res: {status: 'Template name already taken'}
        });
      });
      it('rejects wrong properties', done => {
        TestHelper.request(server, done, {
          method: 'put',
          url: '/template/measurement/spectrum',
          auth: {basic: 'admin'},
          httpStatus: 400,
          req: {parameters: [{name: 'dpt'}], xx: 33},
          res: {status: 'Invalid body format', details: '"parameters[0].range" is required'}
        });
      });
      it('rejects an API key', done => {
        TestHelper.request(server, done, {
          method: 'put',
          url: '/template/measurement/spectrum',
          auth: {key: 'admin'},
          httpStatus: 401,
          req: {}
        });
      });
      it('rejects requests from a write user', done => {
        TestHelper.request(server, done, {
          method: 'put',
          url: '/template/measurement/spectrum',
          auth: {basic: 'janedoe'},
          httpStatus: 403,
          req: {}
        });
      });
      it('rejects unauthorized requests', done => {
        TestHelper.request(server, done, {
          method: 'put',
          url: '/template/measurement/spectrum',
          httpStatus: 401,
          req: {}
        });
      });
    });

    describe('DELETE /template/measurement/{name}', () => {
      it('deletes the template', done => {
        TestHelper.request(server, done, {
          method: 'delete',
          url: '/template/measurement/spectrum',
          auth: {basic: 'admin'},
          httpStatus: 200
        }).end((err, res) => {
          if (err) return done(err);
          should(res.body).be.eql({status: 'OK'});
          TemplateMeasurementModel.find({name: 'spectrum'}).lean().exec((err, data:any) => {
            if (err) return done(err);
            should(data).have.lengthOf(0);
            done();
          });
        });
      });
      it('rejects deleting a template still in use');
      it('rejects an API key', done => {
        TestHelper.request(server, done, {
          method: 'delete',
          url: '/template/measurement/spectrum',
          auth: {key: 'admin'},
          httpStatus: 401
        });
      });
      it('rejects requests from a write user', done => {
        TestHelper.request(server, done, {
          method: 'delete',
          url: '/template/measurement/spectrum',
          auth: {basic: 'janedoe'},
          httpStatus: 403
        })
      });
      it('returns 404 for an unknown name', done => {
        TestHelper.request(server, done, {
          method: 'delete',
          url: '/template/measurement/xxx',
          auth: {basic: 'admin'},
          httpStatus: 404
        })
      });
      it('rejects unauthorized requests', done => {
        TestHelper.request(server, done, {
          method: 'delete',
          url: '/template/measurement/spectrum',
          httpStatus: 401
        })
      });
    });
  });
});