const { expect } = require("@playwright/test");

const { Join } = require('../breakout/join');
const parameters = require('../core/parameters');
const { apiCall, createMeetingPromise } = require('../core/helpers');

function getMeetingInfo(meetingID) {
  return apiCall('getMeetingInfo', {meetingID: meetingID});
}

class APIBreakout extends Join {

  constructor(browser, context) {
    super(browser, context);
  }

  // Attempt to use API to create a breakout room without a parent
  async testBreakoutWithoutParent() {
    const response = await createMeetingPromise(parameters, `isBreakout=true&sequence=1`)
	  .catch(error => error);
    expect(response.response.status).toEqual(500);
  }

  // Attempt to use API to create a break room without a sequence number
  async testBreakoutWithoutSequenceNumber() {
    const response = await createMeetingPromise(parameters, `isBreakout=true&parentMeetingID=${this.modPage.meetingId}`)
	  .catch(error => error);
    expect(response.response.status).toEqual(500);
  }

  // Attempt to use API to create a break room with a non-existent parent meeting
  async testBreakoutWithNonexistentParent() {
    const response = await createMeetingPromise(parameters, `isBreakout=true&parentMeetingID=0000000&sequence=1`)
	  .catch(error => error);
    expect(response.response.status).toEqual(500);
  }

  // Check that breakout rooms created via the GUI appear properly in the API's meeting info
  async testBreakoutMeetingInfoNoJoins() {

    // We have two breakout rooms, but neither user has joined a breakout room.
    // Make sure the API getMeetingInfo returns expected results

    const response1 = await getMeetingInfo(this.modPage.meetingId);
    expect(response1.response.returncode).toEqual(['SUCCESS']);
    expect(response1.response.isBreakout).toEqual(['false']);
    expect(response1.response.breakoutRooms[0].breakout.length).toEqual(2);

    for (const breakoutRoom of response1.response.breakoutRooms[0].breakout) {
      const response2 = await getMeetingInfo(breakoutRoom);

      const expectedMeeting = {meetingID : [breakoutRoom],
			       isBreakout: ['true'],
			       running: ['false'],
			       participantCount: ['0'],
			       hasUserJoined: ['false'],
			       attendees: ['\n'],   /* no attendees; the newline is an artifact of xml2js */
			       freeJoin: ['false'],
			       sequence: [ expect.stringMatching('[12]') ],
			       parentMeetingID: response1.response.internalMeetingID,
			      };

      expect(response2.response.returncode).toEqual(['SUCCESS']);
      expect(response2.response).toMatchObject(expectedMeeting);
    }
  }

  async testBreakoutMeetingInfoOneJoin() {

    // We have two breakout rooms, and one user has joined a breakout room.
    // Make sure the API getMeetingInfo returns expected results

    // First, check that we can retrieve the parent meeting

    const response1 = await getMeetingInfo(this.modPage.meetingId);
    expect(response1.response.returncode).toEqual(['SUCCESS']);
    expect(response1.response.isBreakout).toEqual(['false']);

    // Then, check that the parent meeting lists two breakout rooms

    const breakoutRooms = response1.response.breakoutRooms[0].breakout;
    expect(breakoutRooms.length).toEqual(2);

    // Retrieve meeting info for both breakout rooms

    // Attendee, a VIEWER in the parent meeting, becomes a MODERATOR (and presenter) in the breakout room

    const expectedUser = expect.objectContaining({fullName: ['Attendee'],
						  role: ['MODERATOR'],
						  isPresenter: ['true'],
						 });

    const expectedMeeting1 = {isBreakout: ['true'],
			     running: ['true'],
			     participantCount: ['1'],
			     hasUserJoined: ['true'],
			     attendees: [{ attendee: [ expectedUser ] }],
			     freeJoin: ['false'],
			     sequence: [ '1' ],
			     parentMeetingID: response1.response.internalMeetingID,
			    };

    const expectedMeeting2 = {isBreakout: ['true'],
			     running: ['false'],
			     participantCount: ['0'],
			     hasUserJoined: ['false'],
			     attendees: ['\n'],   /* no attendees; the newline is an artifact of xml2js */
			     freeJoin: ['false'],
			     sequence: [ '2' ],
			     parentMeetingID: response1.response.internalMeetingID,
			    };

    const expectedResponse1 = {response: expect.objectContaining(expectedMeeting1)};
    const expectedResponse2 = {response: expect.objectContaining(expectedMeeting2)};

    // Note that this is an array of two responses from two API calls,
    // not a single API call response containing two breakout rooms

    const response2array = await Promise.all(breakoutRooms.map(getMeetingInfo));
    expect(response2array).toEqual(expect.arrayContaining([expectedResponse1, expectedResponse2]));
  }

}

exports.APIBreakout = APIBreakout;