Magic Cube

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

// 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.solvers;

import android.content.res.Resources;

import org.distorted.main.R;

import org.distorted.objectlib.main.ObjectSignatures;

import org.distorted.objectlib.main.TwistyObject;

import org.distorted.objectlib.tablebases.ImplementedTablebasesList;

import org.distorted.objectlib.tablebases.TablebaseHelpers;

import org.distorted.objectlib.tablebases.TablebasesAbstract;

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

public class SolverSkewb extends SolverTablebase

{

  private static final int ERROR_CORNER_135_MISSING = -1;

  private static final int ERROR_CORNER_134_MISSING = -2;

  private static final int ERROR_CORNER_125_MISSING = -3;

  private static final int ERROR_CORNER_124_MISSING = -4;

  private static final int ERROR_CORNER_035_MISSING = -5;

  private static final int ERROR_CORNER_034_MISSING = -6;

  private static final int ERROR_CORNER_025_MISSING = -7;

  private static final int ERROR_CORNER_024_MISSING = -8;

  private static final int ERROR_CENTER_0_MISSING   = -9;

  private static final int ERROR_CENTER_1_MISSING   = -10;

  private static final int ERROR_CENTER_2_MISSING   = -11;

  private static final int ERROR_CENTER_3_MISSING   = -12;

  private static final int ERROR_CENTER_4_MISSING   = -13;

  private static final int ERROR_CENTER_5_MISSING   = -14;

  private static final int ERROR_CORNERS_CANNOT     = -15;

  private static final int ERROR_CORNER_TWISTED     = -16;

  private static final int ERROR_TWO_CENTERS        = -17;

  private static final int ERROR_TWO_CORNERS        = -18;

  private TablebasesAbstract mSolver;

  private final int[] mFaceColors;

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

  public SolverSkewb(Resources res, TwistyObject object)

    {

    super(res,object);

    mFaceColors = new int[6];

    }

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

  private void getCorners(TwistyObject object, int[][] corners)

    {

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

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

        corners[i][j] = object.getCubitFaceStickerIndex(i,j);

    }

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

  private void getCenters(TwistyObject object, int[] centers)

    {

    int[] map = {12,13,10,11,8,9};

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

      centers[i] = object.getCubitFaceStickerIndex(map[i],0) - 6;

    }

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

  private int commonCornerColor(int[] c1, int[] c2)

    {

    int theSame = 0;

    int index   = 0;

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

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

        if( c1[i]==c2[j] )

          {

          index = i;

          theSame++;

          }

    return theSame==1 ? c1[index] : ERROR_CORNERS_CANNOT;

    }

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

  private int computeFaceColors(int[][] corners, int[] output)

    {

    final int[][] map = { {0,3},{5,6},{0,5},{6,3},{0,6},{3,5} };

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

      {

      int c1 = map[i][0];

      int c2 = map[i][1];

      output[i] = commonCornerColor(corners[c1],corners[c2]);

      if( output[i]<0 ) return ERROR_CORNERS_CANNOT;

      }

    return 0;

    }

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

  private boolean cornerIs(int[] corner, int c0, int c1, int c2)

    {

    return ( (corner[0]==c0 && corner[1]==c1 && corner[2]==c2 ) ||

             (corner[1]==c0 && corner[2]==c1 && corner[0]==c2 ) ||

             (corner[2]==c0 && corner[0]==c1 && corner[1]==c2 )  );

    }

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

  private int checkAllCornersPresent(int[][] corners)

    {

    boolean[] present = new boolean[8];

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

      {

      if( cornerIs(corners[i],4,2,0) ) present[0]=true;

      if( cornerIs(corners[i],2,5,0) ) present[1]=true;

      if( cornerIs(corners[i],3,4,0) ) present[2]=true;

      if( cornerIs(corners[i],5,3,0) ) present[3]=true;

      if( cornerIs(corners[i],1,2,4) ) present[4]=true;

      if( cornerIs(corners[i],5,2,1) ) present[5]=true;

      if( cornerIs(corners[i],4,3,1) ) present[6]=true;

      if( cornerIs(corners[i],1,3,5) ) present[7]=true;

      }

    if( !present[0] ) return ERROR_CORNER_024_MISSING;

    if( !present[1] ) return ERROR_CORNER_025_MISSING;

    if( !present[2] ) return ERROR_CORNER_034_MISSING;

    if( !present[3] ) return ERROR_CORNER_035_MISSING;

    if( !present[4] ) return ERROR_CORNER_124_MISSING;

    if( !present[5] ) return ERROR_CORNER_125_MISSING;

    if( !present[6] ) return ERROR_CORNER_134_MISSING;

    if( !present[7] ) return ERROR_CORNER_135_MISSING;

    return 0;

    }

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

