import { findAll, currentRouteName, find, visit } from '@ember/test-helpers';
import { module, test } from 'qunit';
import { setupApplicationTest } from 'ember-qunit';
import { setupMirage } from 'ember-cli-mirage/test-support';
import { setupIntl, t } from 'ember-intl/test-support';import switchTab from 'croodle/tests/helpers/switch-tab';
import PollEvaluationPage from 'croodle/tests/pages/poll/evaluation';
import { assign } from '@ember/polyfills';
import { DateTime } from 'luxon';

module('Acceptance | view evaluation', function(hooks) {
  hooks.beforeEach(function() {
    window.localStorage.setItem('locale', 'en');
  });

  setupApplicationTest(hooks);
  setupIntl(hooks);
  setupMirage(hooks);

  test('evaluation summary is not present for poll without participants', async function(assert) {
    let encryptionKey = 'abcdefghijklmnopqrstuvwxyz0123456789';
    let poll = this.server.create('poll', {
      encryptionKey
    });

    await visit(`/poll/${poll.id}?encryptionKey=${encryptionKey}`);
    assert.equal(currentRouteName(), 'poll.participation');

    await switchTab('evaluation');
    assert.equal(findAll('.tab-content .tab-pane .evaluation-summary').length, 0, 'evaluation summary is not present');
  });

  test('evaluation is correct for FindADate (date-only)', async function(assert) {
    let encryptionKey = 'abcdefghijklmnopqrstuvwxyz0123456789';
    let user1 = this.server.create('user', {
      id: "1-1",
      creationDate: DateTime.local().minus({ months: 8, weeks: 3 }).toISO(),
      encryptionKey,
      name: 'Maximilian',
      selections: [
        {
          type: 'yes',
          labelTranslation: 'answerTypes.yes.label',
          icon: 'glyphicon glyphicon-thumbs-up',
          label: 'Yes'
        },
        {
          type: 'yes',
          labelTranslation: 'answerTypes.yes.label',
          icon: 'glyphicon glyphicon-thumbs-up',
          label: 'Yes'
        }
      ]
    });
    let user2 = this.server.create('user', {
      id: "1-2",
      creationDate: DateTime.local().minus({ months: 3, weeks: 2 }).toISO(),
      encryptionKey,
      name: 'Peter',
      selections: [
        {
          type: 'no',
          labelTranslation: 'answerTypes.no.label',
          icon: 'glyphicon glyphicon-thumbs-down',
          label: 'No'
        },
        {
          type: 'yes',
          labelTranslation: 'answerTypes.yes.label',
          icon: 'glyphicon glyphicon-thumbs-up',
          label: 'Yes'
        }
      ]
    });
    let poll = this.server.create('poll', {
      id: '1',
      answers: [
        {
          type: 'yes',
          labelTranslation: 'answerTypes.yes.label',
          icon: 'glyphicon glyphicon-thumbs-up',
          label: 'Yes'
        },
        {
          type: 'no',
          labelTranslation: 'answerTypes.no.label',
          icon: 'glyphicon glyphicon-thumbs-down',
          label: 'No'
        }
      ],
      encryptionKey,
      options: [
        { title: '2015-12-12' },
        { title: '2016-01-01' }
      ],
      users: [user1, user2]
    });

    await visit(`/poll/${poll.id}/evaluation?encryptionKey=${encryptionKey}`);
    assert.equal(currentRouteName(), 'poll.evaluation');
    assert.equal(findAll('.tab-content .tab-pane .evaluation-summary').length, 1, 'evaluation summary is present');
    assert.equal(
      find('.participants').textContent.trim(),
      t('poll.evaluation.participants', { count: 2 }).toString(),
      'shows number of participants'
    );
    assert.equal(
      find('.best-options strong').textContent.trim(),
      'Friday, January 1, 2016',
      'shows option most participants replied with yes to as best option'
    );
    assert.equal(
      find('.last-participation').textContent.trim(),
      t('poll.evaluation.lastParticipation', {
        ago: '3 months ago'
      }).toString(),
      'shows last participation date'
    );

    assert.deepEqual(
      findAll('table thead tr th').map((el) => el.textContent.trim()),
      ['', 'Saturday, December 12, 2015', 'Friday, January 1, 2016'],
      'lists dates as table header of parcipants table'
    );

    assert
      .dom('[data-test-participant="1-1"] [data-test-value-for="name"]')
      .hasText('Maximilian', 'shows expected name of first participant in participants table');
    assert
      .dom('[data-test-participant="1-2"] [data-test-value-for="name"]')
      .hasText('Peter', 'shows expected name of second participant in participants table');

    assert
      .dom('[data-test-participant="1-1"] [data-test-value-for="2015-12-12"]')
      .hasText('Yes', 'shows expected selection for first option of first participant');
    assert
      .dom('[data-test-participant="1-1"] [data-test-value-for="2016-01-01"]')
      .hasText('Yes', 'shows expected selection for second option of first participant');


    assert
      .dom('[data-test-participant="1-2"] [data-test-value-for="2015-12-12"]')
      .hasText('No', 'shows expected selection for first option of second participant');
    assert
      .dom('[data-test-participant="1-2"] [data-test-value-for="2016-01-01"]')
      .hasText('Yes', 'shows expected selection for second option of second participant');

    assert.deepEqual(
      findAll('[data-test-participant] [data-test-value-for="name"]').map((el) => el.textContent.trim()),
      ['Maximilian', 'Peter'],
      'Participants are ordered as correctly in participants table'
    );
  });

  test('evaluation is correct for FindADate (datetime)', async function(assert) {
    let encryptionKey = 'abcdefghijklmnopqrstuvwxyz0123456789';
    let user1 = this.server.create('user', {
      id: "1-1",
      creationDate: DateTime.local().minus({ months: 8, weeks: 3 }).toISO(),
      encryptionKey,
      name: 'Maximilian',
      selections: [
        {
          type: 'yes',
          labelTranslation: 'answerTypes.yes.label',
          icon: 'glyphicon glyphicon-thumbs-up',
          label: 'Yes'
        },
        {
          type: 'yes',
          labelTranslation: 'answerTypes.yes.label',
          icon: 'glyphicon glyphicon-thumbs-up',
          label: 'Yes'
        },
        {
          type: 'no',
          labelTranslation: 'answerTypes.no.label',
          icon: 'glyphicon glyphicon-thumbs-down',
          label: 'No'
        },
      ]
    });
    let user2 = this.server.create('user', {
      id: "1-2",
      creationDate: DateTime.local().minus({ months: 3, weeks: 2 }).toISO(),
      encryptionKey,
      name: 'Peter',
      selections: [
        {
          type: 'no',
          labelTranslation: 'answerTypes.no.label',
          icon: 'glyphicon glyphicon-thumbs-down',
          label: 'No'
        },
        {
          type: 'yes',
          labelTranslation: 'answerTypes.yes.label',
          icon: 'glyphicon glyphicon-thumbs-up',
          label: 'Yes'
        },
        {
          type: 'yes',
          labelTranslation: 'answerTypes.yes.label',
          icon: 'glyphicon glyphicon-thumbs-up',
          label: 'Yes'
        }
      ]
    });
    let poll = this.server.create('poll', {
      id: '1',
      answers: [
        {
          type: 'yes',
          labelTranslation: 'answerTypes.yes.label',
          icon: 'glyphicon glyphicon-thumbs-up',
          label: 'Yes'
        },
        {
          type: 'no',
          labelTranslation: 'answerTypes.no.label',
          icon: 'glyphicon glyphicon-thumbs-down',
          label: 'No'
        }
      ],
      encryptionKey,
      options: [
        { title: DateTime.fromISO('2015-12-12T06:06').toISO() },
        { title: DateTime.fromISO('2015-12-12T12:12').toISO() },
        { title: DateTime.fromISO('2016-01-01T18:18').toISO() }
      ],
      users: [user1, user2]
    });

    await visit(`/poll/${poll.id}/evaluation?encryptionKey=${encryptionKey}`);
    assert.equal(currentRouteName(), 'poll.evaluation');
    assert.equal(findAll('.tab-content .tab-pane .evaluation-summary').length, 1, 'evaluation summary is present');
    assert.equal(
      find('.participants').textContent.trim(),
      t('poll.evaluation.participants', { count: 2 }).toString(),
      'shows number of participants'
    );
    assert.equal(
      find('.best-options strong').textContent.trim(),
      'Saturday, December 12, 2015 at 12:12 PM',
      'shows option most participants replied with yes to as best option'
    );
    assert.equal(
      find('.last-participation').textContent.trim(),
      t('poll.evaluation.lastParticipation', {
        ago: '3 months ago'
      }).toString(),
      'shows last participation date'
    );

    assert.deepEqual(
      findAll('table thead tr:first-child th').map((el) => el.textContent.trim()),
      ['', 'Saturday, December 12, 2015', 'Friday, January 1, 2016'],
      'lists days as first row in table header of parcipants table'
    );
    assert.deepEqual(
      findAll('table thead tr:last-child th').map((el) => el.textContent.trim()),
      ['', '6:06 AM', '12:12 PM', '6:18 PM'],
      'lists times as second row in table header of parcipants table'
    );

    assert
      .dom('[data-test-participant="1-1"] [data-test-value-for="name"]')
      .hasText('Maximilian', 'shows expected name of first participant in participants table');
    assert
      .dom('[data-test-participant="1-2"] [data-test-value-for="name"]')
      .hasText('Peter', 'shows expected name of second participant in participants table');

    assert
      .dom(`[data-test-participant="1-1"] [data-test-value-for="${DateTime.fromISO('2015-12-12T06:06').toISO()}"]`)
      .hasText('Yes', 'shows expected selection for first option of first participant');
    assert
      .dom(`[data-test-participant="1-1"] [data-test-value-for="${DateTime.fromISO('2015-12-12T12:12').toISO()}"]`)
      .hasText('Yes', 'shows expected selection for second option of first participant');
    assert
      .dom(`[data-test-participant="1-1"] [data-test-value-for="${DateTime.fromISO('2016-01-01T18:18').toISO()}"]`)
      .hasText('No', 'shows expected selection for third option of first participant');


    assert
      .dom(`[data-test-participant="1-2"] [data-test-value-for="${DateTime.fromISO('2015-12-12T06:06').toISO()}"]`)
      .hasText('No', 'shows expected selection for first option of second participant');
    assert
      .dom(`[data-test-participant="1-2"] [data-test-value-for="${DateTime.fromISO('2015-12-12T12:12').toISO()}"]`)
      .hasText('Yes', 'shows expected selection for second option of second participant');
    assert
      .dom(`[data-test-participant="1-2"] [data-test-value-for="${DateTime.fromISO('2016-01-01T18:18').toISO()}"]`)
      .hasText('Yes', 'shows expected selection for third option of second participant');

    assert.deepEqual(
      findAll('[data-test-participant] [data-test-value-for="name"]').map((el) => el.textContent.trim()),
      ['Maximilian', 'Peter'],
      'Participants are ordered as correctly in participants table'
    );
  });

  test('evaluation is correct for MakeAPoll', async function(assert) {
    let encryptionKey = 'abcdefghijklmnopqrstuvwxyz0123456789';
    let usersData = [
      {
        creationDate: DateTime.local().minus({ weeks: 5 }).toISO(),
        encryptionKey,
        name: 'Maximilian',
        selections: [
          {
            type: 'yes',
            labelTranslation: 'answerTypes.yes.label',
            icon: 'glyphicon glyphicon-thumbs-up',
            label: 'Yes'
          },
          {
            type: 'yes',
            labelTranslation: 'answerTypes.yes.label',
            icon: 'glyphicon glyphicon-thumbs-up',
            label: 'Yes'
          }
        ]
      },
      {
        creationDate: DateTime.local().minus({ days: 3 }).toISO(),
        encryptionKey,
        name: 'Peter',
        selections: [
          {
            type: 'no',
            labelTranslation: 'answerTypes.no.label',
            icon: 'glyphicon glyphicon-thumbs-down',
            label: 'No'
          },
          {
            type: 'yes',
            labelTranslation: 'answerTypes.yes.label',
            icon: 'glyphicon glyphicon-thumbs-up',
            label: 'Yes'
          }
        ]
      },
    ];
    let pollData = {
      answers: [
        {
          type: 'yes',
          labelTranslation: 'answerTypes.yes.label',
          icon: 'glyphicon glyphicon-thumbs-up',
          label: 'Yes'
        },
        {
          type: 'no',
          labelTranslation: 'answerTypes.no.label',
          icon: 'glyphicon glyphicon-thumbs-down',
          label: 'No'
        }
      ],
      encryptionKey,
      options: [
        { title: 'first option' },
        { title: 'second option' }
      ],
      pollType: 'MakeAPoll',
    };
    let poll = this.server.create('poll', assign(pollData, { users: usersData.map((_) => this.server.create('user', _)) }));

    await visit(`/poll/${poll.id}/evaluation?encryptionKey=${encryptionKey}`);
    assert.equal(currentRouteName(), 'poll.evaluation');
    assert.equal(findAll('.tab-content .tab-pane .evaluation-summary').length, 1, 'evaluation summary is present');
    assert.equal(
      find('.participants').textContent.trim(),
      t('poll.evaluation.participants', { count: 2 }).toString(),
      'participants are counted correctly'
    );
    assert.equal(
      find('.best-options strong').textContent.trim(),
      'second option',
      'options are evaluated correctly'
    );

    assert.deepEqual(
      PollEvaluationPage.options.map((_) => _.label),
      ['first option', 'second option'],
      'dates are used as table headers'
    );
    assert.deepEqual(
      PollEvaluationPage.participants.map((_) => _.name), usersData.map((_) => _.name),
      'users are listed in participants table with their names'
    );
    usersData.forEach((user) => {
      let participant = PollEvaluationPage.participants.filterBy('name', user.name)[0];
      assert.deepEqual(
        participant.selections.map((_) => _.answer),
        user.selections.map((_) => t(_.labelTranslation).toString()),
        `answers are shown for user ${user.name} in participants table`
      );
    });

    assert.equal(
      find('.last-participation').textContent.trim(),
      t('poll.evaluation.lastParticipation', {
        ago: '3 days ago'
      }).toString(),
      'last participation is evaluated correctly'
    );
  });

  test('could open evaluation by tab from poll participation', async function(assert) {
    let encryptionKey = 'abcdefghijklmnopqrstuvwxyz0123456789';
    let poll = this.server.create('poll', {
      answers: [
        {
          type: 'yes',
          labelTranslation: 'answerTypes.yes.label',
          icon: 'glyphicon glyphicon-thumbs-up',
          label: 'Yes'
        },
        {
          type: 'no',
          labelTranslation: 'answerTypes.no.label',
          icon: 'glyphicon glyphicon-thumbs-down',
          label: 'No'
        }
      ],
      encryptionKey,
      options: [
        { title: '2015-12-12' },
        { title: '2016-01-01' }
      ],
      users: [
        this.server.create('user', {
          creationDate: '2015-01-01T00:00:00.000Z',
          encryptionKey,
          name: 'Maximilian',
          selections: [
            {
              type: 'yes',
              labelTranslation: 'answerTypes.yes.label',
              icon: 'glyphicon glyphicon-thumbs-up',
              label: 'Yes'
            },
            {
              type: 'yes',
              labelTranslation: 'answerTypes.yes.label',
              icon: 'glyphicon glyphicon-thumbs-up',
              label: 'Yes'
            }
          ]
        }),
        this.server.create('user', {
          creationDate: '2015-08-01T00:00:00.000Z',
          encryptionKey,
          name: 'Peter',
          selections: [
            {
              type: 'yes',
              labelTranslation: 'answerTypes.yes.label',
              icon: 'glyphicon glyphicon-thumbs-up',
              label: 'Yes'
            },
            {
              id: 'no',
              labelTranslation: 'answerTypes.yes.label',
              icon: 'glyphicon glyphicon-thumbs-up',
              label: 'Yes'
            }
          ]
        })
      ]
    });

    await visit(`/poll/${poll.id}?encryptionKey=${encryptionKey}`);
    assert.equal(currentRouteName(), 'poll.participation');

    await switchTab('evaluation');
    assert.equal(currentRouteName(), 'poll.evaluation');
    assert.equal(
      find('.tab-pane h2').textContent.trim(),
      t('poll.evaluation.label').toString(),
      'headline is there'
    );
  });
});