// NOTE. Most Player code is in AbstractPlayer
// (which is the base class for AutoPlayer as well as Player).
class Player : AbstractPlayer {

    var left : Input
    var right : Input
    var up : Input
    var down : Input

    var shuffleLeft : Input
    var shuffleRight : Input
    var shuffleUp : Input
    var shuffleDown : Input

    var nextPlayer : Input

    override fun begin() {
        super.begin()

        val inputs = Game.instance.resources.inputs

        left = inputs.find( "left" )
        right = inputs.find( "right" )
        up = inputs.find( "up" )
        down = inputs.find ( "down" )

        shuffleLeft = inputs.find( "shuffleLeft" )
        shuffleRight = inputs.find( "shuffleRight" )
        shuffleUp = inputs.find( "shuffleUp" )
        shuffleDown = inputs.find( "shuffleDown" )

        nextPlayer = inputs.find( "nextPlayer" )
    }

    override fun end() {
        super.end()
        PlayDirector.instance.playerDied(this)
    }

    override fun myTurn() {
        if (!awake) return


        if ( autoInstructions == "" ) {
            if (shuffleRight.isPressed()) {
                addAutoMoves( "EW" )
                return
            }
            if (shuffleLeft.isPressed()) {
                addAutoMoves( "WE" )
                return
            }
            if (shuffleUp.isPressed()) {
                addAutoMoves( "NS" )
                return
            }
            if (shuffleDown.isPressed()) {
                addAutoMoves( "SN" )
                return
            }
    

            if ( left.isPressed() && tryToMove( WEST ) ) {
                return
            }
            if ( up.isPressed() && tryToMove( NORTH ) ) {
                return
            }
            if ( right.isPressed() && tryToMove( EAST ) ) {
                return
            }
            if ( down.isPressed() && tryToMove( SOUTH ) ) {
                return
            }


            if (nextPlayer.isPressed()) {
                if ( PlayDirector.instance.tester != null ) {
                    print( "x" )
                }
                PlayDirector.instance.wakeUpNextPlayer()
            }


        } else {
            autoPlay()
        }

    }

    // Print the moves that are made when using a TestDirector.
    // I use this to create solutions that can be replayed to test that the level is
    // still possible if/when code is changed.
    override fun tryToMove( direction : int ) : boolean {
        val result = super.tryToMove( direction )
        if (result && PlayDirector.instance.tester != null) {
            print( "RULD".substring( direction, direction + 1 ) )
        }
        return result
    }

    fun addAutoMoves( moves : String ) {
        autoInstructions = moves + autoInstructions
    }
}