'use strict';

const { expect } = require('chai');
const { v4 } = require('uuid');
const { sequelize } = require('../../../db');

const {
  cancelParty,
  query,
  registerParty,
} = require('../../../processes/registration');

describe('VEN registration', function() {
  before(async () => {
    await sequelize.sync();
  });

  describe('registerParty', function() {
    let venId, commonName, registrationResponse;

    beforeEach(async () => {
      venId = v4()
        .replace(/-/g, '')
        .substring(0, 20)
        .toUpperCase()
        .match(/.{2}/g)
        .join(':');
      const requestId = v4().replace(/-/g, '');
      commonName = v4()
        .replace(/-/g, '')
        .substring(0, 12);
      const request = {
        requestId: requestId,
        venId: venId,
        oadrProfileName: '2.0b',
        oadrTransportName: 'simplehttp',
        oadrReportOnly: false,
        oadrXmlSignature: false,
        oadrVenName: `VEN ${commonName}`,
        oadrHttpPullModel: true,
      };
      registrationResponse = await registerParty(request, commonName, venId);
    });

    it('allows registration of a new VEN', async () => {
      expect(registrationResponse.registrationId).to.be.a('string');
    });

    it('rejects VEN with non-matching venId', async () => {
      const venId = v4()
        .replace(/-/g, '')
        .substring(0, 20)
        .toUpperCase()
        .match(/.{2}/g)
        .join(':');
      const requestId = v4().replace(/-/g, '');
      const commonName = v4()
        .replace(/-/g, '')
        .substring(0, 12);
      const request = {
        requestId: requestId,
        venId: venId,
        oadrProfileName: '2.0b',
        oadrTransportName: 'simplehttp',
        oadrReportOnly: false,
        oadrXmlSignature: false,
        oadrVenName: `VEN ${commonName}`,
        oadrHttpPullModel: true,
      };

      let exception;
      try {
        await registerParty(request, commonName, `${venId}:FF`);
      } catch (e) {
        exception = e;
      }

      expect(exception).is.an('error');
      expect(exception.message).to.eql('VenID does not match certificate');
    });

    it('rejects registration when common name changes', async () => {
      const requestId = v4().replace(/-/g, '');
      const commonName2 = v4()
        .replace(/-/g, '')
        .substring(0, 12);
      const request = {
        requestId: requestId,
        venId: venId,
        oadrProfileName: '2.0b',
        oadrTransportName: 'simplehttp',
        oadrReportOnly: false,
        oadrXmlSignature: false,
        oadrVenName: `VEN ${commonName}`,
        oadrHttpPullModel: true,
      };

      let exception;
      try {
        await registerParty(request, commonName2, venId);
      } catch (e) {
        exception = e;
      }

      expect(exception).is.an('error');
      expect(exception.message).to.eql('Client certificate CN mismatch');
    });
  });

  describe('query', function() {
    let venId, commonName, queryResponse;

    beforeEach(async () => {
      venId = v4()
        .replace(/-/g, '')
        .substring(0, 20)
        .toUpperCase()
        .match(/.{2}/g)
        .join(':');
      const requestId = v4().replace(/-/g, '');
      commonName = v4()
        .replace(/-/g, '')
        .substring(0, 12);
      const request = {
        requestId: requestId,
      };
      queryResponse = await query(request, commonName, venId);
    });

    it('does not return venId or registrationId for new device', async () => {
      expect(queryResponse.registrationId).to.be.undefined;
      expect(queryResponse.venId).to.be.undefined;
    });

    it('returns registrationId if already registered', async () => {
      venId = v4()
        .replace(/-/g, '')
        .substring(0, 20)
        .toUpperCase()
        .match(/.{2}/g)
        .join(':');
      const requestId = v4().replace(/-/g, '');
      commonName = v4()
        .replace(/-/g, '')
        .substring(0, 12);
      const registerRequest = {
        requestId: requestId,
        venId: venId,
        oadrProfileName: '2.0b',
        oadrTransportName: 'simplehttp',
        oadrReportOnly: false,
        oadrXmlSignature: false,
        oadrVenName: `VEN ${commonName}`,
        oadrHttpPullModel: true,
      };
      const registrationResponse = await registerParty(
        registerRequest,
        commonName,
        venId,
      );
      const initialRegistrationId = registrationResponse.registrationId;

      const queryRequest = {
        requestId: requestId,
      };
      queryResponse = await query(queryRequest, commonName, venId);
      expect(queryResponse.registrationId).to.eql(initialRegistrationId);
      expect(queryResponse.venId).to.eql(venId);
    });
  });

  describe('cancelParty', function() {
    let venId, commonName, registrationResponse;

    beforeEach(async () => {
      venId = v4()
        .replace(/-/g, '')
        .substring(0, 20)
        .toUpperCase()
        .match(/.{2}/g)
        .join(':');
      const requestId = v4().replace(/-/g, '');
      commonName = v4()
        .replace(/-/g, '')
        .substring(0, 12);
      const request = {
        requestId: requestId,
        venId: venId,
        oadrProfileName: '2.0b',
        oadrTransportName: 'simplehttp',
        oadrReportOnly: false,
        oadrXmlSignature: false,
        oadrVenName: `VEN ${commonName}`,
        oadrHttpPullModel: true,
      };
      registrationResponse = await registerParty(request, commonName, venId);
    });

    it('successfully cancels an existing registration', async () => {
      const cancelRequestId = v4().replace(/-/g, '');
      const cancelRequest = {
        requestId: cancelRequestId,
        registrationId: registrationResponse.registrationId,
        venId: venId,
      };

      const cancelResponse = await cancelParty(
        cancelRequest,
        commonName,
        venId,
      );
      expect(cancelResponse.responseCode).to.eql('200');
      expect(cancelResponse.responseDescription).to.eql('OK');
      expect(cancelResponse.responseRequestId).to.eql(cancelRequestId);
      expect(cancelResponse.venId).to.eql(venId);
    });

    it('fails if no registrationId is specified', async () => {
      const cancelRequestId = v4().replace(/-/g, '');
      const cancelRequest = {
        requestId: cancelRequestId,
        venId: venId,
      };

      let error;
      try {
        await cancelParty(cancelRequest, commonName, venId);
      } catch (e) {
        error = e;
      }
      expect(error).to.be.an('error');
      expect(error.message).to.eql('No registrationID in request');
    });

    it('fails if venID does not match certificate', async () => {
      const otherVenId = v4().replace(/-/g, '');
      const cancelRequestId = v4().replace(/-/g, '');
      const cancelRequest = {
        requestId: cancelRequestId,
        registrationId: registrationResponse.registrationId,
        venId: venId,
      };

      let error;
      try {
        await cancelParty(cancelRequest, commonName, otherVenId);
      } catch (e) {
        error = e;
      }
      expect(error).to.be.an('error');
      expect(error.message).to.eql('VenID does not match certificate');
    });

    it('fails if no current registration to cancel', async () => {
      const cancelRequestId = v4().replace(/-/g, '');
      const cancelRequest = {
        requestId: cancelRequestId,
        registrationId: registrationResponse.registrationId,
        venId: venId,
      };

      // first cancellation
      await cancelParty(cancelRequest, commonName, venId);

      let error;
      try {
        // second cancellation
        await cancelParty(cancelRequest, commonName, venId);
      } catch (e) {
        error = e;
      }
      expect(error).to.be.an('error');
      expect(error.message).to.eql('No current registration for VenID');
    });
  });
});