TwistyPuzzleLib

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

// Copyright 2023 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.tablebases;

import org.distorted.library.helpers.QuatHelper;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.helpers.OperatingSystemInterface;

import org.distorted.objectlib.helpers.QuatGroupGenerator;

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.util.ArrayList;

import java.util.Random;

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

public abstract class TablebasesAbstract

{

  private final Static3D[] mAxis;

  private final int mSize, mMinScramble;

  private final int[][] mAngles;

  private final int[] mNumLayers;

  private final int mNumQuats;

  private final float[][] mCuts;

  private final int[] mNumCuts;

  private final int[][][] mCubitQuatRows;

  private final float[][] mQuats;

  private final float[][] mPosition;

  private int[][] mQuatMult;

  private int[] mInvertedQuat;

  private ArrayList<int[]> mMoves;

  Tablebase mTablebase;

  boolean mInitialized;

  int mLastSolvingIndex;

  final int mScalingFactor;

  final int mNumAxis;

  final int[][] mRotRow;

  final int mNumCubits;

  final boolean[][] mRotatable;

  private static final float[] mTmp = new float[4];

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

  abstract int[][] getBasicAngles();

  abstract Static3D[] getRotationAxis();

  abstract float[][] getPosition();

  abstract float[][] getCuts();

  abstract boolean[][] getRotatable();

  abstract int getMinScramble();

  abstract int getSize();

  abstract int[] getQuats(int index);

  abstract int getIndex(int[] quats);

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

  public TablebasesAbstract()

    {

    mSize = getSize();

    mMinScramble = getMinScramble();

    mAngles = getBasicAngles();

    mAxis = getRotationAxis();

    mNumAxis = mAxis.length;

    mNumLayers = new int[mNumAxis];

    for(int i=0; i<mNumAxis; i++) mNumLayers[i] = mAngles[i].length;

    Static4D[] quats = QuatGroupGenerator.computeGroup(mAxis,mAngles);

    mNumQuats = quats.length;

    mQuats = new float[mNumQuats][];

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

      {

      Static4D q = quats[i];

      mQuats[i] = new float[] {q.get0(),q.get1(),q.get2(),q.get3()};

      }

    mPosition = getPosition();

    mNumCubits = mPosition.length;

    mRotatable = getRotatable();

    mCuts = getCuts();

    mNumCuts = new int[mNumAxis];

    int scaling = 0;

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

      {

      mNumCuts[i] = (mCuts==null || mCuts[i]==null ? 0 : mCuts[i].length);

      int numLayers = mNumLayers[i];

      for(int j=0; j<numLayers; j++) scaling+=(mAngles[i][j]-1);

      }

    mScalingFactor = scaling;

    mRotRow = new int[mNumCubits][mNumAxis];

    mCubitQuatRows = new int[mNumCubits][mNumQuats][];

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

      for(int j=0; j<mNumQuats; j++) mCubitQuatRows[i][j] = computeMap(i,j);

    mInitialized = false;

    }

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

  public TablebasesAbstract(OperatingSystemInterface os, int resource)

    {

    this();

    mInitialized = true;

    InputStream stream = os.openLocalFile(resource);

    ByteArrayOutputStream buffer = new ByteArrayOutputStream();

    int nRead;

    byte[] tmp = new byte[16384];

    try

      {

      while ((nRead = stream.read(tmp, 0, tmp.length)) != -1)

        {

        buffer.write(tmp, 0, nRead);

        }

      stream.close();

      byte[] data = buffer.toByteArray();

      buffer.close();

      mTablebase = new Tablebase(data);

      }

    catch(IOException ex)

      {

      mInitialized = false;

      }

    }

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

  private int[] computeMap(int cubit, int quat)

    {

    float[] pos = mPosition[cubit];

    float[] q = mQuats[quat];

    QuatHelper.rotateVectorByQuat(mTmp,pos[0],pos[1],pos[2],1.0f,q);

    int[] output = new int[mNumAxis];

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

      {

      Static3D ax = mAxis[i];

      float axisX = ax.get0();

      float axisY = ax.get1();

      float axisZ = ax.get2();

      float casted = mTmp[0]*axisX + mTmp[1]*axisY + mTmp[2]*axisZ;

      output[i] = computeSingleRow(i,casted);

      }

    return output;

    }

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

