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.helpers.ObjectSignature;

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

// Info about a scramble state of any bandaged cuboid.

public class ScrambleStateBandagedCuboid

{

  public static int MAX_SUPPORTED_SIZE = 7;

  public static final int AXIS_NONE = -1;

  public static final int AXIS_X = 0;

  public static final int AXIS_Y = 1;

  public static final int AXIS_Z = 2;

  private final ObjectSignature[] mMoves;

  private final ObjectSignature mSignature;

  private final int[] mLayer, mTurns, mSize;

  private final int mNumMoves;

  private final int mStartX, mStartY, mStartZ;

  private final boolean[][] mIsUnblocked;

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

  public ScrambleStateBandagedCuboid(int x, int y, int z, ObjectSignature signature, BlacklistedSignatures blacklisted)

    {

    mLayer = new int[3];

    mTurns = new int[3];

    mSize  = new int[3];

    mIsUnblocked = new boolean[3][MAX_SUPPORTED_SIZE];

    mLayer[0] = x;

    mLayer[1] = y;

    mLayer[2] = z;

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

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

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

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

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

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

    int xMoves = mTurns[0]*mSize[0];

    int yMoves = mTurns[1]*mSize[1];

    int zMoves = mTurns[2]*mSize[2];

    mNumMoves = xMoves + yMoves + zMoves;

    mStartX = 0;

    mStartY = xMoves;

    mStartZ = xMoves + yMoves;

    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 x=mStartX; x<mStartY  ; x++) if( mMoves[x]!=null ) { num++; break; }

    for(int y=mStartY; y<mStartZ  ; y++) if( mMoves[y]!=null ) { num++; break; }

    for(int z=mStartZ; z<mNumMoves; z++) if( mMoves[z]!=null ) { num++; break; }

    return num;

    }

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

  private int numXMoves()

    {

    int num=0;

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

    return num;

    }

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

  private int numYMoves()

    {

    int num=0;

    for(int y=mStartY; y<mStartZ; y++) if( mMoves[y]!=null ) num++;

    return num;

    }

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

  private int numZMoves()

    {

    int num=0;

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

    return num;

    }

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

  public int numMoves()

    {

    return numXMoves()+numYMoves()+numZMoves();

    }

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

  public int numMoves(int excludedAxis)

    {

    switch(excludedAxis)

      {

      case AXIS_X: return numYMoves()+numZMoves();

      case AXIS_Y: return numXMoves()+numZMoves();

      case AXIS_Z: return numXMoves()+numYMoves();

      }

    return numXMoves()+numYMoves()+numZMoves();

    }

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

  public int getNthMove(int n, int excludedAxis)

    {

    int num = 0;

    if( excludedAxis!=0 )

      {

      for(int m=mStartX; m<mStartY; m++)

        if( mMoves[m]!=null )

          {

          if( num==n ) return m;

          num++;

          }

      }

    if( excludedAxis!=1 )

      {

      for(int m=mStartY; m<mStartZ; m++)

        if( mMoves[m]!=null )

          {

          if( num==n ) return m;

          num++;

          }

      }

    if( excludedAxis!=2 )

      {

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

        if( mMoves[m]!=null )

          {

          if( num==n ) return m;

          num++;

          }

      }

    return -1;

    }

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

  private int numXMoves(int excludedLayer)

    {

    int num=0;

    for(int x=mStartX; x<mStartY; x++) if( mMoves[x]!=null && (x-mStartX)%mLayer[0]!=excludedLayer ) num++;

    return num;

    }

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

  private int numYMoves(int excludedLayer)

    {

    int num=0;

    for(int y=mStartY; y<mStartZ; y++) if( mMoves[y]!=null && (y-mStartY)%mLayer[1]!=excludedLayer ) num++;

    return num;

    }

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

  private int numZMoves(int excludedLayer)

    {

    int num=0;

    for(int z=mStartZ; z<mNumMoves; z++) if( mMoves[z]!=null && (z-mStartZ)%mLayer[2]!=excludedLayer ) num++;

    return num;

    }

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

  public int numMoves(int excludedAxis, int excludedLayer)

    {

    switch(excludedAxis)

      {

      case AXIS_X: return numYMoves(excludedLayer)+numZMoves(excludedLayer);

      case AXIS_Y: return numXMoves(excludedLayer)+numZMoves(excludedLayer);

      case AXIS_Z: return numXMoves(excludedLayer)+numYMoves(excludedLayer);

      }

    return numXMoves(excludedLayer)+numYMoves(excludedLayer)+numZMoves(excludedLayer);

    }

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

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

    {

    int num = 0;

    if( excludedAxis!=0 )

      {

      for(int m=mStartX; m<mStartY; m++)

        if( mMoves[m]!=null && (m-mStartX)%mLayer[0]!=excludedLayer )

          {

          if( num==n ) return m;

          num++;

          }

      }

    if( excludedAxis!=1 )

      {

      for(int m=mStartY; m<mStartZ; m++)

        if( mMoves[m]!=null && (m-mStartY)%mLayer[1]!=excludedLayer )

          {

          if( num==n ) return m;

          num++;

          }

      }

    if( excludedAxis!=2 )

      {

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

        if( mMoves[m]!=null && (m-mStartZ)%mLayer[2]!=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<3; axis++)

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

        {

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

        }

    for(int axis=0; axis<3; 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<3; axis++)

      {

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

      if( moveIndex<size )

        {

        scramble[0] = axis;

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

        if( mTurns[axis]==3 )

          {

          switch(moveIndex/mSize[axis])

            {

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

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

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

            }

          }

        else scramble[2] = 1;

        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 + "]";

    }

}