import { Injectable } from '@angular/core';
import { ActivatedRouteSnapshot, Resolve } from '@angular/router';
import { Observable } from 'rxjs';
import { map, tap } from 'rxjs/operators';

import { AssessmentService } from '../services/assessment.service';
import { MinifiedUserModel } from '@shared/models';
import { HelpersService } from '@shared/services';
import { AssessmentExtended } from '../models/assessment-extended.model';
import { AssessmentReviewStatuses } from '../../../enums';
import { AssessmentUsers } from '../models/assessment-users.model';
import { CounterStatuses } from '../models';

@Injectable({
  providedIn: 'root'
})

export class AssessmentViewResolver implements Resolve<Observable<AssessmentExtended>> {
  assessmentReviewStatuses = AssessmentReviewStatuses;
  assessmentStatuses = {
    notStarted: 0,
    inProgress: 0,
    done: 0,
    rejected: 0
  };
  reviewers = 0;

  constructor(private readonly assessmentService: AssessmentService,
              private readonly helperService: HelpersService) {}

  resolve(activeSnapshot: ActivatedRouteSnapshot): Observable<AssessmentExtended> {
    const id = +activeSnapshot.params.id;

    const users: MinifiedUserModel[] = this.helperService.resolveRouteParam(activeSnapshot, 'minifiedUsers');

    return this.assessmentService.getAssessmentView(id).pipe(
      map(assessment => ({
        ...assessment,
        author: users.find((user: MinifiedUserModel) => user.id === assessment.authorId),
        revieweesList: assessment.reviewees.map(userObj => {
          return {
            user: users.find((userItem: MinifiedUserModel) => userItem.id === userObj.userId),
            reviewers: userObj.reviewers.map(reviewerItem => {
              const reviewer = users.find((userItem: MinifiedUserModel) =>
                  userItem.id === (reviewerItem as any as MinifiedUserReviewer).userId) as MinifiedUserModelWithStatus;

              const review = assessment.reviews.find((reviewItem: MinifiedUserReview) =>
                reviewer && (reviewerItem as any as MinifiedUserReviewer).revieweeId === reviewItem.revieweeId
                && (reviewerItem as any as MinifiedUserReviewer).id === reviewItem.reviewerId);

              return {...reviewer, ...{statusReview: review.status}};
            })
          };
        })
      } as any as AssessmentExtended)),
      tap((assessment: AssessmentExtended) => {
        assessment.revieweesList.map((reviewee: AssessmentUsers, i: number) => {
          assessment.revieweesList[i] = this.countPercentages(reviewee);

          return assessment;
        });
      }),
      map(assessment => ({
        ...assessment,
        statusesTotalSum: this.countTotalPercentages(this.assessmentStatuses, this.reviewers)
      } as any as AssessmentExtended))
    );
  }

  private countPercentages(reviewee: AssessmentUsers): AssessmentUsers {
    this.reviewers += reviewee.reviewers.length;
    reviewee.statuses = {
      notStarted: 0,
      inProgress: 0,
      done: 0,
      rejected: 0
    };
    for (const reviewer of reviewee.reviewers) {
      switch (reviewer.statusReview) {
        case this.assessmentReviewStatuses.notStarted:
          reviewee.statuses.notStarted++;
          this.assessmentStatuses.notStarted++;
          break;
        case this.assessmentReviewStatuses.inProgress:
          reviewee.statuses.inProgress++;
          this.assessmentStatuses.inProgress++;
          break;
        case this.assessmentReviewStatuses.done:
          reviewee.statuses.done++;
          this.assessmentStatuses.done++;
          break;
        default:
          reviewee.statuses.rejected++;
          this.assessmentStatuses.rejected++;
      }
    }

    reviewee.statuses = this.countTotalPercentages(reviewee.statuses, reviewee.reviewers.length);

    return reviewee;
  }

  private countTotalPercentages(statuses: CounterStatuses, lengthValue: number) {
    const transformedArr = this.helperService.transformPercentages(
      [this.helperService.roundNumbers(statuses.notStarted, lengthValue),
        this.helperService.roundNumbers(statuses.inProgress, lengthValue),
        this.helperService.roundNumbers(statuses.done, lengthValue),
        this.helperService.roundNumbers(statuses.rejected, lengthValue)
      ]);

    Object.keys(statuses).forEach((key: string, index: number) => {
      ((statuses as any)[key]) = transformedArr.find((_value: number, idx: number) => index === idx);
    });

    return statuses;
  }
}

export interface MinifiedUserModelWithStatus extends MinifiedUserModel {
  statusReview: number;
}

export interface MinifiedUserReviewer {
  id: number;
  revieweeId: number;
  userId: number;
}

export interface MinifiedUserReview {
  id: number;
  revieweeId: number;
  reviewerId: number;
  status: number;
  assessmentId: number;
  answer: [];
}