  private int computeSingleRow(int axisIndex,float casted)

    {

    int num = mNumCuts[axisIndex];

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

      {

      if( casted<mCuts[axisIndex][i] ) return (1<<i);

      }

    return (1<<num);

    }

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

  int computeBitLayer(int ax, int layer)

    {

    return (1<<layer);

    }

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

  int[] computeRow(int cubit, int quat)

    {

    return mCubitQuatRows[cubit][quat];

    }

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

// remember about the double cover or unit quaternions!

  public static int mulQuat(int q1, int q2, float[][] quats)

    {

    int numQuats = quats.length;

    float[] result = QuatHelper.quatMultiply(quats[q1],quats[q2]);

    float rX = result[0];

    float rY = result[1];

    float rZ = result[2];

    float rW = result[3];

    final float MAX_ERROR = 0.1f;

    float dX,dY,dZ,dW;

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

      {

      float[] q = quats[i];

      dX = q[0] - rX;

      dY = q[1] - rY;

      dZ = q[2] - rZ;

      dW = q[3] - rW;

      if( dX<MAX_ERROR && dX>-MAX_ERROR &&

          dY<MAX_ERROR && dY>-MAX_ERROR &&

          dZ<MAX_ERROR && dZ>-MAX_ERROR &&

          dW<MAX_ERROR && dW>-MAX_ERROR  ) return i;

      dX = q[0] + rX;

      dY = q[1] + rY;

      dZ = q[2] + rZ;

      dW = q[3] + rW;

      if( dX<MAX_ERROR && dX>-MAX_ERROR &&

          dY<MAX_ERROR && dY>-MAX_ERROR &&

          dZ<MAX_ERROR && dZ>-MAX_ERROR &&

          dW<MAX_ERROR && dW>-MAX_ERROR  ) return i;

      }

    return -1;

    }

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

  int getMultQuat(int index1, int index2)

    {

    if( mQuatMult==null )

      {

      mQuatMult = new int[mNumQuats][mNumQuats];

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

        for(int j=0; j<mNumQuats; j++) mQuatMult[i][j] = -1;

      }

    if( index1<mNumQuats && index2<mNumQuats )

      {

      if( mQuatMult[index1][index2]==-1 ) mQuatMult[index1][index2] = mulQuat(index1,index2, mQuats);

      return mQuatMult[index1][index2];

      }

    return -2;

    }

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

  int getInvertedQuat(int index)

    {

    if( mInvertedQuat==null )

      {

      mInvertedQuat = new int[mNumQuats];

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

        for(int j=0; j<mNumQuats; j++)

          {

          int result = getMultQuat(i,j);

          if( result==0 )

            {

            mInvertedQuat[i] = j;

            break;

            }

          }

      }

    return mInvertedQuat[index];

    }

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

// assumption: all layers have the same basicAngles!

  private int insertAllChildren(int index, byte level)

    {

    int ret = 0;

    int[] quats = getQuats(index);

    int numQuats = quats.length;

    int[] tmpQuats = new int[numQuats];

    byte newLevel = (byte)(level+1);

    int quatBasis = 0;

    for(int cubit=0; cubit<mNumCubits; cubit++) mRotRow[cubit] = computeRow(cubit,quats[cubit]);

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

      {

      for(int layer=0; layer<mNumLayers[ax]; layer++)

        {

        if( !mRotatable[ax][layer] ) continue;

        int bitLayer = computeBitLayer(ax,layer);

        int maxAngle = mAngles[ax][layer];

        for(int angle=1; angle<maxAngle; angle++ )

          {

          System.arraycopy(quats, 0, tmpQuats, 0, numQuats);

          int quat = quatBasis + angle;

          for(int cubit=0; cubit<mNumCubits; cubit++)

            if( (mRotRow[cubit][ax] & bitLayer) != 0 )

              tmpQuats[cubit] = getMultQuat(quat,tmpQuats[cubit]);

          int childIndex = getIndex(tmpQuats);

          if( mTablebase.insertUnpacked(childIndex,newLevel) ) ret++;

          }

        }

      quatBasis += (mAngles[ax][0]-1);

      }

    return ret;

    }

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

