import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.BlockingQueue;

public class Elevator implements Runnable{

	int currentPosition;

	BlockingQueue<ElevatorCall> queue;
	List<Integer> destinationFloors;
	List<ElevatorCall> peopleOnElevator;

	public Elevator(BlockingQueue<ElevatorCall> queue)
	{
		this.currentPosition = 0;
		this.queue = queue;
	}

	@Override
	public synchronized void run()
	{
		while(true)
		{


			List<ElevatorCall> callsWaiting = new ArrayList<ElevatorCall>();
			queue.drainTo(callsWaiting);

			for(int i = 0; i < callsWaiting.size(); i++)
			{
				boolean directionToGo = getDirection(callsWaiting.get(i).getDestinationFloor(), currentPosition);
				int floorsToGoForCollection = getFloorsToGo(callsWaiting.get(i).getCollectionFloor());
				int floorsToGoForDestination = getFloorsToGo(callsWaiting.get(i).getDestinationFloor());

				System.out.println("Elevator is moving to floor #" + callsWaiting.get(i).getCollectionFloor());
				System.out.println("Elevator is on floor " + currentPosition);

				for(int j = 0; j < floorsToGoForCollection; j++)
				{
					boolean wasPersonOnFloor = checkIfPersonIsOnFloor(currentPosition, callsWaiting);
					boolean isDestinationFloor = checkIfDestination(currentPosition, callsWaiting);

					if(wasPersonOnFloor)
						System.out.println("A person on this floor called the elevator");

					if(isDestinationFloor)
						callsWaiting = removeDestinationFromQueue(currentPosition, callsWaiting);


					wasPersonOnFloor = false;
					moveFloor(directionToGo);

				}
			}
			return;
		}
	}

	//Checks and returns if the current floor is the destination for any elements of the queue
	public boolean checkIfDestination(int currentPosition, List<ElevatorCall> callsWaiting)
	{
		boolean isDestination = false;

		for(int i = 0; i < callsWaiting.size(); i++)
		{
			if(callsWaiting.get(i).getDestinationFloor() == currentPosition)
			{
				isDestination = true;
				break;
			}
		}

		return isDestination;
	}

	//Removes a call from the queue if it is a destination floor
	private List<ElevatorCall> removeDestinationFromQueue(int currentPosition, List<ElevatorCall> callsWaiting)
	{
		List<ElevatorCall> newCallsWaiting = callsWaiting;

		for(int i = 0; i < callsWaiting.size(); i++)
		{
			if(callsWaiting.get(i).getDestinationFloor() == currentPosition)
			{
				callsWaiting.remove(i);
				System.out.println("This floor was a destination, queue shortened");
			}
		}

		return newCallsWaiting;
	}

	//Gets how many floors until elevator reaches its destination
	public int getFloorsToGo(int destinationFloor)
	{
		int floorsToGo = destinationFloor - currentPosition;
		return floorsToGo;
	}

	//Moves up or down dependent on direction
	public synchronized void moveFloor(boolean direction)
	{
		if(direction = false)
			currentPosition--;
		else
			currentPosition++;

		System.out.println("Elevator is on floor " + currentPosition);

		try {
			wait(100);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	//Direction to move, true is up, false is down
	public boolean getDirection(int destinationFloor, int currentPosition)
	{
		boolean directionToGo = true;

		if(destinationFloor < currentPosition)
			directionToGo = false;

		return directionToGo;
	}

	//Checks and returns if a person is on the current floor
	public boolean checkIfPersonIsOnFloor(int currentPosition, List<ElevatorCall> callsWaiting)
	{
		boolean wasPersonOnFloor = false;

		for(int i = 0; i < callsWaiting.size(); i++)
		{
			if(callsWaiting.get(i).getCollectionFloor() == currentPosition)
			{
				wasPersonOnFloor = true;
				break;
			}
		}

		return wasPersonOnFloor;
	}
}