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

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

public class SolverDino6 extends SolverTablebase

{

  private static final int ERROR_EDGE_MISSING        = -1;

  private static final int ERROR_EDGE_CANNOT         = -2;

  private static final int ERROR_EDGE_TWISTED        = -3;

  private static final int ERROR_EDGE_MONOCHROMATIC  = -4;

  private static final int ERROR_EDGE_TWICE          = -5;

  int[][] EDGE_MAP = {

                      {4,2},{0,4},{4,3},{1,4},

                      {2,0},{3,0},{3,1},{2,1},

                      {5,2},{0,5},{5,3},{1,5}

                     };

  private TablebasesAbstract mSolver;

  private final int[] mFaceColors;

  private int mErrorColor1, mErrorColor2;

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

  public SolverDino6(Resources res, TwistyObject object)

    {

    super(res,object);

    mFaceColors = new int[6];

    }

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

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

    {

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

      {

      edges[i][0] = object.getCubitFaceStickerIndex(i,0);

      edges[i][1] = object.getCubitFaceStickerIndex(i,1);

      }

    }

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

  private int computeOpposite(int color, int[][] edges, boolean[] buffer)

    {

    for(int i=0; i<6; i++) buffer[i] = false;

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

      {

      int[] edge = edges[i];

      if( edge[0]==color ) buffer[edge[1]]=true;

      if( edge[1]==color ) buffer[edge[0]]=true;

      }

    int total = 0;

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

      if( buffer[i] )

        {

        if( i!=color) total++;

        else

          {

          mErrorColor1 = i;

          return ERROR_EDGE_MONOCHROMATIC;

          }

        }

    if( total==4 )

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

        if( !buffer[i] && i!=color ) return i;

    return ERROR_EDGE_CANNOT;

    }

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

  private int fillUpRemainingFaceColors(boolean[] buffer)

    {

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

      {

      buffer[i] = false;

      }

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

      {

      int color = mFaceColors[i];

      if( color>=0 ) buffer[color] = true;

      }

    int total = 0;

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

      if( buffer[i] ) total++;

    if( total==4 )

      {

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

        if( !buffer[i] )

          {

          buffer[i]=true;

          mFaceColors[0] = i;

          break;

          }

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

        if( !buffer[i] )

          {

          buffer[i]=true;

          mFaceColors[1] = i;

          break;

          }

      return 0;

      }

    return ERROR_EDGE_CANNOT;

    }

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

  private int figureOutFaceColors(int[][] edges)

    {

    boolean[] present = new boolean[6];

    for(int i=0; i<6; i++) mFaceColors[i] = -1;

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

      {

      int[] edge = edges[i];

      int c0 = edge[0];

      int c1 = edge[1];

      if( c0>=0 && c0<6 ) present[c0] = true;

      if( c1>=0 && c1<6 ) present[c1] = true;

      }

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

      if( !present[i] )

        {

        mErrorColor1 = i;

        mErrorColor2 = (i<5 ? i+1 : 4 );

        return ERROR_EDGE_MISSING;

        }

    if( edges[0][0]==edges[0][1] ) return ERROR_EDGE_CANNOT;

    mFaceColors[4] = edges[0][0];

    mFaceColors[2] = edges[0][1];

    mFaceColors[5] = computeOpposite(mFaceColors[4], edges, present);

    if( mFaceColors[5]<0 ) return mFaceColors[5];

    mFaceColors[3] = computeOpposite(mFaceColors[2], edges, present);

    if( mFaceColors[3]<0 ) return mFaceColors[3];

    int success = fillUpRemainingFaceColors(present);

    if( success<0 ) return success;

    return 0;

    }

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

  private boolean notPresent(int face0, int face1, int[][] edges)

    {

    int c0=mFaceColors[face0];

    int c1=mFaceColors[face1];

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

      {

      int[] edge = edges[i];

      if( edge[0]==c0 && edge[1]==c1 ) return false;

      if( edge[0]==c1 && edge[1]==c0 ) return false;

      }

    return true;

    }

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

  public int checkAllPresent(int[][] edges)

    {

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

      {

      int[] map = EDGE_MAP[i];

      int m1 = map[0];

      int m2 = map[1];

      if( notPresent(m1,m2,edges) )

        {

        mErrorColor1 = mFaceColors[m1];

        mErrorColor2 = mFaceColors[m2];

        return ERROR_EDGE_MISSING;

        }

      }

    return 0;

    }

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

  private boolean wrongTwist(int face0, int face1, int[][] edges)

    {

    int c0=mFaceColors[face0];

    int c1=mFaceColors[face1];

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

      {

      int[] edge = edges[i];

      if( edge[1]==c0 && edge[0]==c1 ) return true;

      }

    return false;

    }

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

  public int checkTwist(int[][] edges)

    {

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

      {

      int[] map = EDGE_MAP[i];

      int m1 = map[0];

      int m2 = map[1];

      if( wrongTwist(m1,m2,edges) )

        {

        mErrorColor1 = mFaceColors[m1];

        mErrorColor2 = mFaceColors[m2];

        return ERROR_EDGE_TWISTED;

        }

      }

    return 0;

    }

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

  public int tablebaseIndex(TwistyObject object)

    {

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

    getEdges(object,edges);

    int result1 = figureOutFaceColors(edges);

    if( result1<0 ) return result1;

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

  {

  android.util.Log.e("D", "face "+i+" : "+mFaceColors[i]);

  }

    int result2 = checkAllPresent(edges);

    if( result2<0 ) return result2;

    int result3 = checkTwist(edges);

    if( result3<0 ) return result3;

    return 0;

    }

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

  private int getColorIndex3(int color)

    {

    switch(color)

      {

      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 getColorIndex6(int color)

    {

    switch(color)

      {

      case 0: return R.string.color_yellow6;

      case 1: return R.string.color_white6;

      case 2: return R.string.color_blue6;

      case 3: return R.string.color_green6;

      case 4: return R.string.color_red6;

      case 5: return R.string.color_orange6;

      }

    return -1;

    }

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

  private String edgeMissingError(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);

    }

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

  private String edgeTwistedError(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_twisted_edge,c0,c1);

    }

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

  private String edgeMonoError(Resources res, int color)

    {

    int j0 = getColorIndex3(color);

    int j1 = getColorIndex6(color);

    String c0 = res.getString(j0);

    String c1 = res.getString(j1);

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

    }

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

  private String edgeTwiceError(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_edge_twice,c0,c1);

    }

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

  public String error(int index, Resources res)

    {

    switch(index)

      {

      case ERROR_EDGE_MISSING      : return edgeMissingError(res,mErrorColor1,mErrorColor2);

      case ERROR_EDGE_TWISTED      : return edgeTwistedError(res,mErrorColor1,mErrorColor2);

      case ERROR_EDGE_MONOCHROMATIC: return edgeMonoError(res,mErrorColor1);

      case ERROR_EDGE_TWICE        : return edgeTwiceError(res,mErrorColor1,mErrorColor2);

      case ERROR_EDGE_CANNOT       : return res.getString(R.string.solver_generic_edges_cannot);

      }

    return null;

    }

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

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

    {

    if( mSolver==null )

      {

      mSolver = ImplementedTablebasesList.createUnpacked(ObjectSignatures.DINO_3);

      if( mSolver!=null )

        {

        mSolver.createTablebase(-1);

        }

      }

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

    }

}