package boarding.relogo

import static repast.simphony.relogo.Utility.*;
import static repast.simphony.relogo.UtilityG.*;
import repast.simphony.relogo.Stop;
import repast.simphony.relogo.Utility;
import repast.simphony.relogo.UtilityG;
import repast.simphony.relogo.schedule.Go;
import repast.simphony.relogo.schedule.Setup;
import boarding.ReLogoObserver;

class UserObserver extends ReLogoObserver
{
    List<Integer> freeSeats = java.util.stream.IntStream.rangeClosed(1, 3).toArray()
    Map<Integer, List<Integer>> seatCoords = new HashMap<Integer, List<Integer>>()

    Integer maxPassengers = 3

    Map<Passenger, List<Passenger>> shufflingPassengers = new HashMap<Passenger, List<Passenger>>()

    @Setup
    def setup()
    {
        GeneratePlane()

        setDefaultShape(Passenger, "person")
        __Board(patch(-10, 0)) //first person
    }

    @Go
    def go()
    {
        def passengers = turtles()

        MovePassengers(passengers)

        BoardNewPassenger(passengers)
    }

    def __CheckNextPassengerIfShuffling(movingPassenger, parentPassenger, listMovingPassengers)
    {
        def parentSeatX, parentSeatY
        (parentSeatX, parentSeatY) = GetSeatCoords(parentPassenger.seatID)

        def seatX, seatY
        (seatX, seatY) = GetSeatCoords(movingPassenger.seatID)

        def sign = CalculateSeatSide(parentPassenger, parentSeatY)

        def movingPassSign = CalculateSeatSide(movingPassenger, seatY)

        if(seatX == movingPassenger.getXcor() && movingPassSign == sign) // Passenger has seat at opposite side of plane
        {
            if(sign < 0)
            {
                if(seatY > parentSeatY)
                {
                    if(movingPassenger.parent != null)
                        return true

                    movingPassenger.moving = true

                    movingPassenger.parent = parentPassenger

                    listMovingPassengers = shufflingPassengers.get(parentPassenger)
                    listMovingPassengers.add(movingPassenger)

                    return false
                }
            }
            else
            {
                if(seatY < parentSeatY)
                {
                    if(movingPassenger.parent != null)
                        return true

                    movingPassenger.moving = true

                    movingPassenger.parent = parentPassenger

                    listMovingPassengers = shufflingPassengers.get(parentPassenger)
                    listMovingPassengers.add(movingPassenger)

                    return false
                }
            }
        }
    }

    def DefinePassengersToShuffle(parentPassenger, parentSeatX, parentSeatY)
    {
        def sign = CalculateSeatSide(parentPassenger, parentSeatY)

        if(sign < 0)
        {
            def listMovingPassengers = new ArrayList<Passenger>()
            for(int y = 0; y > parentSeatY; y += sign)
            {
                def turtles = turtlesOn(patch(parentSeatX, y))

                if(turtles.size() != 1)
                    continue

                def movingPassenger = turtles.get(0)

                def passengerBusy = __CheckNextPassengerIfShuffling(movingPassenger, parentPassenger, listMovingPassengers)

                return passengerBusy
            }
        }
        else
        {
            def listMovingPassengers = new ArrayList<Passenger>()
            for(int y = 0; y < parentSeatY; y += sign)
            {
                def turtles = turtlesOn(patch(parentSeatX, y))

                if(turtles.size() != 1)
                    continue

                def movingPassenger = turtles.get(0)

                def passengerBusy = __CheckNextPassengerIfShuffling(movingPassenger, parentPassenger, listMovingPassengers)

                return passengerBusy
            }
        }
    }

