// (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 { Injectable, Injector } from '@angular/core';
import { CoreFilepoolProvider } from '@providers/filepool';
import { CoreGroupsProvider } from '@providers/groups';
import { CoreTextUtilsProvider } from '@providers/utils/text';
import { CoreCourseModulePrefetchHandlerBase } from '@core/course/classes/module-prefetch-handler';
import { CoreCourseProvider } from '@core/course/providers/course';
import { CoreCourseHelperProvider } from '@core/course/providers/helper';
import { CoreGradesHelperProvider } from '@core/grades/providers/helper';
import { CoreUserProvider } from '@core/user/providers/user';
import { AddonModAssignProvider } from './assign';
import { AddonModAssignHelperProvider } from './helper';
import { AddonModAssignFeedbackDelegate } from './feedback-delegate';
import { AddonModAssignSubmissionDelegate } from './submission-delegate';

/**
 * Handler to prefetch assigns.
 */
@Injectable()
export class AddonModAssignPrefetchHandler extends CoreCourseModulePrefetchHandlerBase {
    name = 'AddonModAssign';
    modName = 'assign';
    component = AddonModAssignProvider.COMPONENT;
    updatesNames = /^configuration$|^.*files$|^submissions$|^grades$|^gradeitems$|^outcomes$|^comments$/;

    constructor(protected injector: Injector, protected assignProvider: AddonModAssignProvider,
            protected textUtils: CoreTextUtilsProvider, protected feedbackDelegate: AddonModAssignFeedbackDelegate,
            protected submissionDelegate: AddonModAssignSubmissionDelegate, protected courseProvider: CoreCourseProvider,
            protected courseHelper: CoreCourseHelperProvider, protected filepoolProvider: CoreFilepoolProvider,
            protected groupsProvider: CoreGroupsProvider, protected gradesHelper: CoreGradesHelperProvider,
            protected userProvider: CoreUserProvider, protected assignHelper: AddonModAssignHelperProvider) {
        super(injector);
    }

    /**
     * Check if a certain module can use core_course_check_updates to check if it has updates.
     * If not defined, it will assume all modules can be checked.
     * The modules that return false will always be shown as outdated when they're downloaded.
     *
     * @param {any} module Module.
     * @param {number} courseId Course ID the module belongs to.
     * @return {boolean|Promise<boolean>} Whether the module can use check_updates. The promise should never be rejected.
     */
    canUseCheckUpdates(module: any, courseId: number): boolean | Promise<boolean> {
        // Teachers cannot use the WS because it doesn't check student submissions.
        return this.assignProvider.getAssignment(courseId, module.id).then((assign) => {
            return this.assignProvider.getSubmissions(assign.id);
        }).then((data) => {
            return !data.canviewsubmissions;
        }).catch(() => {
            return false;
        });
    }

    /**
     * Download the module.
     *
     * @param {any} module The module object returned by WS.
     * @param {number} courseId Course ID.
     * @param {string} [dirPath] Path of the directory where to store all the content files. @see downloadOrPrefetch.
     * @return {Promise<any>} Promise resolved when all content is downloaded.
     */
    download(module: any, courseId: number, dirPath?: string): Promise<any> {
        // Same implementation for download or prefetch.
        return this.prefetch(module, courseId, false, dirPath);
    }

    /**
     * Get list of files. If not defined, we'll assume they're in module.contents.
     *
     * @param {any} module Module.
     * @param {Number} courseId Course ID the module belongs to.
     * @param {boolean} [single] True if we're downloading a single module, false if we're downloading a whole section.
     * @param {string} [siteId] Site ID. If not defined, current site.
     * @return {Promise<any[]>} Promise resolved with the list of files.
     */
    getFiles(module: any, courseId: number, single?: boolean, siteId?: string): Promise<any[]> {

        siteId = siteId || this.sitesProvider.getCurrentSiteId();

        return this.assignProvider.getAssignment(courseId, module.id, siteId).then((assign) => {
            // Get intro files and attachments.
            let files = assign.introattachments || [];
            files = files.concat(this.getIntroFilesFromInstance(module, assign));

            // Now get the files in the submissions.
            return this.assignProvider.getSubmissions(assign.id, siteId).then((data) => {
                const blindMarking = assign.blindmarking && !assign.revealidentities;

                if (data.canviewsubmissions) {
                    // Teacher, get all submissions.
                    return this.assignProvider.getSubmissionsUserData(data.submissions, courseId, assign.id, blindMarking,
                            undefined, siteId).then((submissions) => {

                        const promises = [];

                        // Get all the files in the submissions.
                        submissions.forEach((submission) => {
                            promises.push(this.getSubmissionFiles(assign, submission.submitid, !!submission.blindid, siteId)
                                    .then((submissionFiles) => {
                                files = files.concat(submissionFiles);
                            }));
                        });

                        return Promise.all(promises).then(() => {
                            return files;
                        });
                    });
                } else {
                    // Student, get only his/her submissions.
                    const userId = this.sitesProvider.getCurrentSiteUserId();

                    return this.getSubmissionFiles(assign, userId, blindMarking, siteId).then((submissionFiles) => {
                        files = files.concat(submissionFiles);

                        return files;
                    });
                }
            });
        }).catch(() => {
            // Error getting data, return empty list.
            return [];
        });
    }

