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.signature;

import static org.distorted.objectlib.scrambling.ScrambleStateLocallyBandaged.MAX_SUPPORTED_SIZE;

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

public class ObjectSignature implements Comparable<ObjectSignature>

{

  public static final int SIZE = computeNum();

  private String mName=null;

  int[] mFactoryLayer;

  int mParam;

  long[] mSignature;

  int[] mLayer;

  float[][] mCubitTouch;

  int[][] mTouchRows;

  int mNumCubitTouches;

  int[][][][] mCycles;

  int[] mNumLeftCyclesPerLayer;

  int[] mNumCentCyclesPerLayer;

  int[] mNumInneCyclesPerLayer;

  float[] mTmp;

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

// a cube of size N has 12*(N-1)^2 possible places two adjacent cubies can be 'glued'; therefore

// the signature must contain ceil( 12*(N-1)^2 / 64 ) bytes.

// a Pyraminx of size N has 4 + 6*(N-1)(N-2) places two adjacent cubies can be 'glued' so much less.

// Gigaminx has 540 such places (so more if N<=7)

  private static int computeNum()

    {

    int max = MAX_SUPPORTED_SIZE-1;

    int ret = (int)(0.99f + (12*max*max)/64.0f);

    int giga= (int)(0.99f + (       540)/64.0f);

    return Math.max(ret,giga);

    }

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

  void setUpSignature(long[] signature)

    {

    int size = signature.length;

    int diff = SIZE-size;

    if( diff==0 ) mSignature = signature;

    else

      {

      mSignature = new long[SIZE];

      for(int i=0; i<size; i++) mSignature[diff+i] = signature[i];

      }

    }

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

  public ObjectSignature(ObjectSignature sig)

    {

    int len = sig.mSignature.length;

    mSignature = new long[len];

    for(int i=0; i<len; i++) mSignature[i] = sig.mSignature[i];

    mLayer        = sig.mLayer;

    mCycles       = sig.mCycles;

    mCubitTouch   = sig.mCubitTouch;

    mTouchRows    = sig.mTouchRows;

    mName         = sig.mName;

    mParam        = sig.mParam;

    mFactoryLayer = sig.mFactoryLayer;

    mTmp          = sig.mTmp;

    mNumCubitTouches       = sig.mNumCubitTouches;

    mNumCentCyclesPerLayer = sig.mNumCentCyclesPerLayer;

    mNumLeftCyclesPerLayer = sig.mNumLeftCyclesPerLayer;

    mNumInneCyclesPerLayer = sig.mNumInneCyclesPerLayer;

    }

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

// built-in objects; objects created from JSON (version1)

  public ObjectSignature(long signature)

    {

    mSignature = new long[SIZE];

    mSignature[SIZE-1] = signature;

    }

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

  ObjectSignature()

    {

    }

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

// other objects created from JSON (version2)

  public ObjectSignature(long[] signature)

    {

    setUpSignature(signature);

    }

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

  public void setSignature(int signature)

    {

    for(int i=0; i<SIZE-1; i++) mSignature[i]=0;

    mSignature[SIZE-1] = signature;

    }

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

  public int compareTo(ObjectSignature sig)

    {

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

      {

      long diff = mSignature[i] - sig.mSignature[i];

           if( diff>0 ) return +1;

      else if( diff<0 ) return -1;

      }

    return 0;

    }

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

  public boolean isEqual(ObjectSignature sig)

    {

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

      {

      if( mSignature[i] != sig.mSignature[i] ) return false;

      }

    return true;

    }

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

  public long[] getArray()

    {

    return mSignature;

    }

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

  public String getString()

    {

    if( mName==null )

      {

      StringBuilder sb = new StringBuilder();

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

        {

        String sig = String.format("0x%016X", mSignature[i]);

        if( i>0 ) sb.append('_');

        sb.append(sig);

        }

      mName = sb.toString();

      }

    return mName;

    }

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

  public boolean isUnblockedFromLeft(int axis, int layer)

    {

    if(layer>0)

      {

      int[] touch = mTouchRows[axis];

      for( int index=0; index<mNumCubitTouches; index++)

        if( touch[index]==layer && getBit(index)!=0 ) return false;

      }

    return true;

    }

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

  public ObjectSignature turn(int ax, int layer, int turn)

