import { Injectable } from '@angular/core';
import { GCMockModule } from '@core/mocks/gc-module.mock';
import { UsersValidationPayload } from '@core/typings/user.typing';
import { getOrganizedErrors, validateMultiple } from '@yourcause/common';
import { BeforeEach, Spec, TestCase } from '@yourcause/test-decorators';
import { DescribeAngularService } from '@yourcause/test-decorators/angular';
import { expect, spy } from 'chai';
import { UserService, UsersImportValidationModel, UsersValidator } from './user.service';

@Injectable({ providedIn: 'root' })
@DescribeAngularService(UserService, {
  imports: [
    GCMockModule
  ]
})
export class UserServiceSpec implements Spec<UserServiceSpec, UserService> {
  mockValidationResponse: UsersValidationPayload = {
    emails: [],
    workflowLevelIds: [],
    roleIds: []
  };

  @BeforeEach()
  mockService (service: UserService) {
    service['userResources'].validateUsers = async () => {
      return this.mockValidationResponse;
    };
  }

  @TestCase('should be able to validate against existing records')
  async testShouldBeAbleToValidateAgainstExistingEmails (
    service: UserService
  ) {
    this.mockValidationResponse = {
      emails: ['mockEmail@email.com'],
      workflowLevelIds: [],
      roleIds: []
    };

    const importPayload: UsersImportValidationModel[] = [{
      'First Name': 'Test',
      'Last Name': 'Rest',
      'Job Title': 'Best',
      Email: 'mockEmail@email.com',
      Roles: [1, 2, 3],
      'Workflow Levels': [4, 5, 6],
      'Is SSO': true
    }];
    const response = await validateMultiple(UsersImportValidationModel, importPayload, {
      get () {
        return service;
      }
    });
    const organizedErrors = getOrganizedErrors(response.recordLevelErrors, {
      translate: () => ''
    });
    expect(organizedErrors[0].validator).to.equal(UsersValidator);
    expect(organizedErrors.length).to.equal(1);
  }

  @TestCase('should be able to validate against nonexistent workflowLevelIds')
  async testShouldBeAbleToValidateAgainstNonexistentWFLIDs (
    service: UserService
  ) {
    this.mockValidationResponse = {
      emails: [],
      workflowLevelIds: [4, 5, 6],
      roleIds: []
    };

    const importPayload: UsersImportValidationModel[] = [{
      'First Name': 'Test',
      'Last Name': 'Rest',
      'Job Title': 'Best',
      Email: 'mockEmail@email.com',
      Roles: [1, 2, 3],
      'Workflow Levels': [4, 5, 6],
      'Is SSO': true
    }];
    const response = await validateMultiple(UsersImportValidationModel, importPayload, {
      get () {
        return service;
      }
    });
    const organizedErrors = getOrganizedErrors(response.recordLevelErrors, {
      translate: () => ''
    });
    expect(organizedErrors[0].validator).to.equal(UsersValidator);
    expect(organizedErrors.length).to.equal(1);
  }
  @TestCase('should be able to validate required fields')
  async testShouldBeAbleToRequiredFields (
    service: UserService
  ) {
    this.mockValidationResponse = {
      emails: [],
      workflowLevelIds: [],
      roleIds: []
    };

    const importPayload: UsersImportValidationModel[] = [{
      'First Name': '',
      'Last Name': '',
      'Job Title': '',
      Email: '',
      Roles: [],
      'Workflow Levels': [],
      'Is SSO': true
    }];
    const response = await validateMultiple(UsersImportValidationModel, importPayload, {
      get () {
        return service;
      }
    });
    const organizedErrors = getOrganizedErrors(response.recordLevelErrors, {
      translate: () => ''
    });
    // expected to equal 5 since 4 are required
    // but email must also be formatted so it returns 2 errors
    expect(organizedErrors.length).to.equal(4);
  }
  @TestCase('should be able to edit gm user')
  async testEditGMUser (service: UserService) {
    spy.on(service['userResources'], 'addEditUser', async () => {
      return true;
    });
    const response = await service.addEditUser({
      firstName: 'Al',
      lastName: 'Ien',
      jobTitle: 'Lead alien at Glorp and Sons',
      email: 'al.ien@email.com',
      isSSO: true
    });
    expect(service['userResources']['addEditUser']).to.have.been.called();
    expect(response).to.equal(true);
  }
}