import {TestBed} from '@angular/core/testing';

import {SubLevelService} from './sub-level.service';
import {PostMessageBridgeFactory} from 'ngx-post-message';
import {HttpClientTestingModule} from '@angular/common/http/testing';
import {GameActionsService} from './game-actions.service';
import {AppInfoOxService} from './app-info-ox.service';
import {appInfoSpy} from '../test-files/test-declarations.spec';
import {LevelService} from './level.service';

describe('SubLevelService', () => {
  let sublevelService: SubLevelService;
  let gameActions: GameActionsService<any>;
  const mustBeSublevel = new Map();
  mustBeSublevel.set(1, 1);
  mustBeSublevel.set(2, 1);
  mustBeSublevel.set(3, 2);
  mustBeSublevel.set(4, 2);
  mustBeSublevel.set(5, 3);
  mustBeSublevel.set(6, 3);

  beforeEach(() => {
    TestBed.configureTestingModule({
      providers:
        [
          {provide: AppInfoOxService, useValue: appInfoSpy},
          LevelService,
          PostMessageBridgeFactory,
        ], imports: [HttpClientTestingModule]
    });
    sublevelService = TestBed.get(SubLevelService);
    gameActions = TestBed.get(GameActionsService);
  });

  it('should be created', () => {
    expect(sublevelService).toBeTruthy();
  });

  it('asStart clear state', () => {
    setStrangeState();
    sublevelService['asStart']();
    stateIsClear();
  });

  function stateIsClear() {
    expect(sublevelService.currentSublevel.value).toBe(1);
    expect(sublevelService['subLevelProgress']).toBe(0);
    expect(sublevelService['progressAddedInThisChallenge']).toBeFalsy();
  }

  function setStrangeState() {
    sublevelService['progressAddedInThisChallenge'] = true;
    sublevelService.currentSublevel.next(3);
    sublevelService['subLevelProgress'] = 3;
  }

  it('asStart clear state', () => {
    setStrangeState();
    gameActions.startGame.emit();
    stateIsClear();
  });

  it('after show next challenge progress is set as not added for the challenge', () => {
    sublevelService['progressAddedInThisChallenge'] = true;
    gameActions.showNextChallenge.emit();
    expect(sublevelService['progressAddedInThisChallenge']).toBeFalsy();
  });

  it('After level change max level and current exercises to reach should be set correctly', () => {
    TestBed.get(LevelService).currentLevel.next(1);
    expect(sublevelService.getMaxSubLevel()).toBe(3);
    expect(sublevelService['currentExercisesToReach']).toEqual([2, 4, 6]);
  });

  it('After correct answer progressAddedInThisChallenge must be true, and subLevelProgress must add one', () => {
    firstAnwerCorrect();
  });

  function firstAnwerCorrect() {
    TestBed.get(LevelService).currentLevel.next(1);
    gameActions.startGame.emit();
    addOneCorrectAnswer();
  }

  function addOneCorrectAnswer() {
    gameActions.showNextChallenge.emit();
    const initialProgress = sublevelService['subLevelProgress'];
    expect(sublevelService['progressAddedInThisChallenge']).toBeFalsy();
    gameActions.checkedAnswer.emit(true);
    expect(sublevelService['subLevelProgress']).toBe(initialProgress + 1);
    expect(sublevelService['progressAddedInThisChallenge']).toBeTruthy();
  }

  function addOneWrongAnswer() {
    gameActions.showNextChallenge.emit();
    const initialProgress = sublevelService['subLevelProgress'];
    expect(sublevelService['progressAddedInThisChallenge']).toBeFalsy();
    gameActions.checkedAnswer.emit(false);
    expect(sublevelService['subLevelProgress']).toBe(Math.max(0, initialProgress - 1));
    expect(sublevelService['progressAddedInThisChallenge']).toBeTruthy();
  }

  it('After wrong answer progressAddedInThisChallenge must be true, and subLevelProgress must subtract one', () => {
    firstAnwerCorrect();
    gameActions.showNextChallenge.emit();
    expect(sublevelService['subLevelProgress']).toBe(1);
    expect(sublevelService['progressAddedInThisChallenge']).toBeFalsy();
    gameActions.checkedAnswer.emit(false);
    expect(sublevelService['subLevelProgress']).toBe(0);
    expect(sublevelService['progressAddedInThisChallenge']).toBeTruthy();
  });

  it('Sublevel is correctly updated after corrects answers', () => {
    checkSubLevelUpdatedCorrectlyAfter([true, true, true, true, true, true]);
  });
  it('Sublevel is correctly updated after corrects and wrong answers', () => {
    checkSubLevelUpdatedCorrectlyAfter([true, false, true, false, true, true]);
  });

  it('Sublevel is correctly updated after corrects and wrong answers 2', () => {
    checkSubLevelUpdatedCorrectlyAfter([false, false, true, false, false, true]);
  });

  it('Sublevel is correctly updated after all wrongs', () => {
    checkSubLevelUpdatedCorrectlyAfter([false, false, false, false, false, false]);
  });

  function checkSubLevelUpdatedCorrectlyAfter(answers) {
    TestBed.get(LevelService).currentLevel.next(1);
    gameActions.startGame.emit();
    let value = 0;
    for (let i = 0; i < 6; i++) {
      expect(sublevelService['subLevelProgress']).toBe(value);
      expect(sublevelService.currentSublevel.value).toBe(mustBeSublevel.get(value + 1));
      if (answers[i]) {
        addOneCorrectAnswer();
        value = Math.min(value + 1, 6);
      } else {
        addOneWrongAnswer();
        value = Math.max(0, value - 1);
      }
    }
  }

});