  private int checkAllCentersPresent(int[] centers)

    {

    boolean[] present = new boolean[6];

    for(int i=0; i<6; i++) present[centers[i]]= true;

    if( !present[0] ) return ERROR_CENTER_4_MISSING;

    if( !present[1] ) return ERROR_CENTER_5_MISSING;

    if( !present[2] ) return ERROR_CENTER_2_MISSING;

    if( !present[3] ) return ERROR_CENTER_3_MISSING;

    if( !present[4] ) return ERROR_CENTER_0_MISSING;

    if( !present[5] ) return ERROR_CENTER_1_MISSING;

    return 0;

    }

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

// free corners: 1,2,4,7

  private int retFreeCornerPermutation(int[] perm, int[][] corners)

    {

    int[] map = {1,2,4,7};

    perm[0] = -1;

    perm[1] = -1;

    perm[2] = -1;

    perm[3] = -1;

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

      {

      int[] cor = corners[map[i]];

      if( cornerIs(cor,2,5,0) ) perm[0] = i;

      if( cornerIs(cor,3,4,0) ) perm[1] = i;

      if( cornerIs(cor,1,2,4) ) perm[2] = i;

      if( cornerIs(cor,1,3,5) ) perm[3] = i;

      }

    if( perm[0]==-1 ) return ERROR_CORNER_025_MISSING;

    if( perm[1]==-1 ) return ERROR_CORNER_034_MISSING;

    if( perm[2]==-1 ) return ERROR_CORNER_124_MISSING;

    if( perm[3]==-1 ) return ERROR_CORNER_135_MISSING;

    return 0;

    }

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

  // [1][] are the 3 quats the 1st 'fixed' corner will have when 'fakeTwisted' (which in case of

  // the fixed corners is the same as the final twist) with respectively twist 0,1,2.

  private final int[][] fixedQuats = { {0,1,2},{0,7,8},{0,6,5},{0,4,3} };

  // [1][2][] are the 3 quats the 1st free corner, when permuted to the location of the 2nd corner,

  // will have when it is 'fakeTwisted' with fakeTwist 0,1,2.

  // fakeTwist is an intermediate twist which needs yet to be translated to the final twist of the

  // corners (which needs to sum up to something divisible by 3).

  private final int[][][] freeQuats=

    {

        { {0,3,4},{9,8,1},{6,11,2},{7,10,5} },

        { {9,2,7},{0,5,6},{1,10,3},{4,11,8} },

        { {5,1,11},{2,4,10},{0,8,7},{9,3,6} },

        { {8,6,10},{3,7,11},{9,5,4},{0,2,1} }

    };

  private void fillInQuats(int[] output, int[] perm, int[] twist)

    {

    output[0] = fixedQuats[0][twist[0]];

    output[1] = freeQuats[0][perm[0]][twist[1]];

    output[2] = freeQuats[1][perm[1]][twist[2]];

    output[3] = fixedQuats[1][twist[3]];

    output[4] = freeQuats[2][perm[2]][twist[3]];

    output[5] = fixedQuats[2][twist[5]];

    output[6] = fixedQuats[3][twist[6]];

    output[7] = freeQuats[3][perm[3]][twist[7]];

    }

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

  private int computeLocation(int quat)

    {

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

      {

      int[] q = freeQuats[0][i];

      if( quat==q[0] || quat==q[1] || quat==q[2] ) return i;

      }

    android.util.Log.e("D", "error in computeLocation, quat="+quat);

    return -1;

    }

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

  private int retFixed(int index, int quat)

    {

    int[] qs = fixedQuats[index];

    if( quat==qs[0]) return 0;

    if( quat==qs[1]) return 1;

    if( quat==qs[2]) return 2;

    android.util.Log.e("D", "error in retFixed, index="+index+" quat="+quat);

    return -1;

    }

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

