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.objectlib.main.ObjectType;

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 SolverSkewbDiamond extends SolverTablebase

{

  private static final int ERROR_CORNER_FR_MISSING = -1;

  private static final int ERROR_CORNER_BR_MISSING = -2;

  private static final int ERROR_CORNER_BL_MISSING = -3;

  private static final int ERROR_CORNER_FL_MISSING = -4;

  private static final int ERROR_CORNER_TO_MISSING = -5;

  private static final int ERROR_CORNER_BO_MISSING = -6;

  private static final int ERROR_CENTER_0_MISSING = -7;

  private static final int ERROR_CENTER_1_MISSING = -8;

  private static final int ERROR_CENTER_2_MISSING = -9;

  private static final int ERROR_CENTER_3_MISSING = -10;

  private static final int ERROR_CENTER_4_MISSING = -11;

  private static final int ERROR_CENTER_5_MISSING = -12;

  private static final int ERROR_CENTER_6_MISSING = -13;

  private static final int ERROR_CENTER_7_MISSING = -14;

  private static final int ERROR_TWO_CORNERS      = -15;

  private static final int ERROR_TWO_CENTERS      = -16;

  private static final int ERROR_CORNER_TWIST     = -17;

  private static final int ERROR_CORNERS_CANNOT   = -18;

  private TablebasesAbstract mSolver;

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

  public SolverSkewbDiamond(Resources res, TwistyObject object)

    {

    super(res,object);

    }

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

  private int[] getCornersPermutation(int[] colors, int[][] corners)

    {

    }

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

  private int[] getCornersTwist(int[] colors, int[][] corners)

    {

    }

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

  private int[] getFreeCentersPermutation(int[] colors, int[] centers)

    {

    }

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

  private int getTotalTwist(int[] twist)

    {

    int total = 0;

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

      {

      int t= twist[i];

      if( t==1 || t==3 ) return -1;

      if( t==2 ) total++;

      total *= 2;

      }

    return total;

    }

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

  private int figureOutColor(int[][] corners, int c1, int c2)

    {

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

      {

      int[] cor = corners[i];

      if( cor[0]==c1 && cor[2]==c2 ) return cor[1];

      if( cor[1]==c1 && cor[3]==c2 ) return cor[2];

      if( cor[2]==c1 && cor[0]==c2 ) return cor[3];

      if( cor[3]==c1 && cor[1]==c2 ) return cor[0];

      }

    return -1;

    }

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

// We only move the UR, UR, DR & DB faces --> those centers are fixed and determine the colors of

// the faces.

  private int figureOutFaceColors(int[] output, int[] centers, int[][] corners)

    {

    output[1] = centers[1];

    output[3] = centers[3];

    output[4] = centers[4];

    output[6] = centers[6];

    int color01 = figureOutColor(corners,output[4],output[1]);

    if( color01<0 ) return ERROR_CORNER_FR_MISSING;

    int color02 = figureOutColor(corners,output[3],output[4]);

    if( color02<0 ) return ERROR_CORNER_FL_MISSING;

    int color03 = figureOutColor(corners,output[1],output[3]);

    if( color03<0 ) return ERROR_CORNER_TO_MISSING;

    if( color01!=color02 || color01!=color03 ) return ERROR_CORNERS_CANNOT;

    output[0] = color01;

    int color21 = figureOutColor(corners,output[1],output[6]);

    if( color21<0 ) return ERROR_CORNER_BR_MISSING;

    int color22 = figureOutColor(corners,output[6],output[3]);

    if( color22<0 ) return ERROR_CORNER_BL_MISSING;

    int color23 = figureOutColor(corners,output[3],output[1]);

    if( color23<0 ) return ERROR_CORNER_TO_MISSING;

    if( color21!=color22 || color21!=color23 ) return ERROR_CORNERS_CANNOT;

    output[2] = color21;

    int color51 = figureOutColor(corners,output[1],output[4]);

    if( color51<0 ) return ERROR_CORNER_FR_MISSING;

    int color52 = figureOutColor(corners,output[6],output[1]);

    if( color52<0 ) return ERROR_CORNER_BR_MISSING;

    int color53 = figureOutColor(corners,output[4],output[6]);

    if( color53<0 ) return ERROR_CORNER_BO_MISSING;

    if( color51!=color52 || color51!=color53 ) return ERROR_CORNERS_CANNOT;

    output[5] = color51;

    int color71 = figureOutColor(corners,output[3],output[6]);

    if( color71<0 ) return ERROR_CORNER_BL_MISSING;

    int color72 = figureOutColor(corners,output[4],output[3]);

    if( color72<0 ) return ERROR_CORNER_FL_MISSING;

    int color73 = figureOutColor(corners,output[6],output[4]);

    if( color73<0 ) return ERROR_CORNER_BO_MISSING;

    if( color71!=color72 || color71!=color73 ) return ERROR_CORNERS_CANNOT;

    output[7] = color71;

    return 0;

    }

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

  private int checkAllColorsDifferent(int[] colors)

    {

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

      {

      boolean present = false;

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

        if( colors[j]==i )

          {

          present=true;

          break;

          }

      if( !present ) return ERROR_CORNERS_CANNOT;

      }

    return 0;

    }

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

  private int checkAllCentersPresent(int[] centers)

    {

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

      {

      boolean present = false;

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

        if( centers[j]==i )

          {

          present=true;

          break;

          }

      if( !present )

        {

        switch(i)

          {

          case 0: return ERROR_CENTER_0_MISSING;

          case 1: return ERROR_CENTER_1_MISSING;

          case 2: return ERROR_CENTER_2_MISSING;

          case 3: return ERROR_CENTER_3_MISSING;

          case 4: return ERROR_CENTER_4_MISSING;

          case 5: return ERROR_CENTER_5_MISSING;

          case 6: return ERROR_CENTER_6_MISSING;

          case 7: return ERROR_CENTER_7_MISSING;

          }

        }

      }

    return 0;

    }

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

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

    {

    corners[0][0] = object.getCubitFaceStickerIndex( 0,0); // FR

    corners[0][1] = object.getCubitFaceStickerIndex( 0,1);

    corners[0][2] = object.getCubitFaceStickerIndex( 0,5);

    corners[0][3] = object.getCubitFaceStickerIndex( 0,4);

    corners[1][0] = object.getCubitFaceStickerIndex( 1,1); // BR

    corners[1][1] = object.getCubitFaceStickerIndex( 1,2);

    corners[1][2] = object.getCubitFaceStickerIndex( 1,6);

    corners[1][3] = object.getCubitFaceStickerIndex( 1,5);

    corners[2][0] = object.getCubitFaceStickerIndex( 2,2); // BL

    corners[2][1] = object.getCubitFaceStickerIndex( 2,3);

    corners[2][2] = object.getCubitFaceStickerIndex( 2,7);

    corners[2][3] = object.getCubitFaceStickerIndex( 2,6);

    corners[3][0] = object.getCubitFaceStickerIndex( 3,3); // FL

    corners[3][1] = object.getCubitFaceStickerIndex( 3,0);

    corners[3][2] = object.getCubitFaceStickerIndex( 3,4);

    corners[3][3] = object.getCubitFaceStickerIndex( 3,7);

    corners[4][0] = object.getCubitFaceStickerIndex( 4,0); // U

    corners[4][1] = object.getCubitFaceStickerIndex( 4,3);

    corners[4][2] = object.getCubitFaceStickerIndex( 4,2);

    corners[4][3] = object.getCubitFaceStickerIndex( 4,1);

    corners[5][0] = object.getCubitFaceStickerIndex( 5,6); // D

    corners[5][1] = object.getCubitFaceStickerIndex( 5,7);

    corners[5][2] = object.getCubitFaceStickerIndex( 5,4);

    corners[5][3] = object.getCubitFaceStickerIndex( 5,5);

    }

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

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

    {

    centers[0] = object.getCubitFaceStickerIndex( 9,0); // UF

    centers[1] = object.getCubitFaceStickerIndex( 6,0); // UR

    centers[2] = object.getCubitFaceStickerIndex( 7,0); // UB

    centers[3] = object.getCubitFaceStickerIndex( 8,0); // UL

    centers[4] = object.getCubitFaceStickerIndex(13,0); // DF

    centers[5] = object.getCubitFaceStickerIndex(10,1); // DR

    centers[6] = object.getCubitFaceStickerIndex(11,0); // DB

    centers[7] = object.getCubitFaceStickerIndex(12,0); // DL

    }

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

  public int tablebaseIndex(TwistyObject object)

    {

    int[][] corners = new int[6][4];

    int[] centers = new int[8];

    int[] face_colors = new int[8];

    getCorners(object,corners);

    getCenters(object,centers);

    int result1 = checkAllCentersPresent(centers);

    if( result1<0 ) return result1;

    int result2 = figureOutFaceColors(face_colors,centers,corners);

    if( result2<0 ) return result2;

    int result3 = checkAllColorsDifferent(face_colors);

    if( result3<0 ) return result3;

    int[] corners_perm = getCornersPermutation(face_colors, corners);

    boolean even1 = TablebaseHelpers.permutationIsEven(corners_perm);

    if( !even1 ) return ERROR_TWO_CORNERS;

    int[] free_centers_perm = getFreeCentersPermutation(face_colors, centers);

    boolean even2 = TablebaseHelpers.permutationIsEven(free_centers_perm);

    if( !even2 ) return ERROR_TWO_CENTERS;

    int[] corners_twist = getCornersTwist(face_colors, corners);

    int totalTwist = getTotalTwist(corners_twist);

    if( totalTwist<0 ) return ERROR_CORNER_TWIST;

    int corners_perm_num = TablebaseHelpers.computeEvenPermutationNum(corners_perm);

    int centers_perm_num = TablebaseHelpers.computeEvenPermutationNum(free_centers_perm);

    return centers_perm_num + 12*(totalTwist + 128*corners_perm_num);

    }

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

  public String error(int index, Resources res)

    {

    switch(index)

      {

      case ERROR_CORNER_FR_MISSING:

      case ERROR_CORNER_BR_MISSING:

      case ERROR_CORNER_BL_MISSING:

      case ERROR_CORNER_FL_MISSING:

      case ERROR_CORNER_TO_MISSING:

      case ERROR_CORNER_BO_MISSING:

      case ERROR_CENTER_0_MISSING :

      case ERROR_CENTER_1_MISSING :

      case ERROR_CENTER_2_MISSING :

      case ERROR_CENTER_3_MISSING :

      case ERROR_CENTER_4_MISSING :

      case ERROR_CENTER_5_MISSING :

      case ERROR_CENTER_6_MISSING :

      case ERROR_CENTER_7_MISSING :

      case ERROR_TWO_CORNERS      :

      case ERROR_TWO_CENTERS      :

      case ERROR_CORNER_TWIST     :

      case ERROR_CORNERS_CANNOT   :

      }

    return null;

    }

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

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

    {

    if( mSolver==null )

      {

      mSolver = ImplementedTablebasesList.createUnpacked(ObjectType.DIAM_2);

      if( mSolver!=null ) mSolver.createTablebase();

      }

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

    }

}