  public boolean useForScrambling()

    {

    return true;

    }

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

  public void createTablebase(int maxLevel)

    {

    mTablebase = new Tablebase(mSize);

    int[] solved = getSolvedIndices();

    int numSolved = solved.length;

    for(int s : solved ) mTablebase.insertUnpacked(s,(byte)0);

    int numInserted, totalInserted=numSolved;

    byte insertingLevel = 0;

    android.util.Log.e("D", "creating tablebase of size "+mSize);

    do

      {

      numInserted = 0;

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

        {

        byte level = mTablebase.retrieveUnpacked(i);

        if( level==insertingLevel ) numInserted += insertAllChildren(i,level);

        }

      insertingLevel++;

      totalInserted += numInserted;

      android.util.Log.e("D", "inserted "+numInserted+" positions at level "+insertingLevel);

      }

    while( numInserted>0 && insertingLevel!=maxLevel );

    android.util.Log.e("D", "total Inserted: "+totalInserted);

    }

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

  int[] getSolvedIndices()

    {

    return new int[] {0};

    }

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

  boolean isSolved(int index)

    {

    return index==0;

    }

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

  public void pack()

    {

    android.util.Log.e("D", "packing...");

    mTablebase.pack();

    android.util.Log.e("D", "all done");

    mInitialized = true;

    }

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

  public byte[][] getPacked()

    {

    if( !mInitialized )

      {

      createTablebase(-1);

      pack();

      }

    byte[] data = mTablebase.getPacked();

    return new byte[][] { data };

    }

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

  void convertMoves(int[][] moves)

    {

    for(int[] move : moves )

      {

      int[] m = newMove(move[0],move[1],move[2]);

      move[0] = m[0];

      move[1] = m[1];

      move[2] = m[2];

      }

    }

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

  int[] newMove(int ax, int layer, int angle)

    {

    int maxAngle = mAngles[ax][layer];

    angle = maxAngle-angle;

    if( angle> 0.5f*maxAngle ) angle -= maxAngle;

    return new int[] { ax, computeBitLayer(ax,layer), angle };

    }

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

  int[][] convertMovesFromArray(ArrayList<int[]> moves)

    {

    int len = moves.size();

    int[][] ret = new int[len][];

    for(int i=0; i<len; i++) ret[i] = moves.get(i);

    return ret;

    }

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

  void getNextAxisLayerAngleQuat(int[] data)

    {

    int axis = data[0];

    int layer= data[1];

    int angle= data[2];

    if( angle< mAngles[axis][layer]-1 ) data[2]++;

    else

      {

      data[2] = 1;

      if( layer< mNumLayers[axis]-1 ) data[1]++;

      else

        {

        data[1] = 0;

        data[0] = (axis<mNumAxis-1) ? axis+1 : 0;

        }

      }

    data[3] = data[2];

    for(int i=0; i<data[0]; i++) data[3] += (mAngles[i][0]-1);

    }

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

  int[][] extraInfo(int[][] moves, int[] extra)

    {

    return moves;

    }

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

  public int[][] solution(int index, int[] extra, OperatingSystemInterface osi)

