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

import org.distorted.objectlib.tablebases.TablebasesPyraminx;

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

public class SolverPyraminx extends SolverTablebase

{

  private static final int ERROR_CORNER_GYB_MISSING = -1;

  private static final int ERROR_CORNER_GYR_MISSING = -2;

  private static final int ERROR_CORNER_GBR_MISSING = -3;

  private static final int ERROR_CORNER_YBR_MISSING = -4;

  private static final int ERROR_VERTEX_GYB_MISSING = -5;

  private static final int ERROR_VERTEX_GYR_MISSING = -6;

  private static final int ERROR_VERTEX_GBR_MISSING = -7;

  private static final int ERROR_VERTEX_YBR_MISSING = -8;

  private static final int ERROR_EDGE_RB_MISSING = -9;

  private static final int ERROR_EDGE_RY_MISSING = -10;

  private static final int ERROR_EDGE_RG_MISSING = -11;

  private static final int ERROR_EDGE_YB_MISSING = -12;

  private static final int ERROR_EDGE_GB_MISSING = -13;

  private static final int ERROR_EDGE_GY_MISSING = -14;

  private static final int ERROR_CORNERS_CANNOT   = -15;

  private static final int ERROR_VERTICES_CANNOT  = -16;

  private static final int ERROR_CORNER_TWISTED   = -17;

  private static final int ERROR_EDGE_TWISTED     = -18;

  private static final int ERROR_C_V_DONT_MATCH   = -19;

  private static final int ERROR_TWO_EDGES        = -20;

  TablebasesAbstract mSolver;

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

  private boolean pieceEqual3(int[] piece, int c1, int c2, int c3)

    {

    return ( (piece[0]==c1 && piece[1]==c2 && piece[2]==c3) ||

             (piece[0]==c1 && piece[2]==c2 && piece[1]==c3) ||

             (piece[1]==c1 && piece[0]==c2 && piece[2]==c3) ||

             (piece[1]==c1 && piece[2]==c2 && piece[0]==c3) ||

             (piece[2]==c1 && piece[1]==c2 && piece[0]==c3) ||

             (piece[2]==c1 && piece[0]==c2 && piece[1]==c3)  );

    }

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

  private boolean pieceEqual2(int[] piece, int c1, int c2)

    {

    return ( (piece[0]==c1 && piece[1]==c2) ||

             (piece[0]==c2 && piece[1]==c1)  );

    }

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

  private int checkAllCornersPresent(int[][] corners)

    {

    boolean ybr = false;

    boolean gbr = false;

    boolean gyr = false;

    boolean gyb = false;

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

      {

      if( pieceEqual3(corners[i],0,1,2) ) gyb = true;

      if( pieceEqual3(corners[i],0,1,3) ) gyr = true;

      if( pieceEqual3(corners[i],0,2,3) ) gbr = true;

      if( pieceEqual3(corners[i],1,2,3) ) ybr = true;

      }

    if( !ybr ) return ERROR_CORNER_YBR_MISSING;

    if( !gbr ) return ERROR_CORNER_GBR_MISSING;

    if( !gyr ) return ERROR_CORNER_GYR_MISSING;

    if( !gyb ) return ERROR_CORNER_GYB_MISSING;

    return 0;

    }

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

  private int checkAllVerticesPresent(int[][] vertex)

    {

    boolean ybr = false;

    boolean gbr = false;

    boolean gyr = false;

    boolean gyb = false;

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

      {

      if( pieceEqual3(vertex[i],0,1,2) ) gyb = true;

      if( pieceEqual3(vertex[i],0,1,3) ) gyr = true;

      if( pieceEqual3(vertex[i],0,2,3) ) gbr = true;

      if( pieceEqual3(vertex[i],1,2,3) ) ybr = true;

      }

    if( !ybr ) return ERROR_VERTEX_YBR_MISSING;

    if( !gbr ) return ERROR_VERTEX_GBR_MISSING;

    if( !gyr ) return ERROR_VERTEX_GYR_MISSING;

    if( !gyb ) return ERROR_VERTEX_GYB_MISSING;

    return 0;

    }

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

  private int checkAllEdgesPresent(int[][] edges)

    {

    boolean rb = false;

    boolean ry = false;

    boolean rg = false;

    boolean yb = false;

    boolean gb = false;

    boolean gy = false;

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

      {

      if( pieceEqual2(edges[i],3,2) ) rb = true;

      if( pieceEqual2(edges[i],3,1) ) ry = true;

      if( pieceEqual2(edges[i],3,0) ) rg = true;

      if( pieceEqual2(edges[i],2,1) ) yb = true;

      if( pieceEqual2(edges[i],2,0) ) gb = true;

      if( pieceEqual2(edges[i],1,0) ) gy = true;

      }

    if( !rb ) return ERROR_EDGE_RB_MISSING;

    if( !ry ) return ERROR_EDGE_RY_MISSING;

    if( !rg ) return ERROR_EDGE_RG_MISSING;

    if( !yb ) return ERROR_EDGE_YB_MISSING;

    if( !gb ) return ERROR_EDGE_GB_MISSING;

    if( !gy ) return ERROR_EDGE_GY_MISSING;

    return 0;

    }

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

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

