/*
 *    Copyright [2011] [wisemapping]
 *
 *   Licensed under WiseMapping Public License, Version 1.0 (the "License").
 *   It is basically the Apache License, Version 2.0 (the "License") plus the
 *   "powered by wisemapping" text requirement on every single page;
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the license at
 *
 *       http://www.wisemapping.org/license
 *
 *   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.
 */

mindplot.VariableDistanceBoard = new Class({
    Extends: mindplot.Board,
    initialize: function(defaultHeight, referencePoint) {
        this.parent(defaultHeight, referencePoint);
        var zeroEntryCoordinate = referencePoint.y;
        var entry = this.createBoardEntry(zeroEntryCoordinate - (defaultHeight / 2), zeroEntryCoordinate + (defaultHeight / 2), 0);
        this._entries.set(0, entry);
    },

    lookupEntryByOrder:function(order) {
        var entries = this._entries;
        var index = this._orderToIndex(order);

        var result = entries.get(index);
        if (!$defined(result)) {
            // I've not found a entry. I have to create a new one.
            var i = 1;
            var zeroEntry = entries.get(0);
            var distance = zeroEntry.getWidth() / 2;
            var indexSign = Math.sign(index);
            var absIndex = Math.abs(index);
            while (i < absIndex) {
                // Move to the next entry ...
                var entry = entries.get(i, indexSign);
                if (entry != null) {
                    distance += entry.getWidth();
                } else {
                    distance += this._defaultWidth;
                }
                i++;
            }

            // Calculate limits ...
            var upperLimit = -1;
            var lowerLimit = -1;
            var offset = zeroEntry.workoutEntryYCenter();
            if (index >= 0) {
                lowerLimit = offset + distance;
                upperLimit = lowerLimit + this._defaultWidth;
            } else {
                upperLimit = offset - distance;
                lowerLimit = upperLimit - this._defaultWidth;
            }

            result = this.createBoardEntry(lowerLimit, upperLimit, order);
        }
        return result;
    },

    createBoardEntry:function(lowerLimit, upperLimit, order) {
        return  new mindplot.BoardEntry(lowerLimit, upperLimit, order);
    },

    updateReferencePoint:function(position) {
        var entries = this._entries;
        var referencePoint = this._referencePoint;

        // Update zero entry current position.
        this._referencePoint = position.clone();
        var yOffset = position.y - referencePoint.y;

        var i = -entries.lowerLength();
        for (; i <= entries.length(1); i++) {
            var entry = entries.get(i);
            if (entry != null) {
                var upperLimit = entry.getUpperLimit() + yOffset;
                var lowerLimit = entry.getLowerLimit() + yOffset;
                entry.setUpperLimit(upperLimit);
                entry.setLowerLimit(lowerLimit);

                // Update topic position ...
                if (!entry.isAvailable()) {
                    var topic = entry.getTopic();
                    var topicPosition = topic.getPosition();
                    topicPosition.y = topicPosition.y + yOffset;

                    // MainTopicToCentral must be positioned based on the referencePoint.
                    var xOffset = position.x - referencePoint.x;
                    topicPosition.x = topicPosition.x + xOffset;

                    topic.setPosition(topicPosition);
                }
            }
        }
    },

    lookupEntryByPosition:function(pos) {
        $assert(pos, 'position can not be null');
        var entries = this._entries;
        var zeroEntry = entries.get(0);
        if (zeroEntry.isCoordinateIn(pos.y)) {
            return zeroEntry;
        }

        // Is Upper or lower ?
        var sign = -1;
        if (pos.y >= zeroEntry.getUpperLimit()) {
            sign = 1;
        }

        var i = 1;
        var tempEntry = this.createBoardEntry();
        var currentEntry = zeroEntry;
        while (true) {
            // Move to the next entry ...
            var index = i * sign;
            var entry = entries.get(index);
            if ($defined(entry)) {
                currentEntry = entry;
            } else {
                // Calculate boundaries...
                var lowerLimit, upperLimit;
                if (sign > 0) {
                    lowerLimit = currentEntry.getUpperLimit();
                    upperLimit = lowerLimit + this._defaultWidth;
                }
                else {
                    upperLimit = currentEntry.getLowerLimit();
                    lowerLimit = upperLimit - this._defaultWidth;
                }

                // Update current entry.
                currentEntry = tempEntry;
                currentEntry.setLowerLimit(lowerLimit);
                currentEntry.setUpperLimit(upperLimit);

                var order = this._indexToOrder(index);
                currentEntry.setOrder(order);
            }

            // Have I found the item?
            if (currentEntry.isCoordinateIn(pos.y)) {
                break;
            }
            i++;
        }
        return currentEntry;
    },

    update:function(entry) {
        $assert(entry, 'Entry can not be null');
        var order = entry.getOrder();
        var index = this._orderToIndex(order);

        this._entries.set(index, entry);

    },
    freeEntry:function(entry) {
        var order = entry.getOrder();
        var entries = this._entries;

        var index = this._orderToIndex(order);
        var indexSign = Math.sign(index);

        var currentTopic = entry.getTopic();
        var i = Math.abs(index) + 1;
        while (currentTopic) {
            var e = entries.get(i, indexSign);
            if ($defined(currentTopic) && !$defined(e)) {
                var entryOrder = this._indexToOrder(i * indexSign);
                e = this.lookupEntryByOrder(entryOrder);
            }

            // Move the topic to the next entry ...
            var topic = null;
            if ($defined(e)) {
                topic = e.getTopic();
                if ($defined(currentTopic)) {
                    e.setTopic(currentTopic);
                }
                this.update(e);
            }
            currentTopic = topic;
            i++;
        }

        // Clear the entry topic ...
        entry.setTopic(null);
    },

    _orderToIndex:function(order) {
        var index = Math.round(order / 2);
        return ((order % 2) == 0) ? index : -index;
    },

    _indexToOrder:function(index) {
        var order = Math.abs(index) * 2;
        return (index >= 0) ? order : order - 1;
    },

    inspect:function() {
        return this._entries.inspect();
    }

});