import { Injectable } from '@angular/core';
import { ActivatedRouteSnapshot, Resolve } from '@angular/router';
import { FeedbackApiService } from '@shared/services/feedback/feedback-api.service';
import { UserService } from '@shared/services/user/user.service';
import { User } from '@shared/models/user.model';
// import { Feedback } from '@shared/models/feedback.model';
import { merge, Observable, throwError, forkJoin, of } from 'rxjs';
import { catchError, map, mergeMap, tap, concatMap } from 'rxjs/operators';

@Injectable()
export class AssignedFeedbackResolver implements Resolve<Observable<any>> {
  constructor(private feedbackService: FeedbackApiService,
              private userService: UserService) {}

  resolve(route: ActivatedRouteSnapshot): Observable<any> {
    const assignedFeedbackId = Number(route.paramMap.get('id'));

    if (isNaN(assignedFeedbackId)) {
      return throwError('A feedback id parameter must be specified in URL');
    }

    return this.getAssignedFeedback(assignedFeedbackId).pipe(
      concatMap(assignedFeedbackObj => forkJoin(this.getFeedbacksAndMap(assignedFeedbackObj), this.getQuestionsAndMap(assignedFeedbackObj)).pipe(
        map(([feedbacks, questions]) => {

          assignedFeedbackObj.feedbackCycle.feedbacks = feedbacks;
          assignedFeedbackObj.feedbackCycle.questions = questions;

          return assignedFeedbackObj;
        })
        )
      ));
  }

  private getAssignedFeedback(assignedFeedbackId: any): Observable<any> {

    return this.feedbackService.getAssignedUser(assignedFeedbackId)
      .pipe(
        mergeMap(assigned => this.getFeedbackCycleAndMap(assigned)),
        catchError(() => of(null))
      );
  }

  private getFeedbackCycleAndMap(data: any): Observable<any> {


    return this.feedbackService
      .getFeedbackCycleWithMinimalRelations(data.feedbackCycle.id)
      .pipe(map(cycle => {
        data.feedbackCycle = cycle;

        return data;
      }));
  }

  private getFeedbacksAndMap(assignedFeedback: any): Observable<any[]> {

    const cycleId = assignedFeedback.feedbackCycle.id;

    return this.userService.getUserAuthenticated()
      .pipe(
        mergeMap((user: User) => this.feedbackService.getFeedbacksInFeedbackCycle(cycleId, {userReviewee: assignedFeedback.userReviewee.id, userReviewer: user.id})
          .pipe(
            tap(item => console.log(item)),
            mergeMap(feedbacks => this.getAnswersAndMap(feedbacks)),
            tap(item => console.log(item))
          )
        )
      );
  }

  private getQuestionsAndMap(assignedFeedback: any): Observable<any[]> {
    const cycleId = assignedFeedback.feedbackCycle.id;

    return this.feedbackService.getQuestionsOfFeedbackCycle(cycleId)
      .pipe(
        mergeMap(questions => this.getFeatScalesAndMap(questions))
      );

  }

  private getAnswersAndMap(feedbacks: any[]): Observable<any[]> {
    const feedbackStreams = feedbacks
      .map((feedback: any) => this.feedbackService
        .getAnswersOfFeedback(feedback.id)
        .pipe(map(answers => feedback.answers = answers))
      );


    return forkJoin(feedbackStreams).pipe(map(() => feedbacks));
  }

  private getFeatScalesAndMap(questions: any[]): Observable<any[]> {
    const questionsStreams = questions
      .map((question: any) => this.feedbackService
        .getFeatScalesOfQuestion(question.id)
        .pipe(map(featScales => question.featScales = featScales))
      );

    return forkJoin(questionsStreams).pipe(map(() => questions));
  }
}