// (C) Copyright 2015 Martin Dougiamas
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

import { Component, OnInit, OnDestroy, ViewChild, ChangeDetectorRef, ViewChildren, QueryList } from '@angular/core';
import { IonicPage, NavParams, Content, PopoverController, ModalController, Modal, NavController } from 'ionic-angular';
import { TranslateService } from '@ngx-translate/core';
import { CoreEventsProvider } from '@providers/events';
import { CoreLoggerProvider } from '@providers/logger';
import { CoreSitesProvider } from '@providers/sites';
import { CoreSyncProvider } from '@providers/sync';
import { CoreDomUtilsProvider } from '@providers/utils/dom';
import { CoreTimeUtilsProvider } from '@providers/utils/time';
import { CoreQuestionHelperProvider } from '@core/question/providers/helper';
import { CoreQuestionComponent } from '@core/question/components/question/question';
import { AddonModQuizProvider } from '../../providers/quiz';
import { AddonModQuizSyncProvider } from '../../providers/quiz-sync';
import { AddonModQuizHelperProvider } from '../../providers/helper';
import { AddonModQuizAutoSave } from '../../classes/auto-save';
import { Subscription } from 'rxjs';

/**
 * Page that allows attempting a quiz.
 */
@IonicPage({ segment: 'addon-mod-quiz-player' })
@Component({
    selector: 'page-addon-mod-quiz-player',
    templateUrl: 'player.html',
})
export class AddonModQuizPlayerPage implements OnInit, OnDestroy {
    @ViewChild(Content) content: Content;
    @ViewChildren(CoreQuestionComponent) questionComponents: QueryList<CoreQuestionComponent>;

    quiz: any; // The quiz the attempt belongs to.
    attempt: any; // The attempt being attempted.
    moduleUrl: string; // URL to the module in the site.
    component = AddonModQuizProvider.COMPONENT; // Component to link the files to.
    loaded: boolean; // Whether data has been loaded.
    quizAborted: boolean; // Whether the quiz was aborted due to an error.
    offline: boolean; // Whether the quiz is being attempted in offline mode.
    navigation: any[]; // List of questions to navigate them.
    questions: any[]; // Questions of the current page.
    nextPage: number; // Next page.
    previousPage: number; // Previous page.
    showSummary: boolean; // Whether the attempt summary should be displayed.
    summaryQuestions: any[]; // The questions to display in the summary.
    canReturn: boolean; // Whether the user can return to a page after seeing the summary.
    preventSubmitMessages: string[]; // List of messages explaining why the quiz cannot be submitted.
    endTime: number; // The time when the attempt must be finished.
    autoSaveError: boolean; // Whether there's been an error in auto-save.
    navigationModal: Modal; // Modal to navigate through the questions.

    protected courseId: number; // The course ID the quiz belongs to.
    protected quizId: number; // Quiz ID to attempt.
    protected preflightData: any = {}; // Preflight data to attempt the quiz.
    protected quizAccessInfo: any; // Quiz access information.
    protected attemptAccessInfo: any; // Attempt access info.
    protected lastAttempt: any; // Last user attempt before a new one is created (if needed).
    protected newAttempt: boolean; // Whether the user is starting a new attempt.
    protected quizDataLoaded: boolean; // Whether the quiz data has been loaded.
    protected timeUpCalled: boolean; // Whether the time up function has been called.
    protected autoSave: AddonModQuizAutoSave; // Class to auto-save answers every certain time.
    protected autoSaveErrorSubscription: Subscription; // To be notified when an error happens in auto-save.
    protected forceLeave = false; // If true, don't perform any check when leaving the view.
    protected reloadNavigaton = false; // Whether navigation needs to be reloaded because some data was sent to server.

