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.type.Static3D;

import org.distorted.objectlib.helpers.OperatingSystemInterface;

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

public class TBCuboid323 extends TablebasesPruning

{

  private static final int[][] CORNER_MAP = new int[][]

      {

          {0,4,7,1,2,3,5,6},

          {2,0,1,6,3,4,7,5},

          {7,1,0,4,5,6,2,3},

          {1,6,2,0,7,5,3,4},

          {4,3,5,7,0,2,6,1},

          {3,2,6,5,4,0,1,7},

          {5,7,4,3,6,1,0,2},

          {6,5,3,2,1,7,4,0}

      };

  private static final int[][] EDGE_MAP = new int[][]

      {

          {0,3,5,1,4,7,2,6},

          {3,0,1,5,2,6,4,7},

          {5,1,0,3,7,4,6,2},

          {1,5,3,0,6,2,7,4},

          {2,4,7,6,0,1,3,5},

          {7,6,2,4,1,0,5,3},

          {4,2,6,7,3,5,0,1},

          {6,7,4,2,5,3,1,0}

      };

  private static boolean mUpper;

  private static boolean mFixedEdgeIsDown;

  private int[][] mAngles;

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

  public static void setUpper(boolean upper, boolean isDown )

    {

    mUpper = upper;

    mFixedEdgeIsDown = isDown;

    }

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

// if upper==true, then the edge3 is the 'half-fixed' front edge. Remove it from the permutation.

// Otherwise edge1 is the one; remove it.

  public static int[] edgePermTo7(int[] perm, boolean upper)

    {

    int val;

    int[] ret = new int[7];

    if( upper )

      {

      ret[0] = perm[0];

      ret[1] = perm[1];

      ret[2] = perm[2];

      ret[3] = perm[4];

      ret[4] = perm[5];

      ret[5] = perm[6];

      ret[6] = perm[7];

      val = perm[3];

      }

    else

      {

      ret[0] = perm[0];

      ret[1] = perm[2];

      ret[2] = perm[3];

      ret[3] = perm[4];

      ret[4] = perm[5];

      ret[5] = perm[6];

      ret[6] = perm[7];

      val = perm[1];

      }

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

      if( ret[i]>val ) ret[i]--;

    return ret;

    }

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

  private static int[] edgePermTo8(int[] perm, boolean inPlace)

    {

    int[] ret = new int[8];

    if( mUpper )

      {

      int val = inPlace ? 3:1;

      ret[0] = perm[0]; if( ret[0]>=val ) ret[0]++;

      ret[1] = perm[1]; if( ret[1]>=val ) ret[1]++;

      ret[2] = perm[2]; if( ret[2]>=val ) ret[2]++;

      ret[3] = val;

      ret[4] = perm[3]; if( ret[4]>=val ) ret[4]++;

      ret[5] = perm[4]; if( ret[5]>=val ) ret[5]++;

      ret[6] = perm[5]; if( ret[6]>=val ) ret[6]++;

      ret[7] = perm[6]; if( ret[7]>=val ) ret[7]++;

      }

    else

      {

      int val = inPlace ? 1:3;

      ret[0] = perm[0]; if( ret[0]>=val ) ret[0]++;

      ret[1] = val;

      ret[2] = perm[1]; if( ret[2]>=val ) ret[2]++;

      ret[3] = perm[2]; if( ret[3]>=val ) ret[3]++;

      ret[4] = perm[3]; if( ret[4]>=val ) ret[4]++;

      ret[5] = perm[4]; if( ret[5]>=val ) ret[5]++;

      ret[6] = perm[5]; if( ret[6]>=val ) ret[6]++;

      ret[7] = perm[6]; if( ret[7]>=val ) ret[7]++;

      }

    return ret;

    }

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

  public TBCuboid323()

    {

    super();

    }

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

  public TBCuboid323(OperatingSystemInterface os)

    {

    super(os,null,null);

    }

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

  int[][] getBasicAngles()

    {

    if( mAngles==null )

      {

      int[] tmp2 = {2,2,2};

      int[] tmp4 = {4,4};

      return new int[][] { tmp2,tmp4,tmp2 };

      }

    return mAngles;

    }

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

  Static3D[] getRotationAxis()

    {

    return new Static3D[]

         {

           new Static3D(1,0,0),

           new Static3D(0,1,0),

           new Static3D(0,0,1)

         };

    }

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

  float[][] getPosition()