    /**
     * Get submission files.
     *
     * @param {any} assign Assign.
     * @param {number} submitId User ID of the submission to get.
     * @param {boolean} blindMarking True if blind marking, false otherwise.
     * @param {string} siteId Site ID. If not defined, current site.
     * @return {Promise<any[]>} Promise resolved with array of files.
     */
    protected getSubmissionFiles(assign: any, submitId: number, blindMarking: boolean, siteId?: string)
            : Promise<any[]> {

        return this.assignProvider.getSubmissionStatus(assign.id, submitId, blindMarking, true, false, siteId).then((response) => {
            const promises = [];

            if (response.lastattempt) {
                const userSubmission = this.assignProvider.getSubmissionObjectFromAttempt(assign, response.lastattempt);
                if (userSubmission && userSubmission.plugins) {
                    // Add submission plugin files.
                    userSubmission.plugins.forEach((plugin) => {
                        promises.push(this.submissionDelegate.getPluginFiles(assign, userSubmission, plugin, siteId));
                    });
                }
            }

            if (response.feedback && response.feedback.plugins) {
                // Add feedback plugin files.
                response.feedback.plugins.forEach((plugin) => {
                    promises.push(this.feedbackDelegate.getPluginFiles(assign, response, plugin, siteId));
                });
            }

            return Promise.all(promises);

        }).then((filesLists) => {
            let files = [];

            filesLists.forEach((filesList) => {
                files = files.concat(filesList);
            });

            return files;
        });
    }

    /**
     * Invalidate the prefetched content.
     *
     * @param {number} moduleId The module ID.
     * @param {number} courseId The course ID the module belongs to.
     * @return {Promise<any>} Promise resolved when the data is invalidated.
     */
    invalidateContent(moduleId: number, courseId: number): Promise<any> {
        return this.assignProvider.invalidateContent(moduleId, courseId);
    }

    /**
     * Whether or not the handler is enabled on a site level.
     *
     * @return {boolean|Promise<boolean>} A boolean, or a promise resolved with a boolean, indicating if the handler is enabled.
     */
    isEnabled(): boolean | Promise<boolean> {
        return this.assignProvider.isPluginEnabled();
    }

    /**
     * Prefetch a module.
     *
     * @param {any} module Module.
     * @param {number} courseId Course ID the module belongs to.
     * @param {boolean} [single] True if we're downloading a single module, false if we're downloading a whole section.
     * @param {string} [dirPath] Path of the directory where to store all the content files. @see downloadOrPrefetch.
     * @return {Promise<any>} Promise resolved when done.
     */
    prefetch(module: any, courseId?: number, single?: boolean, dirPath?: string): Promise<any> {
        return this.prefetchPackage(module, courseId, single, this.prefetchAssign.bind(this));
    }

    /**
     * Prefetch an assignment.
     *
     * @param {any} module Module.
     * @param {number} courseId Course ID the module belongs to.
     * @param {boolean} single True if we're downloading a single module, false if we're downloading a whole section.
     * @param {String} siteId Site ID.
     * @return {Promise<any>} Promise resolved when done.
     */
    protected prefetchAssign(module: any, courseId: number, single: boolean, siteId: string): Promise<any> {
        const userId = this.sitesProvider.getCurrentSiteUserId(),
            promises = [];

        siteId = siteId || this.sitesProvider.getCurrentSiteId();

        promises.push(this.courseProvider.getModuleBasicInfo(module.id, siteId));

        // Get assignment to retrieve all its submissions.
        promises.push(this.assignProvider.getAssignment(courseId, module.id, siteId).then((assign) => {
            const subPromises = [],
                blindMarking = assign.blindmarking && !assign.revealidentities;

            if (blindMarking) {
                subPromises.push(this.assignProvider.getAssignmentUserMappings(assign.id, undefined, siteId).catch(() => {
                    // Ignore errors.
                }));
            }

            subPromises.push(this.prefetchSubmissions(assign, courseId, module.id, userId, siteId));

            subPromises.push(this.courseHelper.getModuleCourseIdByInstance(assign.id, 'assign', siteId));

            // Get all files and fetch them.
            subPromises.push(this.getFiles(module, courseId, single, siteId).then((files) => {
                return this.filepoolProvider.addFilesToQueue(siteId, files, this.component, module.id);
            }));

            return Promise.all(subPromises);
        }));

        return Promise.all(promises);
    }