    {

    if( !mInitialized ) return null;

    if( mMoves==null ) mMoves = new ArrayList<>();

    else               mMoves.clear();

    int[] data = new int[4];

    byte level = mTablebase.retrievePacked(index);

    int[] quats = getQuats(index);

    int numQuats = quats.length;

    int[] tmpQuats = new int[numQuats];

    mLastSolvingIndex = index;

    while( !isSolved(index) )

      {

      boolean found = false;

      data[0]=0;

      data[1]=0;

      data[2]=1;

      data[3]=1;

      for(int cubit=0; cubit<mNumCubits; cubit++) mRotRow[cubit] = computeRow(cubit,quats[cubit]);

      for(int s=0; s<mScalingFactor && !found; s++)

        {

        int ax    = data[0];

        int layer = data[1];

        int angle = data[2];

        int quat  = data[3];

        if( mRotatable[ax][layer] )

          {

          int bitLayer = computeBitLayer(ax,layer);

          System.arraycopy(quats, 0, tmpQuats, 0, numQuats);

          for(int cubit=0; cubit<mNumCubits; cubit++)

            if( (mRotRow[cubit][ax] & bitLayer) != 0 )

              {

              int currQuat = tmpQuats[cubit];

              int newQuat = getMultQuat(quat,currQuat);

              tmpQuats[cubit] = newQuat;

              }

          int childIndex = getIndex(tmpQuats);

          byte newLevel = mTablebase.retrievePacked(childIndex);

          if( ((newLevel-level+1)%3) == 0 )

            {

            int[] tmpMove = newMove(ax,layer,angle);

            mMoves.add(tmpMove);

            index = childIndex;

            level = (level==0 ? 2 : (byte)(level-1));

            found = true;

            }

          }

        getNextAxisLayerAngleQuat(data);

        }

      quats = getQuats(index);

      if( !found )

        {

        if( osi!=null ) osi.reportError("solution error: no move found!"+index);

        return null;

        }

      }

    int[][] ret = convertMovesFromArray(mMoves);

    return extraInfo(ret,extra);

    }

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

  void postScramble(int[][] scramble, int num)

    {

    }

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

  public void scramble(Random rnd, int depth, int[][] scramble)

    {

    if( !mInitialized ) return;

    int solDepth = 0;

    int scraLen = scramble.length;

    if( depth>mMinScramble ) depth = mMinScramble;

    int num=0;

    int[] cornerTwist = new int[4];

    for(int i=0; i<4; i++) cornerTwist[i] = (rnd.nextInt(3)-1);

    while( solDepth<depth )

      {

      int randomPosition = rnd.nextInt(mSize-1);

      int[][] sol = solution(randomPosition,cornerTwist,null);

      solDepth = (sol!=null ? sol.length : 0);

      if( solDepth>=depth )

        {

        num = Math.min(scraLen,solDepth);

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

          {

          int[] source = sol[solDepth-1-i];

          scramble[i][0] = source[0];

          scramble[i][1] = source[1];

          scramble[i][2] =-source[2];

          }

        }

      }

    postScramble(scramble,num);

    }

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

// TESTING

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

  public boolean test(int index)

    {

    if( !mInitialized ) return false;

    int[] data = new int[4];

    byte level = mTablebase.retrievePacked(index);

    int[] quats = getQuats(index);

    int numQuats = quats.length;

    int[] tmpQuats = new int[numQuats];

    data[0]=0;

    data[1]=0;

    data[2]=1;

    data[3]=1;

    for(int cubit=0; cubit<mNumCubits; cubit++) mRotRow[cubit] = computeRow(cubit,quats[cubit]);

    for(int s=0; s<mScalingFactor; s++)

      {

      int ax    = data[0];

      int layer = data[1];

      int quat  = data[3];

      if( mRotatable[ax][layer] )

        {

        int bitLayer = computeBitLayer(ax,layer);

        System.arraycopy(quats, 0, tmpQuats, 0, numQuats);

        for(int cubit=0; cubit<mNumCubits; cubit++)

          if( (mRotRow[cubit][ax] & bitLayer) != 0 )

            {

            int currQuat = tmpQuats[cubit];

            int newQuat = getMultQuat(quat,currQuat);

            tmpQuats[cubit] = newQuat;

            }

        int childIndex = getIndex(tmpQuats);

        byte newLevel = mTablebase.retrievePacked(childIndex);

        if( ((newLevel-level+1)%3) == 0 ) return true;

        }

      getNextAxisLayerAngleQuat(data);

      }

    return false;

    }

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

  public void test(OperatingSystemInterface os)

    {

    /*

    int index = 252373232;

    int[] q = getQuats(index);

    TablebaseHelpers.displayTable(q , "QUATS ");

    */

    int[] extra = new int[4];

    for(int i=10113000; i<19958400; i++)

      {

      int[][] sol = solution(i,extra,os);

      if( (i%1000)==0 ) android.util.Log.e("D ", "solving: "+i);

      }

    }

}