import { Injectable } from '@angular/core';
import { GCMockModule } from '@core/mocks/gc-module.mock';
import { AfterEach, BeforeEach, Spec, TestCase } from '@yourcause/test-decorators';
import { DescribeAngularService } from '@yourcause/test-decorators/angular';
import { expect, spy } from 'chai';
import { ReleaseNoteFromApi } from '../release-notes.typing';
import { ReleaseNoteService } from './release-notes.service';

@Injectable({ providedIn: 'root' })
@DescribeAngularService(ReleaseNoteService, {
  imports: [GCMockModule]
})
export class ReleaseNoteServiceSpec implements Spec<ReleaseNoteServiceSpec, ReleaseNoteService> {
  releaseNotes: ReleaseNoteFromApi[] = [{
    id: 1,
    releaseNumber: '2.49',
    releaseNotesUrl: 'url',
    announcementDate: '05/17/2022',
    startDate: '05/17/2022',
    endDate: '06/01/2022'
  }, {
    id: 2,
    releaseNumber: '2.50',
    releaseNotesUrl: 'url',
    announcementDate: '06/17/2022',
    startDate: '06/17/2022',
    endDate: '07/01/2022'
  }];

  @BeforeEach()
  mock (service: ReleaseNoteService) {
    service.hasDisplayedReleaseNotes = false;
    service['releaseNoteResources']['getReleaseNotesForUser'] = async () => {
      return this.releaseNotes;
    };
  }

  @AfterEach()
  restore () {
    spy.restore();
  }

  @TestCase('should be able to set release notes')
  async setReleaseNotes (service: ReleaseNoteService) {
    spy.on(service['releaseNoteResources'], 'getReleaseNotesForPlatform', async () => {
      return this.releaseNotes;
    });
    await service.setReleaseNotes();
    expect(service['releaseNoteResources']['getReleaseNotesForPlatform']).to.have.been.called.once;
    const didSet = !!service.releaseNotes;
    expect(didSet).to.be.true;
  }

  @TestCase('should be able to save release note')
  async saveReleaseNote (service: ReleaseNoteService) {
    spy.on(service['confirmAndTakeActionService'], 'takeAction', async () => {
      return {
        passed: true,
        endpointResponse: null
      };
    });
    await service.saveReleaseNote(this.releaseNotes[0]);
    expect(service['confirmAndTakeActionService']['takeAction']).to.have.been.called.once;
  }

  @TestCase('should be able to delete release note')
  async deleteReleaseNote (service: ReleaseNoteService) {
    spy.on(service['confirmAndTakeActionService'], 'confirmAndTakeAction', async () => {
      return {
        passed: true,
        endpointResponse: null
      };
    });
    await service.deleteReleaseNote(1, '2.58');
    expect(service['confirmAndTakeActionService']['confirmAndTakeAction']).to.have.been.called.once;
  }

  @TestCase('should be able to reset relase notes')
  async reset (service: ReleaseNoteService) {
    spy.on(service['releaseNoteResources'], 'getReleaseNotesForPlatform', async () => {
      return this.releaseNotes;
    });
    await service.resetReleaseNotes();
    expect(service['releaseNoteResources']['getReleaseNotesForPlatform']).to.have.been.called.once;
  }

  @TestCase('should be able to set release note for manager')
  async setReleaseNoteForManager (service: ReleaseNoteService) {
    spy.on(service['releaseNoteResources'], 'getReleaseNotesForUser', async () => {
      return this.releaseNotes;
    });
    spy.on(service, 'handleOpenReleaseNoteModal', async () => {});
    await service.setReleaseNoteForManager();
    expect(service['releaseNoteResources']['getReleaseNotesForUser']).to.have.been.called.once;
    expect(service['handleOpenReleaseNoteModal']).to.have.been.called.once;
    expect(service.releaseNoteForManager).to.deep.equal(this.releaseNotes[0]);
  }

  @TestCase('should be able to handle open release note modal - dismiss')
  async handleOpenReleaseNoteModal (service: ReleaseNoteService) {
    service['set']('releaseNoteForManager', this.releaseNotes[0]);
    const dismiss = true;
    spy.on(service['modalFactory'], 'open', async () => {
      return dismiss;
    });
    spy.on(service['releaseNoteResources'], 'dismissReleaseNote', async () => {});
    await service.handleOpenReleaseNoteModal();
    expect(service['modalFactory']['open']).to.have.been.called.once;
    expect(service['releaseNoteResources']['dismissReleaseNote']).to.have.been.called.once;
    const didReset = !service.releaseNoteForManager;
    expect(didReset).to.be.true;
    expect(service.hasDisplayedReleaseNotes).to.be.true;
  }

  @TestCase('should be able to handle open release note modal - dont dismiss')
  async handleOpenReleaseNoteModalNoDismiss (service: ReleaseNoteService) {
    service['set']('releaseNoteForManager', this.releaseNotes[0]);
    const dismiss = false;
    spy.on(service['modalFactory'], 'open', async () => {
      return dismiss;
    });
    spy.on(service['releaseNoteResources'], 'dismissReleaseNote', async () => {});
    await service.handleOpenReleaseNoteModal();
    expect(service['modalFactory']['open']).to.have.been.called.once;
    expect(service['releaseNoteResources']['dismissReleaseNote']).to.not.have.been.called;
    const didNotReset = !!service.releaseNoteForManager;
    expect(didNotReset).to.be.true;
  }

  @TestCase('should be able to handle not opening release notes modal - has displayed')
  async handleNotOpenReleaseNotesModalHasDisplayed (service: ReleaseNoteService) {
    service['set']('releaseNoteForManager', this.releaseNotes[0]);
    service.hasDisplayedReleaseNotes = true;
    const dismiss = false;
    spy.on(service['modalFactory'], 'open', async () => {
      return dismiss;
    });
    spy.on(service['releaseNoteResources'], 'dismissReleaseNote', async () => {});
    await service.handleOpenReleaseNoteModal();
    expect(service['modalFactory']['open']).to.not.have.been.called;
    expect(service['releaseNoteResources']['dismissReleaseNote']).to.not.have.been.called;
    const didNotReset = !!service.releaseNoteForManager;
    expect(didNotReset).to.be.true;
  }

  @TestCase('should be able to handle not opening release notes modal - has no release notes')
  async handleNotOpenReleaseNotesModalHasNoReleaseNotes (service: ReleaseNoteService) {
    service['set']('releaseNoteForManager', undefined);
    const dismiss = false;
    spy.on(service['modalFactory'], 'open', async () => {
      return dismiss;
    });
    spy.on(service['releaseNoteResources'], 'dismissReleaseNote', async () => {});
    await service.handleOpenReleaseNoteModal();
    expect(service['modalFactory']['open']).to.not.have.been.called;
    expect(service['releaseNoteResources']['dismissReleaseNote']).to.not.have.been.called;
  }
}