  private int retFree(int index, int quat)

    {

    int[][] qs = freeQuats[index];

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

      {

      if( quat==qs[i][0]) return 0;

      if( quat==qs[i][1]) return 1;

      if( quat==qs[i][2]) return 2;

      }

    android.util.Log.e("D", "error in retFree, index="+index+" quat="+quat);

    return -1;

    }

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

// In case of the four 'fixed' corners (0,3,5,6) which do not change their location,

// the twist is natural: 0 in the init positions and increasing 1 mod 3 on each CW turn.

//

// In case of the four 'free' corners their twist is relative to the position of the 'free'

// tetrahedron. And so, for example the twist of free corner 1 (whose 0th face is orange) is equal

// to 0 if free corner 7 is on the same face like 0th face of corner 1 (which is the case in init

// position); then once free corners 2,4,7 permute CW, twist of corner 1 increases by 1 mod 3.

  private void computeCornerTwists(int[] twists, int[] quats)

    {

    twists[0] = retFixed(0,quats[0]);

    twists[3] = retFixed(1,quats[3]);

    twists[5] = retFixed(2,quats[5]);

    twists[6] = retFixed(3,quats[6]);

    twists[1] = retFree(0,quats[1]);

    twists[2] = retFree(1,quats[2]);

    twists[4] = retFree(2,quats[4]);

    twists[7] = retFree(3,quats[7]);

    }

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

  private int retCornerPerm(int index, int[] perm)

    {

    int[] free = {1,2,4,7};

    switch(index)

      {

      case 0: return 0;

      case 1: return free[perm[0]];

      case 2: return free[perm[1]];

      case 3: return 3;

      case 4: return free[perm[2]];

      case 5: return 5;

      case 6: return 6;

      case 7: return free[perm[3]];

      }

    return -1;

    }

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

  private void computeCornerQuats(int[] quats, int[][] corners, int[] perm)

    {

    final int[] map = { 4,2,3,5,1,5,4,1 };

    int[] twists = new int[8];

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

      {

      int color = mFaceColors[map[i]];

      int[] c = corners[retCornerPerm(i,perm)];

           if( c[0]==color ) twists[i] = 0;

      else if( c[1]==color ) twists[i] = 1;

      else                   twists[i] = 2;

      }

    fillInQuats(quats,perm,twists);

    }

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

  public int tablebaseIndex(TwistyObject object)

    {

    int[][] corners= new int[8][3];

    int[] centers  = new int[6];

    int[] twist    = new int[8];

    int[] freePerm = new int[4];

    int[] quats    = new int[8];

    getCorners(object,corners);

    int result1 = computeFaceColors(corners,mFaceColors);

    if( result1<0 ) return result1;

    int result2 = checkAllCornersPresent(corners);

    if( result2<0 ) return result2;

    getCenters(object,centers);

    int result3 = checkAllCentersPresent(centers);

    if( result3<0 ) return result3;

/*

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

  for(int j=0; j<3; j++) android.util.Log.e("D", "corner "+i+" face "+j+" : "+corners[i][j]);

for(int i=0; i<6; i++) android.util.Log.e("D", "center "+i+" : "+centers[i]);

for(int i=0; i<6; i++) android.util.Log.e("D", "face "+i+" : "+mFaceColors[i]);

*/

    if( !TablebaseHelpers.permutationIsEven(centers) ) return ERROR_TWO_CENTERS;

    int center_perm_num = TablebaseHelpers.computeEvenPermutationNum(centers);

    int result4 = retFreeCornerPermutation(freePerm,corners);

    if( result4<0 ) return result4;

    computeCornerQuats(quats,corners,freePerm);

    computeCornerTwists(twist,quats);

/*

for(int i=0; i<4; i++) android.util.Log.e("D", "perm "+i+" : "+freePerm[i]);

for(int i=0; i<8; i++) android.util.Log.e("D", "quat "+i+" : "+quats[i]);

for(int i=0; i<8; i++) android.util.Log.e("D", "twist "+i+" : "+twist[i]);

*/

    int total = twist[1]+twist[2]+twist[4]+twist[7];

    if( (total%3)!=0 ) return ERROR_CORNER_TWISTED;

    int totalTwist = twist[0]+ 3*(twist[1]+ 3*(twist[2]+ 3*(twist[3]+ 3*(twist[4]+ 3*(twist[5]+ 3*twist[6])))));

    int locationOfFree0 = computeLocation(quats[1]);

    return center_perm_num+ 360*(totalTwist + 2187*locationOfFree0);

    }

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