    {

    ObjectSignature ret = new ObjectSignature(this);

    // I don't understand it, but Firebase shows mCycles is occasionally null here.

    if( mCycles!=null && mCycles[ax]!=null )

      {

      int[][] cycles = mCycles[ax][layer];

      // it can happen that there are no cycles in this layer: 2x1x2 axis 0 layer 0.

      if( cycles!=null && cycles.length>0 && cycles[0]!=null )

        {

             if( cycles[0].length==5 ) for(int[] cyc : cycles) ret.cycle5(turn,cyc);

        else if( cycles[0].length==4 ) for(int[] cyc : cycles) ret.cycle4(turn,cyc);

        else if( cycles[0].length==3 ) for(int[] cyc : cycles) ret.cycle3(turn,cyc);

        else if( cycles[0].length==2 ) for(int[] cyc : cycles) ret.cycle2(cyc);

        }

      }

    return ret;

    }

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

  private void cycle2(int[] cyc)

    {

    int index0 = cyc[0];

    int index1 = cyc[1];

    long b0 = getBit(index0);

    long b1 = getBit(index1);

    setBit(index1,b0);

    setBit(index0,b1);

    }

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

  private void cycle3(int turn, int[] cyc)

    {

    int index0 = cyc[0];

    int index1 = cyc[1];

    int index2 = cyc[2];

    long b0 = getBit(index0);

    long b1 = getBit(index1);

    long b2 = getBit(index2);

    switch(turn)

      {

      case 1: setBit(index0,b2);

              setBit(index1,b0);

              setBit(index2,b1);

              break;

      case 2: setBit(index0,b1);

              setBit(index1,b2);

              setBit(index2,b0);

              break;

      }

    }

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

  private void cycle4(int turn, int[] cyc)

    {

    int index0 = cyc[0];

    int index1 = cyc[1];

    int index2 = cyc[2];

    int index3 = cyc[3];

    long b0 = getBit(index0);

    long b1 = getBit(index1);

    long b2 = getBit(index2);

    long b3 = getBit(index3);

    switch(turn)

      {

      case 1: setBit(index0,b3);

              setBit(index1,b0);

              setBit(index2,b1);

              setBit(index3,b2);

              break;

      case 2: setBit(index0,b2);

              setBit(index1,b3);

              setBit(index2,b0);

              setBit(index3,b1);

              break;

      case 3: setBit(index0,b1);

              setBit(index1,b2);

              setBit(index2,b3);

              setBit(index3,b0);

              break;

      }

    }

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

  private void cycle5(int turn, int[] cyc)

    {

    int index0 = cyc[0];

    int index1 = cyc[1];

    int index2 = cyc[2];

    int index3 = cyc[3];

    int index4 = cyc[4];

    long b0 = getBit(index0);

    long b1 = getBit(index1);

    long b2 = getBit(index2);

    long b3 = getBit(index3);

    long b4 = getBit(index4);

    switch(turn)

      {

      case 1: setBit(index0,b4);

              setBit(index1,b0);

              setBit(index2,b1);

              setBit(index3,b2);

              setBit(index4,b3);

              break;

      case 2: setBit(index0,b3);

              setBit(index1,b4);

              setBit(index2,b0);

              setBit(index3,b1);

              setBit(index4,b2);

              break;

      case 3: setBit(index0,b2);

              setBit(index1,b3);

              setBit(index2,b4);

              setBit(index3,b0);

              setBit(index4,b1);

              break;

      case 4: setBit(index0,b1);

              setBit(index1,b2);

              setBit(index2,b3);

              setBit(index3,b4);

              setBit(index4,b0);

              break;

    }

  }

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

  float[] getPosition(int index, float[][][] centers, int len)

    {

    int num=0, i1=0, i2=0;

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

      {

      int t = centers[i].length;

      if( t > index-num )

        {

        i1 = i;

        i2 = index-num;

        break;

        }

      else

        {

        num += t;

        }

      }

    return centers[i1][i2];

    }

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

  int getIndexOfCubitTouch(float x, float y, float z)

    {

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

      {

      float[] touch = mCubitTouch[i];

      float dx = touch[0] - x;

      float dy = touch[1] - y;

      float dz = touch[2] - z;

      if( dx*dx + dy*dy + dz*dz < 0.01f ) return i;

      }

    return -1;

    }

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

  float[] getCubitTouchOfIndex(int index)

    {

    return mCubitTouch[index];

    }

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

  long getBit(int index)

    {

    int sigIndex = SIZE-1-(index/64);

    return (mSignature[sigIndex]>>(index%64))&0x1;

    }

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

  void setBit(int index, long bit)

    {

    long diff    = (1L<<(index%64));

    int sigIndex = SIZE-1-(index/64);

    if( bit!=0 ) mSignature[sigIndex] |= diff;

    else         mSignature[sigIndex] &=~diff;

    }

}