    /**
     * Prefetch assign submissions.
     *
     * @param {any} assign Assign.
     * @param {number} courseId Course ID.
     * @param {number} moduleId Module ID.
     * @param {number} [userId] User ID. If not defined, site's current user.
     * @param {string} [siteId] Site ID. If not defined, current site.
     * @return {Promise<any>} Promise resolved when prefetched, rejected otherwise.
     */
    protected prefetchSubmissions(assign: any, courseId: number, moduleId: number, userId?: number, siteId?: string): Promise<any> {

        // Get submissions.
        return this.assignProvider.getSubmissions(assign.id, siteId).then((data) => {
            const promises = [],
                blindMarking = assign.blindmarking && !assign.revealidentities;

            if (data.canviewsubmissions) {
                // Teacher. Do not send participants to getSubmissionsUserData to retrieve user profiles.
                promises.push(this.assignProvider.getSubmissionsUserData(data.submissions, courseId, assign.id, blindMarking,
                        undefined, siteId).then((submissions) => {

                    const subPromises = [];

                    submissions.forEach((submission) => {
                        subPromises.push(this.assignProvider.getSubmissionStatus(assign.id, submission.submitid,
                                !!submission.blindid, true, false, siteId).then((subm) => {
                            return this.prefetchSubmission(assign, courseId, moduleId, subm, submission.submitid, siteId);
                        }));
                    });

                    return Promise.all(subPromises);
                }));

                // Get list participants.
                promises.push(this.assignHelper.getParticipants(assign, siteId).then((participants) => {
                    participants.forEach((participant) => {
                        if (participant.profileimageurl) {
                            this.filepoolProvider.addToQueueByUrl(siteId, participant.profileimageurl);
                        }
                    });
                }).catch(() => {
                    // Fail silently (Moodle < 3.2).
                }));
            } else {
                // Student.
                promises.push(this.assignProvider.getSubmissionStatus(assign.id, userId, false, true, false, siteId)
                        .then((subm) => {
                    return this.prefetchSubmission(assign, courseId, moduleId, subm, userId, siteId);
                }));
            }

            promises.push(this.groupsProvider.activityHasGroups(assign.cmid));
            promises.push(this.groupsProvider.getActivityAllowedGroups(assign.cmid, undefined, siteId));

            return Promise.all(promises);
        });
    }

    /**
     * Prefetch a submission.
     *
     * @param {any} assign Assign.
     * @param {number} courseId Course ID.
     * @param {number} moduleId Module ID.
     * @param {any} submission Data returned by AddonModAssignProvider.getSubmissionStatus.
     * @param {number} [userId] User ID. If not defined, site's current user.
     * @param {string} [siteId] Site ID. If not defined, current site.
     * @return {Promise<any>} Promise resolved when prefetched, rejected otherwise.
     */
    protected prefetchSubmission(assign: any, courseId: number, moduleId: number, submission: any, userId?: number,
            siteId?: string): Promise<any> {

        const promises = [],
            blindMarking = assign.blindmarking && !assign.revealidentities;
        let userIds = [];

        if (submission.lastattempt) {
            const userSubmission = this.assignProvider.getSubmissionObjectFromAttempt(assign, submission.lastattempt);

            // Get IDs of the members who need to submit.
            if (!blindMarking && submission.lastattempt.submissiongroupmemberswhoneedtosubmit) {
                userIds = userIds.concat(submission.lastattempt.submissiongroupmemberswhoneedtosubmit);
            }

            if (userSubmission && userSubmission.id) {
                // Prefetch submission plugins data.
                if (userSubmission.plugins) {
                    userSubmission.plugins.forEach((plugin) => {
                        promises.push(this.submissionDelegate.prefetch(assign, userSubmission, plugin, siteId));
                    });
                }

                // Get ID of the user who did the submission.
                if (userSubmission.userid) {
                    userIds.push(userSubmission.userid);
                }
            }
        }

        // Prefetch feedback.
        if (submission.feedback) {
            // Get profile and image of the grader.
            if (submission.feedback.grade && submission.feedback.grade.grader) {
                userIds.push(submission.feedback.grade.grader);
            }

            if (userId) {
                promises.push(this.gradesHelper.getGradeModuleItems(courseId, moduleId, userId, undefined, siteId));
            }

            // Prefetch feedback plugins data.
            if (submission.feedback.plugins) {
                submission.feedback.plugins.forEach((plugin) => {
                    promises.push(this.feedbackDelegate.prefetch(assign, submission, plugin, siteId));
                });
            }
        }

        // Prefetch user profiles.
        promises.push(this.userProvider.prefetchProfiles(userIds, courseId, siteId));

        return Promise.all(promises);
    }
}