  private int getColorIndex2(int face)

    {

    switch(mFaceColors[face])

      {

      case 0: return R.string.color_yellow2;

      case 1: return R.string.color_white2;

      case 2: return R.string.color_blue2;

      case 3: return R.string.color_green2;

      case 4: return R.string.color_red2;

      case 5: return R.string.color_orange2;

      }

    return -1;

    }

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

  private int getColorIndex3(int face)

    {

    switch(mFaceColors[face])

      {

      case 0: return R.string.color_yellow3;

      case 1: return R.string.color_white3;

      case 2: return R.string.color_blue3;

      case 3: return R.string.color_green3;

      case 4: return R.string.color_red3;

      case 5: return R.string.color_orange3;

      }

    return -1;

    }

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

  private int getColorIndex4(int face)

    {

    switch(mFaceColors[face])

      {

      case 0: return R.string.color_yellow4;

      case 1: return R.string.color_white4;

      case 2: return R.string.color_blue4;

      case 3: return R.string.color_green4;

      case 4: return R.string.color_red4;

      case 5: return R.string.color_orange4;

      }

    return -1;

    }

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

  private String cornerError(Resources res, int face0, int face1, int face2)

    {

    int j0 = getColorIndex3(face0);

    int j1 = getColorIndex3(face1);

    int j2 = getColorIndex4(face2);

    String c0 = res.getString(j0);

    String c1 = res.getString(j1);

    String c2 = res.getString(j2);

    return res.getString(R.string.solver_generic_missing_corner,c0,c1,c2);

    }

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

  private String centerError(Resources res, int face)

    {

    int color = getColorIndex2(face);

    String clr= res.getString(color);

    return res.getString(R.string.solver_generic_missing_center,clr);

    }

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

  public String error(int index, Resources res)

    {

    switch(index)

      {

      case ERROR_CORNER_135_MISSING: return cornerError(res,1,3,5);

      case ERROR_CORNER_134_MISSING: return cornerError(res,1,3,4);

      case ERROR_CORNER_125_MISSING: return cornerError(res,1,2,5);

      case ERROR_CORNER_124_MISSING: return cornerError(res,1,2,4);

      case ERROR_CORNER_035_MISSING: return cornerError(res,0,3,5);

      case ERROR_CORNER_034_MISSING: return cornerError(res,0,3,4);

      case ERROR_CORNER_025_MISSING: return cornerError(res,0,2,5);

      case ERROR_CORNER_024_MISSING: return cornerError(res,0,2,4);

      case ERROR_CENTER_0_MISSING  : return centerError(res,0);

      case ERROR_CENTER_1_MISSING  : return centerError(res,1);

      case ERROR_CENTER_2_MISSING  : return centerError(res,2);

      case ERROR_CENTER_3_MISSING  : return centerError(res,3);

      case ERROR_CENTER_4_MISSING  : return centerError(res,4);

      case ERROR_CENTER_5_MISSING  : return centerError(res,5);

      case ERROR_CORNERS_CANNOT    : return res.getString(R.string.solver_generic_corners_cannot);

      case ERROR_CORNER_TWISTED    : return res.getString(R.string.solver_generic_corner_twist);

      case ERROR_TWO_CENTERS       : return res.getString(R.string.solver_generic_two_centers);

      case ERROR_TWO_CORNERS       : return res.getString(R.string.solver_generic_two_corners);

      }

    return null;

    }

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

  public int[][] solution(int index, Resources res)

    {

    if( mSolver==null )

      {

      mSolver = ImplementedTablebasesList.createUnpacked(ObjectSignatures.SKEW_2);

      if( mSolver!=null )

        {

        mSolver.createTablebase(-1);

        mSolver.pack();

        }

      }

    return mSolver!=null ? mSolver.solution(index,null) : null;

    }

}