    constructor(navParams: NavParams, logger: CoreLoggerProvider, protected translate: TranslateService,
            protected eventsProvider: CoreEventsProvider, protected sitesProvider: CoreSitesProvider,
            protected syncProvider: CoreSyncProvider, protected domUtils: CoreDomUtilsProvider, popoverCtrl: PopoverController,
            protected timeUtils: CoreTimeUtilsProvider, protected quizProvider: AddonModQuizProvider,
            protected quizHelper: AddonModQuizHelperProvider, protected quizSync: AddonModQuizSyncProvider,
            protected questionHelper: CoreQuestionHelperProvider, protected cdr: ChangeDetectorRef,
            modalCtrl: ModalController, protected navCtrl: NavController) {

        this.quizId = navParams.get('quizId');
        this.courseId = navParams.get('courseId');
        this.moduleUrl = navParams.get('moduleUrl');

        // Block the quiz so it cannot be synced.
        this.syncProvider.blockOperation(AddonModQuizProvider.COMPONENT, this.quizId);

        // Create the auto save instance.
        this.autoSave = new AddonModQuizAutoSave('addon-mod_quiz-player-form', '#addon-mod_quiz-connection-error-button',
                logger, popoverCtrl, questionHelper, quizProvider);

        // Create the navigation modal.
        this.navigationModal = modalCtrl.create('AddonModQuizNavigationModalPage', {
            page: this
        }, { cssClass: 'core-modal-lateral',
            showBackdrop: true,
            enableBackdropDismiss: true,
            enterAnimation: 'core-modal-lateral-transition',
            leaveAnimation: 'core-modal-lateral-transition' });
    }

    /**
     * Component being initialized.
     */
    ngOnInit(): void {
        // Start the player when the page is loaded.
        this.start();

        // Listen for errors on auto-save.
        this.autoSaveErrorSubscription = this.autoSave.onError().subscribe((error) => {
            this.autoSaveError = error;
            this.cdr.detectChanges();
        });
    }

    /**
     * Component being destroyed.
     */
    ngOnDestroy(): void {
        // Stop auto save.
        this.autoSave.cancelAutoSave();
        this.autoSave.stopCheckChangesProcess();
        this.autoSaveErrorSubscription && this.autoSaveErrorSubscription.unsubscribe();

        // Unblock the quiz so it can be synced.
        this.syncProvider.unblockOperation(AddonModQuizProvider.COMPONENT, this.quizId);
    }

    /**
     * Check if we can leave the page or not.
     *
     * @return {boolean|Promise<void>} Resolved if we can leave it, rejected if not.
     */
    ionViewCanLeave(): boolean | Promise<void> {
        if (this.forceLeave) {
            return true;
        }

        if (this.questions && this.questions.length && !this.showSummary) {
            // Save answers.
            const modal = this.domUtils.showModalLoading('core.sending', true);

            return this.processAttempt(false, false).catch(() => {
                // Save attempt failed. Show confirmation.
                modal.dismiss();

                return this.domUtils.showConfirm(this.translate.instant('addon.mod_quiz.confirmleavequizonerror'));
            }).finally(() => {
                modal.dismiss();
            });
        }

        return Promise.resolve();
    }

    /**
     * Abort the quiz.
     */
    abortQuiz(): void {
        this.quizAborted = true;
    }

    /**
     * A behaviour button in a question was clicked (Check, Redo, ...).
     *
     * @param {any} button Clicked button.
     */
    behaviourButtonClicked(button: any): void {
        // Confirm that the user really wants to do it.
        this.domUtils.showConfirm(this.translate.instant('core.areyousure')).then(() => {
            const modal = this.domUtils.showModalLoading('core.sending', true);

            // Get the answers.
            return this.prepareAnswers().then((answers) => {

                // Add the clicked button data.
                answers[button.name] = button.value;

                // Behaviour checks are always in online.
                return this.quizProvider.processAttempt(this.quiz, this.attempt, answers, this.preflightData);
            }).then(() => {
                this.reloadNavigaton = true; // Data sent to server, navigation should be reloaded.

                // Reload the current page.
                const scrollElement = this.content.getScrollElement(),
                    scrollTop = scrollElement.scrollTop || 0,
                    scrollLeft = scrollElement.scrollLeft || 0;

                this.loaded = false;
                this.domUtils.scrollToTop(this.content); // Scroll top so the spinner is seen.

                return this.loadPage(this.attempt.currentpage).finally(() => {
                    this.loaded = true;
                    this.domUtils.scrollTo(this.content, scrollLeft, scrollTop);
                });
            }).finally(() => {
                modal.dismiss();
            });
        }).catch((error) => {
            this.domUtils.showErrorModalDefault(error, 'Error performing action.');
        });
    }