    def MovePassengers(passengers)
    {
        for(int index = 0; index < passengers.size(); index++)
        {
            def currentPassenger = passengers.get(index)

            if(currentPassenger.shuffling)
            {
                SeatShuffle2(currentPassenger)
            }
            else
            {
                if(currentPassenger.seated || currentPassenger.moving)
                    continue

                def currentPatch = currentPassenger.patchHere()

                def seatX
                def seatY
                (seatX, seatY) = GetSeatCoords(currentPassenger.seatID)

                if(seatX == currentPassenger.getXcor() + 1)
                {
                    shufflingPassengers.put(currentPassenger, new ArrayList<Passenger>())

                    def passengerBusy = DefinePassengersToShuffle(currentPassenger, seatX, seatY)

                    if(passengerBusy == true)
                    {
                        shufflingPassengers.remove(currentPassenger)
                    }
                    else
                    {
                        currentPassenger.shuffling = true
                        currentPassenger.parent = currentPassenger
                        SeatShuffle2(currentPassenger)
                    }
                }
                else
                {
                    MoveToNextPatch(currentPassenger)
                }
            }
        }
    }

    def SeatShuffle2(parentPassenger)
    {
        def passengersNeededToMove = shufflingPassengers.get(parentPassenger)

        def passengersNum = passengersNeededToMove.size()

        def CloserFurther = GetCloserFurtherPassenger(passengersNeededToMove)

        def passengerClosestToCorridor = CloserFurther[0]
        def passengerFurtherToCorridor = CloserFurther[1]

        if(passengersNum == 0)
        {
            ExecuteParentSuffle(parentPassenger, passengersNum)
        }

        else // There are some passengers that need to move.
        {
            if(passengersNum == 1) // passengerFurtherToCorridor == null (only one passenger needs to move)
            {
                if(passengerClosestToCorridor.goingToSeat == true)
                    return

                if(passengerClosestToCorridor.movedOnRightPosition == false)
                    ExecuteShuffleStep(passengerClosestToCorridor, parentPassenger)

                else if(passengerClosestToCorridor.movedOnRightPosition == true || passengerClosestToCorridor.seated == true)
                {
                    ExecuteParentSuffle(parentPassenger, passengersNum)
                    ExecuteShuffleStep(passengerClosestToCorridor, parentPassenger)
                }
            }

            else if(passengersNum == 2)
            {
                if(passengerClosestToCorridor.goingToSeat == true || passengerFurtherToCorridor.goingToSeat == true)
                    return

                if(passengerClosestToCorridor.movedOnRightPosition == false && passengerFurtherToCorridor.movedOnRightPosition == false)
                {
                    ExecuteShuffleStep(passengerClosestToCorridor, parentPassenger, 2)
                    ExecuteShuffleStep(passengerFurtherToCorridor, parentPassenger, 1)
                }

                else if((passengerClosestToCorridor.movedOnRightPosition == true || passengerClosestToCorridor.seated == true) &&
                    (passengerFurtherToCorridor.movedOnRightPosition == true || passengerFurtherToCorridor.seated == true))
                {
                    ExecuteParentSuffle(parentPassenger, passengersNum)
                    ExecuteShuffleStep(passengerFurtherToCorridor, parentPassenger, 1)
                    ExecuteShuffleStep(passengerClosestToCorridor, parentPassenger, 2)

                }
            }
        }

        println("Shuffling Passengers:")
        println(shufflingPassengers)

        println("parent passenger: " + parentPassenger.seatID)
        println("passengersNum = " + passengersNum)
        for(int i = 0; i < passengersNum; i++)
        {
            def pass = passengersNeededToMove.get(i)
            println("moving passenger: " + pass.seatID)
            println("seated = " + pass.seated)
            println("shuffling = " + pass.shuffling)
            println("moving = " + pass.moving)
            println("movedOnRightPosition = " + pass.movedOnRightPosition)
            println("comingBack = " + pass.comingBack)
            println("goingToSeat = " + pass.goingToSeat)
        }
        println("-------------")

    }

    def ExecuteParentSuffle(parentPassenger, passengersNeededToMoveSize)
    {
        def seatX, seatY
        (seatX, seatY) = GetSeatCoords(parentPassenger.seatID)

        def pasX = parentPassenger.getXcor()
        def pasY = parentPassenger.getYcor()

        if(pasX == seatX)
        {
            MoveTowardSeat(parentPassenger)

            pasY = parentPassenger.getYcor()
            if(pasY == seatY)
            {
                parentPassenger.seated = true
                parentPassenger.goingToSeat = false

                if(passengersNeededToMoveSize == 0)
                {
                    shufflingPassengers.remove(parentPassenger)
                    parentPassenger.shuffling = false
                    parentPassenger.parent = null
                }
            }
        }
        else
        {
            parentPassenger.goingToSeat = true
            MoveToNextPatch(parentPassenger)
        }
    }