    {

    int[] ret = new int[4];

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

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

        if( corners[i][0]!=j && corners[i][1]!=j && corners[i][2]!=j ) ret[i]=j;

    return ret;

    }

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

  private int checkAgreement(int[] faces1, int[] faces2)

    {

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

      if( faces1[i]!=faces2[i] ) return ERROR_C_V_DONT_MATCH;

    return 0;

    }

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

  private int computePieceTwist(int index, int[] corner, int[] faceColor)

    {

    int twist1=0, twist2=0, twist3=0;

    switch(index)

      {

      case 0: if( corner[1]==faceColor[1] ) twist1=1;

              if( corner[2]==faceColor[1] ) twist1=2;

              if( corner[0]==faceColor[2] ) twist2=2;

              if( corner[2]==faceColor[2] ) twist2=1;

              if( corner[0]==faceColor[3] ) twist3=1;

              if( corner[1]==faceColor[3] ) twist3=2;

              break;

      case 1: if( corner[1]==faceColor[0] ) twist1=1;

              if( corner[2]==faceColor[0] ) twist1=2;

              if( corner[0]==faceColor[2] ) twist2=1;

              if( corner[1]==faceColor[2] ) twist2=2;

              if( corner[0]==faceColor[3] ) twist3=2;

              if( corner[2]==faceColor[3] ) twist3=1;

              break;

      case 2: if( corner[1]==faceColor[0] ) twist1=1;

              if( corner[2]==faceColor[0] ) twist1=2;

              if( corner[0]==faceColor[1] ) twist2=2;

              if( corner[2]==faceColor[1] ) twist2=1;

              if( corner[0]==faceColor[3] ) twist3=1;

              if( corner[1]==faceColor[3] ) twist3=2;

              break;

      case 3: if( corner[1]==faceColor[0] ) twist1=1;

              if( corner[2]==faceColor[0] ) twist1=2;

              if( corner[0]==faceColor[1] ) twist2=1;

              if( corner[1]==faceColor[1] ) twist2=2;

              if( corner[0]==faceColor[2] ) twist3=2;

              if( corner[2]==faceColor[2] ) twist3=1;

              break;

      }

    return ( twist1!=twist2 || twist1!=twist3 ) ? -1 : twist1;

    }

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

  private int[] computeEdgeQuats(int[][] edges)

    {

    return null;

    }

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

  public SolverPyraminx(Resources res, TwistyObject object)

    {

    super(res,object);

    }

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

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

    {

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

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

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

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

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

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

    corners[2][0] = object.getCubitFaceStickerIndex(13,3);  // R

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

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

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

    corners[3][1] = object.getCubitFaceStickerIndex(11,1);  // Y

    corners[3][2] = object.getCubitFaceStickerIndex(11,2);  // B

    }

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

  private void getVertices(TwistyObject object, int[][] vertex)

    {

    vertex[0][0] = object.getCubitFaceStickerIndex(1,5);  // R

    vertex[0][1] = object.getCubitFaceStickerIndex(1,7);  // B

    vertex[0][2] = object.getCubitFaceStickerIndex(1,2);  // Y

    vertex[1][0] = object.getCubitFaceStickerIndex(0,5);  // R

    vertex[1][1] = object.getCubitFaceStickerIndex(0,0);  // G

    vertex[1][2] = object.getCubitFaceStickerIndex(0,7);  // B

    vertex[2][0] = object.getCubitFaceStickerIndex(3,5);  // R

    vertex[2][1] = object.getCubitFaceStickerIndex(3,2);  // Y

    vertex[2][2] = object.getCubitFaceStickerIndex(3,0);  // G

    vertex[3][0] = object.getCubitFaceStickerIndex(2,0);  // G

    vertex[3][1] = object.getCubitFaceStickerIndex(2,2);  // Y

    vertex[3][2] = object.getCubitFaceStickerIndex(2,7);  // B

    }

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

  private void getEdges(TwistyObject object, int[][] edges)

    {

    edges[0][0] = object.getCubitFaceStickerIndex(5,3);  // R

    edges[0][1] = object.getCubitFaceStickerIndex(5,2);  // B

    edges[1][0] = object.getCubitFaceStickerIndex(10,3); // R

    edges[1][1] = object.getCubitFaceStickerIndex(10,1); // Y

    edges[2][0] = object.getCubitFaceStickerIndex(9,3);  // R

    edges[2][1] = object.getCubitFaceStickerIndex(9,0);  // G

    edges[3][0] = object.getCubitFaceStickerIndex(8,1);  // Y

    edges[3][1] = object.getCubitFaceStickerIndex(8,2);  // B

    edges[4][0] = object.getCubitFaceStickerIndex(7,0);  // G

    edges[4][1] = object.getCubitFaceStickerIndex(7,2);  // B

    edges[5][0] = object.getCubitFaceStickerIndex(12,0); // G

    edges[5][1] = object.getCubitFaceStickerIndex(12,1); // Y

    }

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

