TwistyPuzzleLib

///////////////////////////////////////////////////////////////////////////////////////////////////

// Copyright 2022 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Magic Cube.                                                              //

//                                                                                               //

// Magic Cube is proprietary software licensed under an EULA which you should have received      //

// along with the code. If not, check https://distorted.org/magic/License-Magic-Cube.html        //

///////////////////////////////////////////////////////////////////////////////////////////////////

package org.distorted.objectlib.scrambling;

import org.distorted.objectlib.signature.ObjectSignature;

///////////////////////////////////////////////////////////////////////////////////////////////////

// Info about a scramble state of any bandaged cuboids or pyraminxes.

public class ScrambleStateLocallyBandaged

{

  public static int MAX_SUPPORTED_SIZE = 7;

  public static final int AXIS_NONE = -1;

  private final ObjectSignature[] mMoves;

  private final ObjectSignature mSignature;

  private final int[] mLayer, mTurns, mSize, mStart;

  private final int mNumMoves;

  private final boolean[][] mIsUnblocked;

  private final int mNumAxis;

///////////////////////////////////////////////////////////////////////////////////////////////////

  public ScrambleStateLocallyBandaged(int[] numLayers, ObjectSignature signature, BlacklistedSignatures blacklisted)

    {

    mNumAxis = numLayers.length;

    mLayer = new int[mNumAxis];

    mTurns = new int[mNumAxis];

    mSize  = new int[mNumAxis];

    mStart = new int[mNumAxis+1];

    mIsUnblocked = new boolean[mNumAxis][MAX_SUPPORTED_SIZE];

    for(int a=0; a<mNumAxis; a++)

      {

      mLayer[a] = numLayers[a];

      }

    if( mNumAxis==3 )

      {

      mTurns[0] = (mLayer[1]==mLayer[2] ? 3 : 1);

      mTurns[1] = (mLayer[0]==mLayer[2] ? 3 : 1);

      mTurns[2] = (mLayer[0]==mLayer[1] ? 3 : 1);

      }

    else if( mNumAxis==4 )

      {

      mTurns[0] = 2;

      mTurns[1] = 2;

      mTurns[2] = 2;

      mTurns[3] = 2;

      }

    else if( mNumAxis==6 )

      {

      mTurns[0] = 4;

      mTurns[1] = 4;

      mTurns[2] = 4;

      mTurns[3] = 4;

      mTurns[4] = 4;

      mTurns[5] = 4;

      }

    int numMoves = 0;

    for(int a=0; a<mNumAxis; a++)

      {

      mSize[a] = (mLayer[a]>1 ? mLayer[a] : 0);

      int tmp = mTurns[a]*mSize[a];

      numMoves += tmp;

      if( a==0 ) mStart[a] = 0;

      else       mStart[a] = mStart[a-1] + tmp;

      }

    mStart[mNumAxis] = numMoves;

    mNumMoves = numMoves;

    mSignature = signature;

    mMoves = createMoves(blacklisted);

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public ObjectSignature getSignature()

    {

    return mSignature;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public ObjectSignature getMove(int index)

    {

    return (index>=0 && index<mNumMoves) ? mMoves[index] : null;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public void removeMoves(ObjectSignature signature)

    {

    for(int m=0; m<mNumMoves; m++)

      if( mMoves[m]!=null && signature.isEqual(mMoves[m]) ) mMoves[m]=null;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public int numAxis()

    {

    int num = 0;

    for(int a=0; a<mNumAxis; a++)

      for(int x=mStart[a]; x<mStart[a+1]; x++)

        if( mMoves[x]!=null ) { num++; break; }

    return num;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private int numMovesInAx(int ax)

    {

    int num=0;

    for(int x=mStart[ax]; x<mStart[ax+1]; x++) if( mMoves[x]!=null ) num++;

    return num;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private int numMovesInAx(int ax, int excludedLayer)

    {

    int num=0;

    for(int x=mStart[ax]; x<mStart[ax+1]; x++)

      if( mMoves[x]!=null && (x-mStart[ax])%mLayer[ax]!=excludedLayer ) num++;

    return num;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private int numAllMoves()

    {

    int num=0;

    for(int x=0; x<mNumMoves; x++) if( mMoves[x]!=null ) num++;

    return num;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private int numAllMoves(int excludedLayer)

    {

    int num=0;

    for(int a=0; a<mNumAxis; a++)

      for(int x=mStart[a]; x<mStart[a+1]; x++)

        if( mMoves[x]!=null && (x-mStart[a])%mLayer[a]!=excludedLayer ) num++;

    return num;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public int numMoves(int excludedAxis)

    {

    if( excludedAxis>=0 && excludedAxis<mNumAxis )

      return numAllMoves() - numMovesInAx(excludedAxis);

    return numAllMoves();

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public int numMoves(int excludedAxis, int excludedLayer)

    {

    if( excludedAxis>=0 && excludedAxis<mNumAxis )

      return numAllMoves(excludedLayer) - numMovesInAx(excludedAxis, excludedLayer);

    return numAllMoves(excludedLayer);

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public int getNthMove(int n, int excludedAxis)

    {

    int num = 0;

    for(int a=0; a<mNumAxis; a++)

      if( excludedAxis!=a )

        {

        for(int m=mStart[a]; m<mStart[a+1]; m++)

          if( mMoves[m]!=null )

            {

            if( num==n ) return m;

            num++;

            }

        }

    return -1;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public int getNthMove(int n, int excludedAxis, int excludedLayer)

    {

    int num = 0;

    for(int a=0; a<mNumAxis; a++)

      if( excludedAxis!=a )

        {

        for(int m=mStart[a]; m<mStart[a+1]; m++)

          if( mMoves[m]!=null && (m-mStart[a])%mLayer[a]!=excludedLayer )

            {

            if( num==n ) return m;

            num++;

            }

        }

    return -1;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private ObjectSignature[] createMoves(BlacklistedSignatures blacklisted)

    {

    ObjectSignature[] ret = new ObjectSignature[mNumMoves];

    int index = 0;

    for(int axis=0; axis<mNumAxis; axis++)

      for(int layer=0; layer<mLayer[axis]; layer++)

        {

        mIsUnblocked[axis][layer] = mSignature.isUnblockedFromLeft(axis,layer);

        }

    for(int axis=0; axis<mNumAxis; axis++)

      if( mLayer[axis]>1 )

        for(int turn=1; turn<=mTurns[axis]; turn++)

          {

          boolean allLayersLocked = true;

          int begIndex = index;

          for(int layer=0; layer<mLayer[axis]; layer++)

            {

            if( mIsUnblocked[axis][layer] )

              {

              if( layer>0 ) allLayersLocked = false;

              ret[index] = mSignature.turn(axis,layer,turn);

              }

            else

              {

              ret[index] = ret[index-1].turn(axis,layer,turn);

              ret[index-1] = null;

              }

            index++;

            }

          for(int i=begIndex; i<index; i++)

            {

            if( ret[i]!=null && blacklisted.contains(ret[i]) ) ret[i]=null;

            }

          if( allLayersLocked ) ret[index-1] = null;

          }

    return ret;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public void fillOutScramble(int[] scramble, int moveIndex)

    {

    for(int axis=0; axis<mNumAxis; axis++)

      {

      int size = mTurns[axis]*mSize[axis];

      if( moveIndex<size )

        {

        scramble[0] = axis;

        scramble[1] = moveIndex % mSize[axis];

        switch( mTurns[axis] )

          {

          case 2: switch(moveIndex/mSize[axis])

                    {

                    case 0: scramble[2] =-1; break;

                    case 1: scramble[2] = 1; break;

                    }

                  break;

          case 3: switch(moveIndex/mSize[axis])

                    {

                    case 0: scramble[2] =-1; break;

                    case 1: scramble[2] = 2; break;

                    case 2: scramble[2] = 1; break;

                    }

                  break;

          case 4: switch(moveIndex/mSize[axis])

                    {

                    case 0: scramble[2] =-1; break;

                    case 1: scramble[2] =-2; break;

                    case 2: scramble[2] = 2; break;

                    case 3: scramble[2] = 1; break;

                    }

                  break;

          default:scramble[2] = 1;

                  android.util.Log.e("D", "ScrambleStateLocallyBandaged: unsupported turns: "+mTurns[axis]);

          }

        return;

        }

      moveIndex -= size;

      }

    android.util.Log.e("D", "ERROR in fillOutScramble moveIndex="+moveIndex);

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private void printMoves()

    {

    for(int i=0; i<mNumMoves; i++)

      {

      android.util.Log.e("D", "move "+i+" : "+(mMoves[i]!=null ? " "+mMoves[i].getString() : " NULL") );

      }

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private static String printBits(long id)

    {

    String ret = "[";

    boolean first = true;

    for(int i=0; i<64; i++)

      {

      if( ( (id>>i)&0x1)==1 )

        {

        String num = (i<10 ? " "+i : ""+i);

        if( first ) { ret += num; first=false; }

        else          ret += (","+num);

        }

      }

    return ret + "]";

    }

}