    /**
     * Change the current page. If slot is supplied, try to scroll to that question.
     *
     * @param {number} page Page to load. -1 means summary.
     * @param {boolean} [fromModal] Whether the page was selected using the navigation modal.
     * @param {number} [slot] Slot of the question to scroll to.
     */
    changePage(page: number, fromModal?: boolean, slot?: number): void {
        if (page != -1 && (this.attempt.state == AddonModQuizProvider.ATTEMPT_OVERDUE || this.attempt.finishedOffline)) {
            // We can't load a page if overdue or the local attempt is finished.
            return;
        } else if (page == this.attempt.currentpage && !this.showSummary && typeof slot != 'undefined') {
            // Navigating to a question in the current page.
            this.scrollToQuestion(slot);

            return;
        } else if ((page == this.attempt.currentpage && !this.showSummary) || (fromModal && this.quiz.isSequential && page != -1)) {
            // If the user is navigating to the current page we do nothing.
            // Also, in sequential quizzes we don't allow navigating using the modal except for finishing the quiz (summary).
            return;
        } else if (page === -1 && this.showSummary) {
            // Summary already shown.
            return;
        }

        this.loaded = false;
        this.domUtils.scrollToTop(this.content);

        // First try to save the attempt data. We only save it if we're not seeing the summary.
        const promise = this.showSummary ? Promise.resolve() : this.processAttempt(false, false);
        promise.then(() => {
            if (!this.showSummary) {
                this.reloadNavigaton = true; // Data sent to server, navigation should be reloaded.
            }

            // Attempt data successfully saved, load the page or summary.
            let subPromise;

            // Stop checking for changes during page change.
            this.autoSave.stopCheckChangesProcess();

            if (page === -1) {
                subPromise = this.loadSummary();
            } else {
                subPromise = this.loadPage(page);
            }

            return subPromise.catch((error) => {
                // If the user isn't seeing the summary, start the check again.
                if (!this.showSummary) {
                    this.autoSave.startCheckChangesProcess(this.quiz, this.attempt, this.preflightData, this.offline);
                }

                this.domUtils.showErrorModalDefault(error, 'addon.mod_quiz.errorgetquestions', true);
            });
        }, (error) => {
            this.domUtils.showErrorModalDefault(error, 'addon.mod_quiz.errorsaveattempt', true);
        }).finally(() => {
            this.loaded = true;

            if (typeof slot != 'undefined') {
                // Scroll to the question. Give some time to the questions to render.
                setTimeout(() => {
                    this.scrollToQuestion(slot);
                }, 2000);
            }
        });
    }