  public int tablebaseIndex(TwistyObject object)

    {

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

    int[][] edges   = new int[6][2];

    int[][] vertices= new int[4][3];

    int[] corner_twist = new int[4];

    int[] vertex_twist = new int[4];

    getCorners(object,corners);

    getVertices(object,vertices);

    getEdges(object,edges);

    int result1 = checkAllCornersPresent(corners);

    if( result1<0 ) return result1;

    int result2 = checkAllVerticesPresent(vertices);

    if( result2<0 ) return result2;

    int result3 = checkAllEdgesPresent(edges);

    if( result3<0 ) return result3;

    int[] faces1 = computeFaceColors(corners);

    int[] faces2 = computeFaceColors(vertices);

    int result4 = checkAgreement(faces1,faces2);

    if( result4<0 ) return result4;

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

      {

      corner_twist[i] = computePieceTwist(i,corners[i],faces1);

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

      }

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

      {

      vertex_twist[i] = computePieceTwist(i,vertices[i],faces1);

      if( vertex_twist[i]<0 ) return ERROR_VERTICES_CANNOT;

      }

    int[] quats = computeEdgeQuats(edges);

    int[] permutation = new int[6];

    TablebasesPyraminx.getEdgePermutation(permutation,quats);

    boolean even = TablebaseHelpers.permutationIsEven(permutation);

    if( !even ) return ERROR_TWO_EDGES;

    return 0;

    }

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

  private int getColorIndex3(int color)

    {

    switch(color)

      {

      case 0: return R.string.color_green3;

      case 1: return R.string.color_yellow3;

      case 2: return R.string.color_blue3;

      case 3: return R.string.color_red3;

      }

    return -1;

    }

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

  private int getColorIndex4(int color)

    {

    switch(color)

      {

      case 0: return R.string.color_green4;

      case 1: return R.string.color_yellow4;

      case 2: return R.string.color_blue4;

      case 3: return R.string.color_red4;

      }

    return -1;

    }

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

  private int getColorIndex6(int color)

    {

    switch(color)

      {

      case 0: return R.string.color_green6;

      case 1: return R.string.color_yellow6;

      case 2: return R.string.color_blue6;

      case 3: return R.string.color_red6;

      }

    return -1;

    }

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

  private String cornerError(Resources res, int color0, int color1, int color2)

    {

    int j0 = getColorIndex3(color0);

    int j1 = getColorIndex3(color1);

    int j2 = getColorIndex4(color2);

    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 vertexError(Resources res, int color0, int color1, int color2)

    {

    int j0 = getColorIndex3(color0);

    int j1 = getColorIndex3(color1);

    int j2 = getColorIndex4(color2);

    String c0 = res.getString(j0);

    String c1 = res.getString(j1);

    String c2 = res.getString(j2);

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

    }

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

  private String edgeError(Resources res, int color0, int color1)

    {

    int j0 = getColorIndex3(color0);

    int j1 = getColorIndex6(color1);

    String c0 = res.getString(j0);

    String c1 = res.getString(j1);

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

    }

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

  public String error(int index, Resources res)

    {

    switch(index)

      {

      case ERROR_CORNER_YBR_MISSING: return cornerError(res,3,2,1);

      case ERROR_CORNER_GBR_MISSING: return cornerError(res,3,2,0);

      case ERROR_CORNER_GYR_MISSING: return cornerError(res,3,1,0);

      case ERROR_CORNER_GYB_MISSING: return cornerError(res,2,1,0);

      case ERROR_VERTEX_YBR_MISSING: return vertexError(res,3,2,1);

      case ERROR_VERTEX_GBR_MISSING: return vertexError(res,3,2,0);

      case ERROR_VERTEX_GYR_MISSING: return vertexError(res,3,1,0);

      case ERROR_VERTEX_GYB_MISSING: return vertexError(res,2,1,0);

      case ERROR_EDGE_RB_MISSING   : return edgeError(res,3,2);

      case ERROR_EDGE_RY_MISSING   : return edgeError(res,3,1);

      case ERROR_EDGE_RG_MISSING   : return edgeError(res,3,0);

      case ERROR_EDGE_YB_MISSING   : return edgeError(res,2,1);

      case ERROR_EDGE_GB_MISSING   : return edgeError(res,2,0);

      case ERROR_EDGE_GY_MISSING   : return edgeError(res,1,0);

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

      case ERROR_EDGE_TWISTED      : return res.getString(R.string.solver_generic_edge_twist);

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

      case ERROR_VERTICES_CANNOT   : return res.getString(R.string.solver_generic_vertices_cannot);

      case ERROR_C_V_DONT_MATCH    : return res.getString(R.string.solver_generic_c_v_dont_match);

      case ERROR_TWO_EDGES         : return res.getString(R.string.solver_generic_two_edges);

      }

    return null;

    }

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

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

    {

    if( mSolver==null )

      {

      //mSolver = ImplementedTablebasesList.createPacked(res,ObjectType.PYRA_3);

      mSolver = ImplementedTablebasesList.createUnpacked(ObjectType.PYRA_3);

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

      }

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

    }

}