/**
 * The task is to implement an elevator driver. Elevator moves between floors (up & down).
 * There are button for each floor in the elevator cabin (no buttons to open/close the doors).
 * On each floor there are 2 buttons UP & DOWN (1 button for the highest floor DOWN and 1 for the lowest UP).
 * The elevator should move according to the floors selected by users, but neither user should have priority and each user should be able to go to the desired floor (i.e. if there is 25 floors in the building, users on each floor should have the same priority; also there should be no possibility to stop the elevator from moving to users that are not inside of the cabin e.g. by moving between 2nd & 3rd floor endlessly).
 *
 * Implementation notes:
 *
 * - Start updating the template code from `Elevator.prototype = {` line
 * - If elevator is not moving `getCurrentDirection` returns `DIRECTION_NONE`
 * - `getCurrentFloor` called from `onBeforeFloor` returns the floor number that was before the floor for which `onBeforeFloor` is called (i.e. if the elevator goes up after the 2nd floor, and `onBeforeFloor` is called for the 3rd floor, `getCurrentFloor` will return 2)
 * - `moveUp` & `moveDown` functions starts movement and are not discrete (i.e. if `moveUp` is called you should explicitly provide stop conditions and stop the elevator - it doesn't move the elevator up by one floor).
 */


const DIRECTION_DOWN = -1;
const DIRECTION_NONE = 0;
const DIRECTION_UP = 1;

function HardwareElevator() {}

HardwareElevator.prototype = {
    moveUp: function() { console.log("up") },
    moveDown: function() { console.log("down") },
    stopAndOpenDoors: function() { console.log("stop and open") },
    getCurrentFloor: function() {},
    getCurrentDirection: function() {}
};

function Elevator() {
    this.hw = new HardwareElevator();
    this.hw.on("doorsClosed", _bind(this.onDoorsClosed, this));
    this.hw.on("beforeFloor", _bind(this.onBeforeFloor, this));
    this.hw.on("floorButtonPressed", _bind(this.onFloorButtonPressed, this));
    this.hw.on("cabinButtonPressed", _bind(this.onCabinButtonPressed, this));

    this.queue = {
        top: [],
        bottom: []
    };
}

Elevator.prototype = {
    // your changes starting from here
    addToQueue(floor, direction) {
        const currentDirection = this.getCurrentDirection();
        const currentFloor = this.getCurrentFloor();
        const queue = this.queue[direction];

        if (currentFloor === floor) {
            // open door on same floor
            this.stopAndOpenDoors();
            return;
        }

        if (queue.indexOf(floor) !== -1) {
            return;
        }

        queue.push(floor).sort();

        if (direction === DIRECTION_UP) {
            queue.reverse();
        }

        this.queue[direction] = queue;
    },

    getDirection() {
        const currentDirection = this.getCurrentDirection();
        const anotherDirection = this.getAnotherDirection(currentDirection);

        if (currentDirecction !== DIRECTION_NONE) {
            if (this.queue[currentDirection].length) {
                return currentDirection;
            }

            if (this.queue[anotherDirection].length) {
                return anotherDirection;
            }
        }

        return null;
    },

    getAnotherDirection(direction) {
        return [DIRECTION_UP, DIRECTION_DOWN].filter(d => d !== direction)[0];
    },

    getNextFloor() {
        const direction = this.getDirection();
        const anotherDirection = this.getAnotherDirection(direction);

        if (!direction) {
            return null;
        }

        const nextQueue = this.queue[direction];
        const anotherQueue = this.queue[anotherDirection];

        if (nextQueue.length) {
            return nextQueue[0];
        }

        return anotherQueue[0];
    },

    moveNext() {
        const direction = getDirection();
        const move = {
            [DIRECTION_UP]: this.moveUp,
            [DIRECTION_DOWN]: this.moveDown
        };

        if (direction) {
            move[direction]();
        }
    },

    onDoorsClosed: function() {
        this.moveNext();
    },

    onBeforeFloor: function() {
        const direction = this.getDirection();
        const queue = this.queue[direction];

        const currentFloor = this.getCurrentFloor();
        const nextFloor = this.getNextFloor();

        if (!nextFloor) {
            return;
        }

        if (currentFloor + direction === nextFloor) {
            this.stopAndOpenDoors();
        }
    },

    onFloorButtonPressed: function(floor, direction) {
        tihs.addToQueue(floor, direction);
    },

    onCabinButtonPressed: function(floor) {
        const currentFloor = this.getCurrentFloor();

        if (floor === currentFloor) {
            return;
        }

        const direction = floor > currentFloor ? DIRECTION_UP : DIRECTION_DOWN;

        this.addToQueue(floor, direction);
    }
}