    /**
     * Convenience function to get the quiz data.
     *
     * @return {Promise<any>} Promise resolved when done.
     */
    protected fetchData(): Promise<any> {
        // Wait for any ongoing sync to finish. We won't sync a quiz while it's being played.
        return this.quizSync.waitForSync(this.quizId).then(() => {
            // Sync finished, now get the quiz.
            return this.quizProvider.getQuizById(this.courseId, this.quizId);
        }).then((quizData) => {
            this.quiz = quizData;
            this.quiz.isSequential = this.quizProvider.isNavigationSequential(this.quiz);

            if (this.quizProvider.isQuizOffline(this.quiz)) {
                // Quiz supports offline.
                return true;
            } else {
                // Quiz doesn't support offline right now, but maybe it did and then the setting was changed.
                // If we have an unfinished offline attempt then we'll use offline mode.
                return this.quizProvider.isLastAttemptOfflineUnfinished(this.quiz);
            }
        }).then((offlineMode) => {
            this.offline = offlineMode;

            if (this.quiz.timelimit > 0) {
                this.quiz.readableTimeLimit = this.timeUtils.formatTime(this.quiz.timelimit);
            }

            // Get access information for the quiz.
            return this.quizProvider.getQuizAccessInformation(this.quiz.id, this.offline, true);
        }).then((info) => {
            this.quizAccessInfo = info;

            // Get user attempts to determine last attempt.
            return this.quizProvider.getUserAttempts(this.quiz.id, 'all', true, this.offline, true);
        }).then((attempts) => {
            if (!attempts.length) {
                // There are no attempts, start a new one.
                this.newAttempt = true;
            } else {
                const promises = [];

                // Get the last attempt. If it's finished, start a new one.
                this.lastAttempt = attempts[attempts.length - 1];
                this.newAttempt = this.quizProvider.isAttemptFinished(this.lastAttempt.state);

                // Load quiz last sync time.
                promises.push(this.quizSync.getSyncTime(this.quiz.id).then((time) => {
                    this.quiz.syncTime = time;
                    this.quiz.syncTimeReadable = this.quizSync.getReadableTimeFromTimestamp(time);
                }));

                // Load flag to show if attempts are finished but not synced.
                promises.push(this.quizProvider.loadFinishedOfflineData(attempts));

                return Promise.all(promises);
            }
        }).catch((error) => {
            this.domUtils.showErrorModalDefault(error, 'addon.mod_quiz.errorgetquiz', true);
        });
    }

    /**
     * Finish an attempt, either by timeup or because the user clicked to finish it.
     *
     * @param {boolean} [userFinish] Whether the user clicked to finish the attempt.
     * @param {boolean} [timeUp] Whether the quiz time is up.
     * @return {Promise<void>} Promise resolved when done.
     */
    finishAttempt(userFinish?: boolean, timeUp?: boolean): Promise<void> {
        let promise;

        // Show confirm if the user clicked the finish button and the quiz is in progress.
        if (!timeUp && this.attempt.state == AddonModQuizProvider.ATTEMPT_IN_PROGRESS) {
            promise = this.domUtils.showConfirm(this.translate.instant('addon.mod_quiz.confirmclose'));
        } else {
            promise = Promise.resolve();
        }

        return promise.then(() => {
            const modal = this.domUtils.showModalLoading('core.sending', true);

            return this.processAttempt(userFinish, timeUp).then(() => {
                // Trigger an event to notify the attempt was finished.
                this.eventsProvider.trigger(AddonModQuizProvider.ATTEMPT_FINISHED_EVENT, {
                    quizId: this.quizId,
                    attemptId: this.attempt.id,
                    synced: !this.offline
                }, this.sitesProvider.getCurrentSiteId());

                // Leave the player.
                this.forceLeave = true;
                this.navCtrl.pop();
            }).finally(() => {
                modal.dismiss();
            });
        }).catch((error) => {
            this.domUtils.showErrorModalDefault(error, 'addon.mod_quiz.errorsaveattempt', true);
        });
    }

    /**
     * Fix sequence checks of current page.
     *
     * @return {Promise<any>} Promise resolved when done.
     */
    protected fixSequenceChecks(): Promise<any> {
        // Get current page data again to get the latest sequencechecks.
        return this.quizProvider.getAttemptData(this.attempt.id, this.attempt.currentpage, this.preflightData, this.offline, true)
                .then((data) => {

            const newSequenceChecks = {};

            data.questions.forEach((question) => {
                newSequenceChecks[question.slot] = this.questionHelper.getQuestionSequenceCheckFromHtml(question.html);
            });

            // Notify the new sequence checks to the components.
            this.questionComponents.forEach((component) => {
                component.updateSequenceCheck(newSequenceChecks);
            });
        });
    }

    /**
     * Get the input answers.
     *
     * @return {any} Object with the answers.
     */
    protected getAnswers(): any {
        return this.questionHelper.getAnswersFromForm(document.forms['addon-mod_quiz-player-form']);
    }