    /**
     * Execute shuffle for passenger that needs to move.
     *
     * @param passenger Passenger that needs to move.
     * @param parentPassenger Parent passenger of passenger.
     * @param placeOffset Offset of passenger's seatX set to 1 as default (assuming only one passenger needs to move).
     */
    def ExecuteShuffleStep(passenger, parentPassenger, placeOffset=1)
    {
        def shufSeatX, shufSeatY
        (shufSeatX, shufSeatY) = GetSeatCoords(passenger.seatID)

        def shufCurrentX = passenger.getXcor()
        def shufCurrentY = passenger.getYcor()

        if(shufCurrentY == 0 || passenger.comingBack == true) // At corridor
        {
            if(!passenger.movedOnRightPosition) // Moving for parent to be able to take their seat
            {
                MoveToNextPatch(passenger)

                shufCurrentX = passenger.getXcor()
                if(shufCurrentX == shufSeatX + placeOffset)
                    passenger.movedOnRightPosition = true
            }
            else if(parentPassenger.getYcor() != 0) // Parent is moving to his seat
            {
                passenger.comingBack = true
                ComeBackToSeat(passenger)

                CheckIfPassengersSeated(parentPassenger)
            }
            // else wait till everything is done
        }
        else
        {
            MoveTowardCorridor(passenger)

            shufCurrentY = passenger.getYcor()
            if(passenger.seated && shufCurrentY != shufSeatY)
            {
                passenger.seated = false
                passenger.moving = true
            }
        }
    }

    def CalculateSeatSide(passenger, seatY)
    {
        def sign
        if(seatY < 0)
            sign = -1
        else
            sign = 1

        return sign
    }

    def ComeBackToSeat(passenger)
    {
        def seatX, seatY
        (seatX, seatY) = GetSeatCoords(passenger.seatID)

        def sign = CalculateSeatSide(passenger, seatY)

        def pasX = passenger.getXcor()
        def pasY = passenger.getYcor()

        def currentPatch = patch(pasX, pasY)

        if(pasX != seatX)
        {
            MoveToPreviousPatch(passenger)
        }
        else
        {
            MoveTowardSeat(passenger)

            pasY = passenger.getYcor()
            if(pasY == seatY)
            {
                passenger.movedOnRightPosition = false
                passenger.comingBack = false
                passenger.seated = true
                passenger.moving = false
            }
        }
    }

    def CheckIfPassengersSeated(parentPassenger)
    {
        def passengers = shufflingPassengers.get(parentPassenger)
        def pasSize = passengers.size()

        def numSeated = 0

        if(parentPassenger.seated == true)
            numSeated++

        for(int i = 0; i < pasSize; i++)
        {
            if(passengers.get(i).seated == true)
                numSeated++
        }

        if(numSeated == pasSize + 1) // parent + children
        {
            for(int i = 0; i < pasSize; i++)
            {
                def pas = passengers.get(i)
                pas.parent = null
            }
            parentPassenger.shuffling = false
            parentPassenger.parent = null
            shufflingPassengers.remove(parentPassenger)
        }
    }

    def MoveToPreviousPatch(passenger)
    {
        def seatX, seatY
        (seatX, seatY) = GetSeatCoords(passenger.seatID)

        def sign = CalculateSeatSide(passenger, seatY)

        def pasX = passenger.getXcor()
        def pasY = passenger.getYcor()

        def currentPatch = patch(pasX, pasY)
        def previousPatch = patch(pasX - 1, pasY)

        if(!previousPatch.occupied)
        {
            currentPatch.occupied = false
            passenger.moveTo(previousPatch)
            previousPatch.occupied = true
        }
    }

