/*
 * Copyright (C) 2014 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

Analyzer = function()
{
    BaseObject.call(this);

    // Only load one queue at a time to not overload the server.
    this._queueBeingLoaded = null;

    Dashboard.Repository.OpenSource.trac.addEventListener(Trac.Event.Loaded, this._loadedFromTrac, this);
};

BaseObject.addConstructorFunctions(Analyzer);

Analyzer.Event = {
    Starting: "starting",
    QueueResults: "queue-results",
    Finished: "finished",
};

Analyzer.prototype = {
    constructor: Analyzer,
    __proto__: BaseObject.prototype,

    analyze: function(queues, fromDate, toDate)
    {
        this.dispatchEventToListeners(Analyzer.Event.Starting, null);

        this._rangeStartTime = new Date(fromDate);
        this._rangeEndTime = new Date(toDate);

        this._hasTracData = false;

        // A commit can start a build-test sequence, or it can be ignored following builder queue rules.
        // Only the builder queue knows which commits triggered builds, and which were ignored.
        // We need to know which commits were ignored when measuring tester queue performance,
        // so we load and analyze builder queues first.
        this._queues = queues.slice(0);
        this._queues.sort(function(a, b) { return b.builder - a.builder; });

        this._remainingQueues = {};
        this._queuesReadyToAnalyze = [];

        this._triggeringCommitsByTriggeringQueue = {};

        this._queues.forEach(function(queue) {
            if (!queue.iterations.length) {
                this._remainingQueues[queue.id] = queue;
                if (!this._queueBeingLoaded) {
                    this._queueBeingLoaded = queue.id;
                    queue.loadAll(this._loadedFromBuildbot.bind(this));
                }
            } else
                this._queuesReadyToAnalyze.push(queue);
        }, this);

        Dashboard.Repository.OpenSource.trac.load(this._rangeStartTime, this._rangeEndTime);

        bubbleQueueServer.loadProcessingTimes(this._rangeStartTime, this._rangeEndTime, this._loadedBubblesTiming.bind(this));
    },

    _triggeringQueue: function(queue)
    {
        if (queue.builder)
            return queue;
        for (var i = 0; i < this._queues.length; ++i) {
            if (this._queues[i].tester)
                continue;
            if (this._queues[i].platform === queue.platform && this._queues[i].architecture === queue.architecture && this._queues[i].debug === queue.debug)
                return this._queues[i];
        }
        return queue;
    },

    _recordTriggeringCommitsForTriggeringQueue: function(queue)
    {
        console.assert(!(queue.id in this._triggeringCommitsByTriggeringQueue));
        console.assert(queue.id === this._triggeringQueue(queue).id);

        var commits = {};
        queue.iterations.forEach(function(iteration) {
            iteration.changes.forEach(function(change) {
                // FIXME: Support multiple source trees.
                commits[change.revisionNumber] = 1;
            });
        });

        this._triggeringCommitsByTriggeringQueue[queue.id] = commits;
    },

    // Iterations is an array of finished iterations ordered by time, iterations[0] being the newest.
    // Returns an index of an iteration that defined the queue color at the start, or -1
    // if there was none.
    _findIndexOfLargestIterationAtOrBeforeStart: function(iterations)
    {
        var result = -1;
        var i = 0;
        while (i < iterations.length && iterations[i].endTime > this._rangeStartTime)
            ++i;
        if (i < iterations.length)
            result = i++;
        while (i < iterations.length) {
            if (iterations[i].revision[Dashboard.Repository.OpenSource.name] > iterations[result].revision[Dashboard.Repository.OpenSource.name])
                result = i;
            ++i;
        }
        return result;
    },

    _dashboardIsAllGreen: function(topIterationByQueue)
    {
        var countOfQueuesWithKnownColor = Object.keys(topIterationByQueue).length;
        if (countOfQueuesWithKnownColor === 0)
            return undefined;

        for (var queueID in topIterationByQueue) {
            if (!topIterationByQueue[queueID].successful)
                return false;
        }
        return true;
    },

    _updateStretchOfRedCounters: function(topIterationByQueue, currentTime, stretchOfRedCounters)
    {
        var dashboardIsAllGreen = this._dashboardIsAllGreen(topIterationByQueue);

        if (dashboardIsAllGreen === undefined) {
            console.assert(stretchOfRedCounters.currentStretchOfRedStart === undefined);
            console.assert(stretchOfRedCounters.longestStretchOfRed === 0);
            return;
        }

        if (dashboardIsAllGreen) {
            if (stretchOfRedCounters.currentStretchOfRedStart !== undefined) {
                stretchOfRedCounters.longestStretchOfRed = Math.max(stretchOfRedCounters.longestStretchOfRed, currentTime - stretchOfRedCounters.currentStretchOfRedStart);
                stretchOfRedCounters.currentStretchOfRedStart = undefined;
            }
        } else {
            if (stretchOfRedCounters.currentStretchOfRedStart === undefined)
                stretchOfRedCounters.currentStretchOfRedStart = currentTime;
        }
    },

    _countPercentageOfGreen: function(queues, result)
    {
        var topIterationByQueue = {};
        var iterations = [];

        // Find what the top iteration for each queue was at the start of the time range (and thus what colors the dashboard was showing).
        // Merge all queues' iterations into one array, filtering out ones that can't possibly affect the end result.
        queues.forEach(function(queue) {
            var queueIterations = queue.iterations.filter(function(iteration) { return iteration.finished; });
            queueIterations.sort(function(a, b) { return b.endTime - a.endTime; });

            var indexOfLargestIterationAtOrBeforeStart = this._findIndexOfLargestIterationAtOrBeforeStart(queueIterations);
            if (indexOfLargestIterationAtOrBeforeStart >= 0) {
                topIterationByQueue[queue.id] = queueIterations[indexOfLargestIterationAtOrBeforeStart];
                var i = indexOfLargestIterationAtOrBeforeStart;
            } else
                var i = queueIterations.length - 1;
            while (i >= 0 && queueIterations[i].endTime <= this._rangeEndTime)
                iterations.push(queueIterations[i--]);
        }, this);

        iterations.sort(function(a, b) { return b.endTime - a.endTime; });

        // Go forward in time, ignoring out of order iterations that didn't affect queue color.
        var currentTime = this._rangeStartTime;
        var greenTime = 0;
        var stretchOfRedCounters = {
            longestStretchOfRed: 0,
            currentStretchOfRedStart: undefined
        };
        var earliestTimeInRangeWithColor;
        if (this._dashboardIsAllGreen(topIterationByQueue) !== undefined)
            earliestTimeInRangeWithColor = this._rangeStartTime;
        this._updateStretchOfRedCounters(topIterationByQueue, this._rangeStartTime, stretchOfRedCounters);
        for (var i = iterations.length - 1; i >= 0; --i) {
            if (iterations[i].endTime <= this._rangeStartTime) {
                console.assert(iterations[i].queue.id in topIterationByQueue);
                continue;
            }
            if (!(iterations[i].queue.id in topIterationByQueue)) {
                topIterationByQueue[iterations[i].queue.id] = iterations[i];
                if (earliestTimeInRangeWithColor === undefined) {
                    currentTime = iterations[i].endTime;
                    earliestTimeInRangeWithColor = currentTime;
                }
                this._updateStretchOfRedCounters(topIterationByQueue, currentTime, stretchOfRedCounters);
                continue;
            }
            if (iterations[i].revision[Dashboard.Repository.OpenSource.name] <= topIterationByQueue[iterations[i].queue.id].revision[Dashboard.Repository.OpenSource.name])
                continue;

            var dashboardWasAllGreen = this._dashboardIsAllGreen(topIterationByQueue);
            console.assert(dashboardWasAllGreen !== undefined);
            topIterationByQueue[iterations[i].queue.id] = iterations[i];

            if (dashboardWasAllGreen === true)
                greenTime += iterations[i].endTime - currentTime;

            currentTime = iterations[i].endTime;
            this._updateStretchOfRedCounters(topIterationByQueue, currentTime, stretchOfRedCounters);
        }

        if (this._dashboardIsAllGreen(topIterationByQueue) === true)
            greenTime += this._rangeEndTime - currentTime;

        if (stretchOfRedCounters.currentStretchOfRedStart !== undefined)
            stretchOfRedCounters.longestStretchOfRed = Math.max(stretchOfRedCounters.longestStretchOfRed, this._rangeEndTime - stretchOfRedCounters.currentStretchOfRedStart);

        result.longestStretchOfRed = stretchOfRedCounters.longestStretchOfRed / 1000;

        if (earliestTimeInRangeWithColor === this._rangeStartTime)
            result.percentageOfGreen = greenTime / (this._rangeEndTime - this._rangeStartTime) * 100;
        else {
            result.buildbotRangeError = true;
            if (earliestTimeInRangeWithColor !== undefined) {
                result.buildbotRangeErrorText = "Queue only has results starting " + earliestTimeInRangeWithColor;
                result.percentageOfGreen = greenTime / (this._rangeEndTime - earliestTimeInRangeWithColor) * 100;
            } else
                result.buildbotRangeErrorText = "Queue has no results in this range";
        }
    },

    _countTimes: function(queues, result)
    {
        var relevantIterationsByQueue = {};
        queues.forEach(function(queue) {
            relevantIterationsByQueue[queue.id] = queue.iterations.filter(function(iteration) {
                return iteration.productive && iteration.startTime > this._rangeStartTime && iteration.endTime < this._rangeEndTime;
            }, this);
            relevantIterationsByQueue[queue.id].sort(function(a, b) { return a.endTime - b.endTime; });
        }, this);

        var times = [];
        var ownTimes = [];
        var worstTime = 0;
        var worstOwnTime = 0
        var worstTimeRevision;
        var worstOwnTimeRevision;

        Dashboard.Repository.OpenSource.trac.recordedCommits.forEach(function(revision) {
            if (revision.date < this._rangeStartTime || revision.date >= this._rangeEndTime)
                return;

            var endTime = -1;
            var ownTime = -1;
            queues.forEach(function(queue) {
                if (!(revision.revisionNumber in this._triggeringCommitsByTriggeringQueue[this._triggeringQueue(queue).id]))
                    return;
                for (var i = 0; i < relevantIterationsByQueue[queue.id].length; ++i) {
                    var iteration = relevantIterationsByQueue[queue.id][i];
                    if (iteration.revision[Dashboard.Repository.OpenSource.name] >= revision.revisionNumber) {
                        endTime = Math.max(endTime, iteration.endTime);
                        ownTime = Math.max(ownTime, iteration.endTime - iteration.startTime);
                        break;
                    }
                }
            }, this);
            if (endTime >= 0) {
                console.assert(ownTime >= 0);
                var time = endTime - revision.date;
                times.push(time);
                ownTimes.push(ownTime);
                if (time > worstTime) {
                    worstTime = time;
                    worstTimeCommit = revision.revisionNumber;
                }
                if (ownTime > worstOwnTime) {
                    worstOwnTime = ownTime;
                    worstOwnTimeCommit = revision.revisionNumber;
                }
            }
        }, this);

        result.averageSecondsFromCommit = times.average() / 1000;
        result.medianSecondsFromCommit = times.median() / 1000;
        console.assert(worstTime === Math.max.apply(Math, times));
        result.worstSecondsFromCommit = worstTime / 1000;
        result.revisionWithWorstTimeFromCommit = worstTimeCommit;

        result.averageSecondsOwnTime = ownTimes.average() / 1000;
        result.medianSecondsOwnTime = ownTimes.median() / 1000;
        result.worstSecondsOwnTime = worstOwnTime / 1000;
        console.assert(worstOwnTime === Math.max.apply(Math, ownTimes));
        result.revisionWithWorstOwnTime = worstOwnTimeCommit;
    },

    _analyzeQueue: function(queue)
    {
        if (this._triggeringQueue(queue).id === queue.id && !(queue.id in this._triggeringCommitsByTriggeringQueue))
            this._recordTriggeringCommitsForTriggeringQueue(queue);

        var result = { queueID: queue.id };
        this._countPercentageOfGreen([queue], result);
        this._countTimes([queue], result);

        this.dispatchEventToListeners(Analyzer.Event.QueueResults, result);
    },

    _analyzeAggregate: function()
    {
        var builderQueues = this._queues.filter(function(queue) { return queue.builder; });

        var buildersResult = { queueID: allBuilderResultsPseudoQueue.id };
        this._countPercentageOfGreen(builderQueues, buildersResult);
        this._countTimes(builderQueues, buildersResult);
        this.dispatchEventToListeners(Analyzer.Event.QueueResults, buildersResult);

        var allQueuesResult = { queueID: allResultsPseudoQueue.id };
        this._countPercentageOfGreen(this._queues, allQueuesResult);
        this._countTimes(this._queues, allQueuesResult);
        this.dispatchEventToListeners(Analyzer.Event.QueueResults, allQueuesResult);
    },

    _analyze: function(queue)
    {
        console.assert(this._hasTracData);

        this._queuesReadyToAnalyze.forEach(function(queue) {
            this._analyzeQueue(queue);
        }, this);

        this._queuesReadyToAnalyze = [];

        if (!Object.keys(this._remainingQueues).length) {
            this._analyzeAggregate();
            this.dispatchEventToListeners(Analyzer.Event.Finished, null);
        }
    },

    _loadedFromTrac: function(event)
    {
        this._hasTracData = event.data[0] <= this._rangeStartTime && event.data[1] >= this._rangeEndTime;
        if (this._hasTracData)
            this._analyze();
    },

    _loadedFromBuildbot: function(queue)
    {
        console.assert(this._queueBeingLoaded === queue.id);
        this._queueBeingLoaded = null;

        if (queue.id in this._remainingQueues) {
            delete this._remainingQueues[queue.id];
            this._queuesReadyToAnalyze.push(queue);
        }

        for (var queueID in this._remainingQueues) {
            var queue = this._remainingQueues[queueID];
            console.assert(queue.id === queueID);
            console.assert(!queue.iterations.length);
            this._queueBeingLoaded = queueID;
            queue.loadAll(this._loadedFromBuildbot.bind(this));
            break;
        }

        if (this._hasTracData)
            this._analyze();
    },

    _analyzeBubblePerformance: function(queueID, patches)
    {
        var patchesThatCausedInternalError = [];
        for (patchID in patches) {
            if (patches[patchID].resolution === "internal error")
                patchesThatCausedInternalError.push(patchID);
        }

        var waitTimes = [];
        var patchesThatWaitedMoreThan3Minutes = [];
        var totalTimes = [];
        var totalTimesForPatchesThatWereNotRetried = [];
        var totalTimesForPatchesThatSpinnedAndPassedOrFailed = [];
        var patchesThatDidNotComplete = [];
        var retryCounts = [];
        var patchesThatSpinnedAndDidNotComplete = [];
        var patchesThatSpinnedAndCeasedToApply = [];
        var patchesThatSpinnedAndPassedOrFailed = [];
        var patchesDidNotApply = [];
        for (patchID in patches) {
            var patch = patches[patchID];

            // Wait time is equally interesting for all patches.
            waitTimes.push(patch.wait_duration);

            if (patch.wait_duration > 3 * 60)
                patchesThatWaitedMoreThan3Minutes.push(patchID);

            if (patch.resolution === "not processed")
                patchesThatDidNotComplete.push(patchID);

            if (patch.retry_count === 0)
                totalTimesForPatchesThatWereNotRetried.push(patch.wait_duration + patch.process_duration);
            else {
                retryCounts.push(patch.retry_count);
                if (patch.resolution === "not processed")
                    patchesThatSpinnedAndDidNotComplete.push(patchID);
                else if (patch.resolution === "could not apply")
                    patchesThatSpinnedAndCeasedToApply.push(patchID);
                else if (patch.resolution === "pass" || patch.resolution === "fail") {
                    patchesThatSpinnedAndPassedOrFailed.push(patchID);
                    totalTimesForPatchesThatSpinnedAndPassedOrFailed.push(patch.wait_duration + patch.process_duration);
                }
            }

            // Analyze processing performance for patches that were definitely processed.
            // We can't target improving performance of others (such as patches that were obsoleted while in the queue).
            // Patches that don't apply to trunk have to be excluded, because otherwise we
            // get times for patches that spinned until they ceased to apply.
            if (patch.resolution === "pass" || patch.resolution === "fail")
                totalTimes.push(patch.wait_duration + patch.process_duration);

            if (patch.resolution === "could not apply")
                patchesDidNotApply.push(patchID);
        }

        var result = {
            queueID: queueID,
            totalPatches: Object.keys(patches).length,
            patchesThatDidNotCompleteCount: patchesThatDidNotComplete.length,
            patchesWithRetriesCount: retryCounts.length,
            patchesThatDidNotApplyCount: patchesDidNotApply.length,
            patchesThatSpinnedAndDidNotCompleteCount: patchesThatSpinnedAndDidNotComplete.length,
            patchesThatSpinnedAndCeasedToApplyCount: patchesThatSpinnedAndCeasedToApply.length,
            patchesThatSpinnedAndPassedOrFailedCount: patchesThatSpinnedAndPassedOrFailed.length,
            medianTotalTimeForPatchesThatSpinnedAndPassedOrFailedInSeconds: totalTimesForPatchesThatSpinnedAndPassedOrFailed.median(),
            averageTotalTimeForPatchesThatSpinnedAndPassedOrFailedInSeconds: totalTimesForPatchesThatSpinnedAndPassedOrFailed.average(),
            medianWaitTimeInSeconds: waitTimes.median(),
            averageWaitTimeInSeconds: waitTimes.average(),
            maximumWaitTimeInSeconds: Math.max.apply(Math, waitTimes),
            patchesThatWaitedMoreThan3MinutesCount: patchesThatWaitedMoreThan3Minutes.length,
            patchesThatCausedInternalError: patchesThatCausedInternalError,
        };

        if (totalTimes.length) {
            result.medianTotalTimeInSeconds = totalTimes.median();
            result.averageTotalTimeInSeconds = totalTimes.average();
        }

        if (totalTimesForPatchesThatWereNotRetried.length) {
            result.medianTotalTimeForPatchesThatWereNotRetriedInSeconds = totalTimesForPatchesThatWereNotRetried.median();
            result.averageTotalTimeForPatchesThatWereNotRetriedInSeconds = totalTimesForPatchesThatWereNotRetried.average();
        }

        this.dispatchEventToListeners(Analyzer.Event.QueueResults, result);
    },

    _analyzeAllBubblesPerformance: function(dataByPatch)
    {
        var data = {};
        for (queueID in bubbleQueueServer.queues)
            data[queueID] = {};

        for (patchID in dataByPatch) {
            for (queueID in dataByPatch[patchID]) {
                if (!(queueID in data))
                    continue;
                var patchData = dataByPatch[patchID][queueID];
                if (patchData.date < this.fromDate || patchData.date > this.toDate)
                    continue;
                if (patchData.resolution === "in progress")
                    continue;
                data[queueID][patchID] = patchData;
            };
        };
        for (queueID in data)
            this._analyzeBubblePerformance(queueID, data[queueID]);
    },

    _loadedBubblesTiming: function(data, fromTime, toTime)
    {
        // Only analyze if the data covers the latest range requested by the user.
        // It may be different from the loaded one if the user quickly requested multiple ranges.
        if (fromTime > this._rangeStartTime || toTime < this._rangeEndTime)
            return;
        this._analyzeAllBubblesPerformance(data);
    },
};