    /**
     * Initializes the timer if enabled.
     */
    protected initTimer(): void {
        if (this.attemptAccessInfo.endtime > 0) {
            // Quiz has an end time. Check if time left should be shown.
            if (this.quizProvider.shouldShowTimeLeft(this.quizAccessInfo.activerulenames, this.attempt,
                    this.attemptAccessInfo.endtime)) {
                this.endTime = this.attemptAccessInfo.endtime;
            } else {
                delete this.endTime;
            }
        }
    }

    /**
     * Load a page questions.
     *
     * @param {number} page The page to load.
     * @return {Promise<void>} Promise resolved when done.
     */
    protected loadPage(page: number): Promise<void> {
        return this.quizProvider.getAttemptData(this.attempt.id, page, this.preflightData, this.offline, true).then((data) => {
            // Update attempt, status could change during the execution.
            this.attempt = data.attempt;
            this.attempt.currentpage = page;

            this.questions = data.questions;
            this.nextPage = data.nextpage;
            this.previousPage = this.quiz.isSequential ? -1 : page - 1;
            this.showSummary = false;

            this.questions.forEach((question) => {
                // Get the readable mark for each question.
                question.readableMark = this.quizHelper.getQuestionMarkFromHtml(question.html);

                // Extract the question info box.
                this.questionHelper.extractQuestionInfoBox(question, '.info');

                // Set the preferred behaviour.
                question.preferredBehaviour = this.quiz.preferredbehaviour;

                // Check if the question is blocked. If it is, treat it as a description question.
                if (this.quizProvider.isQuestionBlocked(question)) {
                    question.type = 'description';
                }
            });

            // Mark the page as viewed. We'll ignore errors in this call.
            this.quizProvider.logViewAttempt(this.attempt.id, page, this.preflightData, this.offline).catch((error) => {
                // Ignore errors.
            });

            // Start looking for changes.
            this.autoSave.startCheckChangesProcess(this.quiz, this.attempt, this.preflightData, this.offline);
        });
    }

    /**
     * Load attempt summary.
     *
     * @return {Promise<void>} Promise resolved when done.
     */
    protected loadSummary(): Promise<void> {
        this.summaryQuestions = [];

        return this.quizProvider.getAttemptSummary(this.attempt.id, this.preflightData, this.offline, true, true).then((qs) => {
            this.showSummary = true;
            this.summaryQuestions = qs;

            this.canReturn = this.attempt.state == AddonModQuizProvider.ATTEMPT_IN_PROGRESS && !this.attempt.finishedOffline;
            this.preventSubmitMessages = this.quizProvider.getPreventSubmitMessages(this.summaryQuestions);

            this.attempt.dueDateWarning = this.quizProvider.getAttemptDueDateWarning(this.quiz, this.attempt);

            // Log summary as viewed.
            this.quizProvider.logViewAttemptSummary(this.attempt.id, this.preflightData, this.quizId).catch((error) => {
                // Ignore errors.
            });
        });
    }

    /**
     * Load data to navigate the questions using the navigation modal.
     *
     * @return {Promise<void>} Promise resolved when done.
     */
    protected loadNavigation(): Promise<void> {
        // We use the attempt summary to build the navigation because it contains all the questions.
        return this.quizProvider.getAttemptSummary(this.attempt.id, this.preflightData, this.offline, true, true)
                .then((questions) => {

            questions.forEach((question) => {
                question.stateClass = this.questionHelper.getQuestionStateClass(question.state);
            });

            this.navigation = questions;
        });
    }

    /**
     * Open the navigation modal.
     *
     * @return {Promise<any>} Promise resolved when done.
     */
    openNavigation(): Promise<any> {
        let promise;

        if (this.reloadNavigaton) {
            // Some data has changed, reload the navigation.
            const modal = this.domUtils.showModalLoading();

            promise = this.loadNavigation().catch(() => {
                // Ignore errors.
            }).then(() => {
                modal.dismiss();
                this.reloadNavigaton = false;
            });
        } else {
            promise = Promise.resolve();
        }

        return promise.finally(() => {
            this.navigationModal.present();
        });
    }

    // Prepare the answers to be sent for the attempt.
    protected prepareAnswers(): Promise<any> {
        return this.questionHelper.prepareAnswers(this.questions, this.getAnswers(), this.offline);
    }

