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

import org.distorted.objectlib.metadata.ListObjects;

import org.distorted.objectlib.main.TwistyObject;

import org.distorted.objectlib.tablebases.ImplementedTablebasesList;

import org.distorted.objectlib.tablebases.TBDino6;

import org.distorted.objectlib.tablebases.TablebaseHelpers;

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;

  private static final int ERROR_TWO_EDGES           = -6;

  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(OperatingSystemInterface os, Resources res, TwistyObject object)

    {

    super(os,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)

    {

    int[] buffer = new int[6];

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

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

      {

      int e0 = edges[i][0];

      int e1 = edges[i][1];

      if( e0==color && e1==color)

        {

        mErrorColor1 = color;

        return ERROR_EDGE_MONOCHROMATIC;

        }

      if( e0==color )

        {

        buffer[e1]++;

        if( buffer[e1]>1 )

          {

          mErrorColor1 = color;

          mErrorColor2 = e1;

          return ERROR_EDGE_TWICE;

          }

        }

      if( e1==color )

        {

        buffer[e0]++;

        if( buffer[e0]>1 )

          {

          mErrorColor1 = color;

          mErrorColor2 = e0;

          return ERROR_EDGE_TWICE;

          }

        }

      }

    int total = 0;

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

      if( buffer[i]==1 )

        {

        if( i!=color) total++;

        else

          {

          mErrorColor1 = i;

          return ERROR_EDGE_MONOCHROMATIC;

          }

        }

    if( total==4 )

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

        if( buffer[i]==0 && 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<4 ? i+2 : i-2 );

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

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

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

    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;

    }

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

  private int getPerm(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 i;

      }

    return -1;

    }

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

  private int computePermutation(int[][] edges, int[] perm)

    {

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

      {

      int[] map = EDGE_MAP[i];

      int m1 = map[0];

      int m2 = map[1];

      perm[i] = getPerm(m1,m2,edges);

      }

    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;

    int result2 = checkAllPresent(edges);

    if( result2<0 ) return result2;

    int result3 = checkTwist(edges);

    if( result3<0 ) return result3;

    int[] perm = new int[12];

    int result4 = computePermutation(edges,perm);

    if( result4<0 ) return result4;

    if( !TablebaseHelpers.permutationIsEven(perm) ) return ERROR_TWO_EDGES;

    return TBDino6.getIndexFromPerm(perm);

    }

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

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

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

      }

    return null;

    }

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

  public int[][] solution(int index, OperatingSystemInterface os)

    {

    if( mSolver==null )

      {

      mSolver = ImplementedTablebasesList.createPacked(os, ListObjects.DINO_3.name() );

      }

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

    }

}