package org.litesoft.sandbox.anywhere.die;

import java.util.*;

import static org.litesoft.sandbox.anywhere.die.View.*;

public class State {
    private Map<View, Integer> mViewValues = new EnumMap<View, Integer>( View.class );
    private final Orientation mOrientation;

    /**
     * Initialize to Identifier 1?2
     */
    public State( Orientation pOrientation ) {
        mViewValues.put( Result, 1 );
        mViewValues.put( Other, 6 );

        mViewValues.put( North, 2 );
        mViewValues.put( South, 5 );

        if ( Orientation.L.equals( mOrientation = pOrientation ) ) {
            mViewValues.put( East, 3 );
            mViewValues.put( West, 4 );
        } else {
            mViewValues.put( West, 3 );
            mViewValues.put( East, 4 );
        }
    }

    public synchronized Identifier getIdentifier() {
        return new Identifier( mOrientation, getValue(), getValue( North ) );
    }

    public int getValue() {
        return getValue( Result );
    }

    public synchronized Integer getValue( View pView ) {
        return mViewValues.get( pView );
    }

    public synchronized View getViewForValue( int pValue ) {
        for ( View zView : View.values() ) {
            if ( pValue == getValue( zView ) ) {
                return zView;
            }
        }
        return null;
    }

    public synchronized void adjustTo( Identifier pIdentifier ) {
        if ( pIdentifier == null ) {
            return;
        }
        if ( mOrientation != pIdentifier.getOrientation() ) {
            throw new IllegalStateException( "Orientation Incompatible" );
        }
        makeResultEqual( pIdentifier.getFace() );
        makeNorthEqual( pIdentifier.getNorthSide() );
    }

    public void makeNorthResult() {
        rollToSide( North ); // Move Down
    }

    public void makeSouthResult() {
        rollToSide( South ); // Move Up
    }

    public void makeWestResult() {
        rollToSide( West ); // Move Right
    }

    public void makeEastResult() {
        rollToSide( East ); // Move Left
    }

    public void makeWestNorth() // Rotate Clockwise
    {
        rotateEastOrWestToNorth( West );
    }

    public void makeEastNorth() // Rotate Counter-Clockwise
    {
        rotateEastOrWestToNorth( East );
    }

    public void rotate180degrees() {
        moveSides( North, South, //
                   East, West, //
                   West, East, //
                   South, North );
    }

    public void rollOver() {
        moveSides( Result, Other, // Rotate around the East-West Axis
                   North, South, //
                   South, North, //
                   Other, Result );
    }

    private void rotateEastOrWestToNorth( View pFromSide ) {
        View zOpposite = pFromSide.opposite();
        moveSides( pFromSide, North, //
                   North, zOpposite, //
                   zOpposite, South, //
                   South, pFromSide );
    }

    private void rollToSide( View pFromSide ) {
        View zOpposite = pFromSide.opposite();
        moveSides( Other, pFromSide, //
                   pFromSide, Result, //
                   Result, zOpposite, //
                   zOpposite, Other );
    }

    private void makeResultEqual( int pValue ) {
        switch ( getViewForValue( pValue ) ) {
            case North:
                makeNorthResult();
                break;
            case East:
                makeEastResult();
                break;
            case West:
                makeWestResult();
                break;
            case South:
                makeSouthResult();
                break;
            case Other:
                rollOver();
                break;
            default: // & Result
                break;
        }
    }

    private void makeNorthEqual( int pValue ) {
        switch ( getViewForValue( pValue ) ) {
            default: // & North
                break;
            case East:
                makeEastNorth();
                break;
            case West:
                makeWestNorth();
                break;
            case South:
                rotate180degrees();
                break;
            case Other:
                makeNorthResult(); // Result changed!
                break;
            case Result:
                makeSouthResult(); // Result changed!
                break;
        }
    }

    private synchronized void moveSides( View... pFromToViewPairs ) {
        Map<View, Integer> zViewValues = new EnumMap<View, Integer>( mViewValues );
        for ( int i = 0; i < pFromToViewPairs.length; ) {
            // **** Do NOT inline the following
            View zFromView = pFromToViewPairs[i++];
            View zToView = pFromToViewPairs[i++];
            zViewValues.put( zToView, mViewValues.get( zFromView ) ); // Copy Value "From" to "To"
        }
        mViewValues = zViewValues;
    }
}