    /**
     * Process attempt.
     *
     * @param {boolean} [userFinish] Whether the user clicked to finish the attempt.
     * @param {boolean} [timeUp] Whether the quiz time is up.
     * @return {Promise<any>} Promise resolved when done.
     * @param {boolean} [retrying] Whether we're retrying the change.
     */
    protected processAttempt(userFinish?: boolean, timeUp?: boolean, retrying?: boolean): Promise<any> {
        // Get the answers to send.
        return this.prepareAnswers().then((answers) => {
            // Send the answers.
            return this.quizProvider.processAttempt(this.quiz, this.attempt, answers, this.preflightData, userFinish, timeUp,
                    this.offline).catch((error) => {

                if (error && error.errorcode == 'submissionoutofsequencefriendlymessage') {
                    // There was an error with the sequence check. Try to ammend it.
                    return this.fixSequenceChecks().then((): any => {
                        if (retrying) {
                            // We're already retrying, don't send the data again because it could cause an infinite loop.
                            return Promise.reject(error);
                        }

                        // Sequence checks updated, try to send the data again.
                        return this.processAttempt(userFinish, timeUp, true);
                    }, () => {
                        return Promise.reject(error);
                    });
                }

                return Promise.reject(error);
            });
        }).then(() => {
            // Answers saved, cancel auto save.
            this.autoSave.cancelAutoSave();
            this.autoSave.hideAutoSaveError();
        });
    }

    /**
     * Scroll to a certain question.
     *
     * @param {number} slot Slot of the question to scroll to.
     */
    protected scrollToQuestion(slot: number): void {
        this.domUtils.scrollToElementBySelector(this.content, '#addon-mod_quiz-question-' + slot);
    }

    /**
     * Show connection error.
     *
     * @param {Event} ev Click event.
     */
    showConnectionError(ev: Event): void {
        this.autoSave.showAutoSaveError(ev);
    }

    /**
     * Convenience function to start the player.
     */
    start(): void {
        let promise;
        this.loaded = false;

        if (this.quizDataLoaded) {
            // Quiz data has been loaded, try to start or continue.
            promise = this.startOrContinueAttempt();
        } else {
            // Fetch data.
            promise = this.fetchData().then(() => {
                this.quizDataLoaded = true;

                return this.startOrContinueAttempt();
            });
        }

        promise.finally(() => {
            this.loaded = true;
        });
    }

    /**
     * Start or continue an attempt.
     *
     * @return {Promise<any>} [description]
     */
    protected startOrContinueAttempt(): Promise<any> {
        const attempt = this.newAttempt ? undefined : this.lastAttempt;

        // Get the preflight data and start attempt if needed.
        return this.quizHelper.getAndCheckPreflightData(this.quiz, this.quizAccessInfo, this.preflightData, attempt, this.offline,
                false, 'addon.mod_quiz.startattempt').then((attempt) => {

            // Re-fetch attempt access information with the right attempt (might have changed because a new attempt was created).
            return this.quizProvider.getAttemptAccessInformation(this.quiz.id, attempt.id, this.offline, true).then((info) => {
                this.attemptAccessInfo = info;
                this.attempt = attempt;

                return this.loadNavigation();
            }).then(() => {
                if (this.attempt.state != AddonModQuizProvider.ATTEMPT_OVERDUE && !this.attempt.finishedOffline) {
                    // Attempt not overdue and not finished in offline, load page.
                    return this.loadPage(this.attempt.currentpage).then(() => {
                        this.initTimer();
                    });
                } else {
                    // Attempt is overdue or finished in offline, we can only load the summary.
                    return this.loadSummary();
                }
            });
        }).catch((error) => {
            this.domUtils.showErrorModalDefault(error, 'addon.mod_quiz.errorgetquestions', true);
        });
    }

    /**
     * Quiz time has finished.
     */
    timeUp(): void {
        if (this.timeUpCalled) {
            return;
        }

        this.timeUpCalled = true;
        this.finishAttempt(false, true);
    }
}