    def MoveToNextPatch(passenger)
    {
        def seatX, seatY
        (seatX, seatY) = GetSeatCoords(passenger.seatID)

        def sign = CalculateSeatSide(passenger, seatY)

        def pasX = passenger.getXcor()
        def pasY = passenger.getYcor()

        def currentPatch = patch(pasX, pasY)
        def nextPatch = patch(pasX + 1, pasY)

        if(!nextPatch.occupied)
        {
            currentPatch.occupied = false
            passenger.moveTo(nextPatch)
            nextPatch.occupied = true
        }
    }

    def MoveTowardSeat(passenger)
    {
        def seatX, seatY
        (seatX, seatY) = GetSeatCoords(passenger.seatID)

        def sign = CalculateSeatSide(passenger, seatY)

        def pasX = passenger.getXcor()
        def pasY = passenger.getYcor()

        def currentPatch = patch(pasX, pasY)
        def patchNextSeat = patch(pasX, pasY += sign)

        if(!patchNextSeat.occupied)
        {
            currentPatch.occupied = false
            passenger.moveTo(patchNextSeat)
            patchNextSeat.occupied = true
        }
    }

    def MoveTowardCorridor(passenger)
    {
        def seatX, seatY
        (seatX, seatY) = GetSeatCoords(passenger.seatID)

        def sign = CalculateSeatSide(passenger, seatY)

        def pasX = passenger.getXcor()
        def pasY = passenger.getYcor()

        def currentPatch = patch(pasX, pasY)
        def patchNextSeat = patch(pasX, pasY -= sign)

        if(!patchNextSeat.occupied)
        {
            currentPatch.occupied = false
            passenger.moveTo(patchNextSeat)
            patchNextSeat.occupied = true
        }
    }

    def GetSeatCoords(ID)
    {
        def coords = seatCoords.get(ID)
        return coords
    }

    def GetCloserFurtherPassenger(passengersNeededToMove)
    {
        def passengersNum = passengersNeededToMove.size()

        def passengerClosestToCorridor = null
        def passengerFurtherToCorridor = null

        def tempY = 0
        for(int i = 0; i < passengersNum; i++)
        {
            def passenger = passengersNeededToMove[i]
            if(tempY == 0 || abs(passenger.getYcor()) < tempY)
            {
                tempY = abs(passenger.getYcor())

                if(passengerClosestToCorridor != null)
                    passengerFurtherToCorridor = passengerClosestToCorridor // previous closest is now further

                passengerClosestToCorridor = passenger
            }
            else
                passengerFurtherToCorridor = passenger
        }

        def CloserFurther = [passengerClosestToCorridor, passengerFurtherToCorridor]
        return CloserFurther
    }

    def GeneratePlane()
    {
        def corridorColor = 5
        def seatColor = 105
        def count = 1

        for(int x = -10; x <= 10; x++)
        {
            if(seatColor == 105)
                seatColor = 106
            else
                seatColor = 105

            for(int y = 3; y >= -3; y--)
            {
                def currentPatch = patch(x, y)

                if(x > -8 && x < 9 && y != 0)
                {
                    currentPatch.setPcolor(seatColor)
                    currentPatch.ID = count
                    seatCoords.put(count, [x, y])
                    currentPatch.setPlabel(currentPatch.ID)
                    count++

                    if(seatColor == 105)
                        seatColor = 106
                    else
                        seatColor = 105
                }
                else
                {
                    currentPatch.setPcolor(corridorColor)

                    if(corridorColor == 5)
                        corridorColor = 6
                    else
                        corridorColor = 5
                }
            }
        }
    }

    def __Board(firstPatch)
    {
        def passenger = createPassengers(1)

        passenger[0].setXcor(-10)
        passenger[0].setYcor(0)

        passenger[0].setColor(white())

        def id_index = random(freeSeats.size())
        passenger[0].seatID = freeSeats.remove(id_index)
        passenger[0].setLabel(passenger[0].seatID)
        passenger[0].setLabelColor(black())

        def currentPatch = passenger[0].patchHere()
        currentPatch.occupied = true
    }

    def BoardNewPassenger(passengers)
    {
        def firstPatch = patch(-10, 0)
        if(!firstPatch.occupied && passengers.size() != maxPassengers)
        {
            __Board(firstPatch)
        }
    }
}