    {

    return new float[][]

      {

        { -1.0f, -0.5f, -1.0f },

        { -1.0f, -0.5f,  1.0f },

        { -1.0f,  0.5f, -1.0f },

        { -1.0f,  0.5f,  1.0f },

        {  1.0f, -0.5f, -1.0f },

        {  1.0f, -0.5f,  1.0f },

        {  1.0f,  0.5f, -1.0f },

        {  1.0f,  0.5f,  1.0f },

        {  0.0f, -0.5f, -1.0f },

        {  0.0f, -0.5f,  1.0f },

        {  0.0f,  0.5f, -1.0f },

        {  0.0f,  0.5f,  1.0f },

        { -1.0f, -0.5f,  0.0f },

        { -1.0f,  0.5f,  0.0f },

        {  1.0f, -0.5f,  0.0f },

        {  1.0f,  0.5f,  0.0f },

        {  0.0f,  0.5f,  0.0f },

        {  0.0f, -0.5f,  0.0f },

      };

    }

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

  float[][] getCuts()

    {

    return new float[][] { {-0.5f,0.5f}, {0.0f}, {-0.5f,0.5f} };

    }

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

  boolean[][] getRotatable()

    {

    return new boolean[][] { {true,false,true},{true,false},{true,false,true} };

    }

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

// specifically for the tablebase

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

// we can never really move the fixed front edge, because if we do so, we would also rotate the

// rotation axis themselves! (see getIndex() where the cubit quats are normalized)

// Fixed front edge is always iin the front, up or down (depending on value of mFixedEdgeIsDown)

// If the edge is up and we are moving along Y axis, invert!

  @Override

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

    {

    if( axis==2 && layer==2 ) mFixedEdgeIsDown = !mFixedEdgeIsDown;

    if( axis==1 && layer==1 && !mFixedEdgeIsDown ) return new int[] { axis, 1, -angle };

    int maxAngle = mAngles[axis][layer];

    angle = maxAngle-angle;

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

    return new int[] { axis, (1<<layer), angle };

    }

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

// 8!*8!/4 --> https://www.jaapsch.net/puzzles/domino.htm

  int getSize()

    {

    return 406425600;

    }

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

  int getMinScramble()

    {

    return 13;

    }

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

  int[] getMidPruningLevels()

    {

    return new int[] {6,7};

    }

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

  int[] getHighPruningLevels()

    {

    return new int[] {17,18};

    }

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

  int getGodsNumber()

    {

    return 18;

    }

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

  boolean moveCanProceed(int lastA, int lastR, int currA, int currR)

    {

    return (lastA!=currA) || (lastR!=currR);

    }

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

  private int findIndex(int[] table, int value)

    {

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

      if( table[i]==value ) return i;

    return -1;

    }

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

  private boolean isFrontEdgeInItsPlace(int[] perm)

    {

    int index = mUpper?3:1;

    return perm[index]==index;

    }

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

  private void correctQuats(int[] quats)

    {

    int mult=0, index = mUpper? 11:9;

    switch(quats[index])

      {

      case 0: case 5: return;

      case 4: case 7: mult=2; break;

      case 1: case 3: mult=3; break;

      case 2: case 6: mult=4; break;

      }

    for(int i=0; i<16; i++) quats[i] = getMultQuat(mult,quats[i]);

    }

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

  public int[] getQuats(int index)

    {

    int cornerPermNum = index%40320;

    index /= 40320;

    boolean inPlace = ((index%2)==0);

    int edgePermNum = index/2;

    int[] corner_perm = new int[8];

    TablebaseHelpers.getPermutationFromNum(corner_perm,8,cornerPermNum);

    int[] edge_perm7 = new int[7];

    TablebaseHelpers.getPermutationFromNum(edge_perm7,7,edgePermNum);

    int[] edge_perm8 = edgePermTo8(edge_perm7,inPlace);

    int[] quats = new int[18];

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

      {

      int q = CORNER_MAP[i][corner_perm[i]];

      quats[i] = q;

      }

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

      {

      int q = EDGE_MAP[i][edge_perm8[i]];

      quats[i+8] = q;

      }

    return quats;

    }

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

  public int getIndex(int[] quats)

    {

    int[] corner_perm = new int[8];

    int[] edge_perm8  = new int[8];

    correctQuats(quats);

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

      {

      corner_perm[i] = findIndex( CORNER_MAP[i], quats[i  ]);

      edge_perm8[i]  = findIndex( EDGE_MAP[i]  , quats[i+8]);

      }

    int[] edge_perm7 = edgePermTo7(edge_perm8,mUpper);

    int corner_perm_num = TablebaseHelpers.computePermutationNum(corner_perm);

    int edge_perm_num = TablebaseHelpers.computePermutationNum(edge_perm7);

    boolean inPlace = isFrontEdgeInItsPlace(edge_perm8);

    return corner_perm_num + 40320*( (inPlace?0:1) + 2*edge_perm_num);

    }

}