Magic Cube

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

// Copyright 2020 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.screens;

import static org.distorted.objectlib.main.TwistyObject.*;

import java.lang.ref.WeakReference;

import android.content.SharedPreferences;

import android.graphics.Bitmap;

import android.graphics.Canvas;

import android.graphics.Paint;

import android.graphics.PorterDuff;

import android.graphics.drawable.Drawable;

import android.os.Bundle;

import androidx.core.content.ContextCompat;

import android.view.View;

import android.widget.ImageButton;

import android.widget.LinearLayout;

import org.distorted.dialogs.RubikDialogSolverImpossible;

import org.distorted.main.MainActivity;

import org.distorted.objectlib.main.ObjectControl;

import org.distorted.objectlib.signature.ObjectConstants;

import org.distorted.objectlib.main.TwistyObject;

import org.distorted.dialogs.RubikDialogSolverError;

import org.distorted.helpers.TransparentImageButton;

import org.distorted.main.R;

import org.distorted.main_old.RubikActivity;

import org.distorted.objectlib.shape.ShapeDiamond;

import org.distorted.objectlib.shape.ShapeDodecahedron;

import org.distorted.objectlib.shape.ShapeHexahedron;

import org.distorted.objectlib.shape.ShapeIcosahedron;

import org.distorted.objectlib.shape.ShapeOctahedron;

import org.distorted.objectlib.shape.ShapeTetrahedron;

import org.distorted.objects.RubikObjectList;

import org.distorted.solvers.ImplementedSolversList;

import org.distorted.solvers.SolverMain;

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

public class RubikScreenSolver extends RubikScreenAbstract

  {

  private static final int RESET_DURATION = 1000;

  private static final int MODE_NORMAL = 0;

  private static final int MODE_DINO_4 = 1;

  private static Bitmap[] mBitmap;

  private ImageButton[] mColorButton;

  private TransparentImageButton mResetButton,mBackButton, mSolveButton;

  private boolean mSolving;

  private int mCurrentColor, mCurrentButton;

  private int[] mFaceColors;

  private int mColorMode;

  private int mNumColors;

  private float mBitmapSize;

  private WeakReference<RubikActivity> mWeakAct;

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

  void leaveScreen(RubikActivity act)

    {

    ObjectControl control = act.getControl();

    control.unsetLock();

    }

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

  void enterScreen(final RubikActivity act)

    {

    ObjectControl control = act.getControl();

    control.setLock(false);

    float width = act.getScreenWidthInPixels();

    float heigh = act.getScreenHeightInPixels();

    mWeakAct = new WeakReference<>(act);

    mSolving = false;

    int solverIndex= act.getSolverIndex();

    ImplementedSolversList currentSolver = ImplementedSolversList.getSolver(solverIndex);

    int currentObject = currentSolver.getObject();

    act.changeIfDifferent(currentObject,control);

    control.solveOnly();

    RubikObjectList.setCurrObject(currentObject);

    generateFaceColors(currentObject);

    final float BUTTON_RATIO = 0.75f;

    int sizeV = (int)(heigh*MainActivity.RATIO_BAR*BUTTON_RATIO);

    int sizeH = (int)((width/mNumColors)*BUTTON_RATIO);

    mBitmapSize = Math.min(sizeV,sizeH);

    // TOP ////////////////////////////

    LinearLayout layoutTop = act.findViewById(R.id.upperBar);

    layoutTop.removeAllViews();

    if( mNumColors>0 )

      {

      setupBitmaps();

      setupColorButtons(act,width);

      markButton(act);

      }

    for(ImageButton button: mColorButton) layoutTop.addView(button);

    // BOT ////////////////////////////

    LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT,LinearLayout.LayoutParams.MATCH_PARENT,1);

    LinearLayout layoutL = new LinearLayout(act);

    layoutL.setLayoutParams(params);

    LinearLayout layoutM = new LinearLayout(act);

    layoutM.setLayoutParams(params);

    LinearLayout layoutR = new LinearLayout(act);

    layoutR.setLayoutParams(params);

    LinearLayout layoutBot = act.findViewById(R.id.lowerBar);

    layoutBot.removeAllViews();

    setupResetButton(act);

    setupSolveButton(act);

    setupBackButton(act);

    layoutL.addView(mResetButton);

    layoutM.addView(mSolveButton);

    layoutR.addView(mBackButton);

    layoutBot.addView(layoutL);

    layoutBot.addView(layoutM);

    layoutBot.addView(layoutR);

    }

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

// This doesn't quite work in many cases, but in case of the solvers that will pop up in foreseeable

// future it should be ok.

  public void generateFaceColors(int object)

    {

    mColorMode = MODE_NORMAL;

    if( object== ObjectConstants.PYRA_3 ||

        object== ObjectConstants.PYRA_4 ||

        object== ObjectConstants.PYRA_5 ||

        object== ObjectConstants.PDUO_2 ||

        object== ObjectConstants.JING_2 ||

        object== ObjectConstants.MORP_2 ||

        object== ObjectConstants.MORP_3 ||

        object== ObjectConstants.MORP_4  )

      {

      mNumColors  = ShapeTetrahedron.NUM_FACES;

      mFaceColors = ShapeTetrahedron.FACE_COLORS;

      }

    else if( object== ObjectConstants.DIAM_2 ||

             object== ObjectConstants.DIAM_3 ||

             object== ObjectConstants.DIAM_4 ||

             object== ObjectConstants.TRAJ_3 ||

             object== ObjectConstants.TRAJ_4 ||

             object== ObjectConstants.PDIA_3  )

      {

      mNumColors  = ShapeOctahedron.NUM_FACES;

      mFaceColors = ShapeOctahedron.FACE_COLORS;

      }

    else if( object== ObjectConstants.CRYS_3 ||

             object== ObjectConstants.STAR_3 ||

             object== ObjectConstants.PENT_2 ||

             object== ObjectConstants.KILO_3 ||

             object== ObjectConstants.KILO_5 ||

             object== ObjectConstants.MEGA_3 ||

             object== ObjectConstants.MEGA_5  )

      {

      mNumColors  = ShapeDodecahedron.NUM_FACES;

      mFaceColors = ShapeDodecahedron.FACE_COLORS;

      }

    else if( object== ObjectConstants.BALL_4 )

      {

      mNumColors  = ShapeDiamond.NUM_FACES;

      mFaceColors = ShapeDiamond.FACE_COLORS;

      }

    else if( object== ObjectConstants.ICOS_2 )

      {

      mNumColors  = ShapeIcosahedron.NUM_FACES;

      mFaceColors = ShapeIcosahedron.FACE_COLORS;

      }

    else if( object== ObjectConstants.DIN4_3 )

      {

      mNumColors  = 4;

      mFaceColors = new int[] { COLOR_YELLOW, COLOR_RED, COLOR_BLUE, COLOR_WHITE };

      mColorMode  = MODE_DINO_4;

      }

    else

      {

      mNumColors  = ShapeHexahedron.NUM_FACES;

      mFaceColors = ShapeHexahedron.FACE_COLORS;

      }

    }

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

  private void setupBitmaps()

    {

    final int SIZE = (int)mBitmapSize;

    final float R = SIZE*0.15f;

    final float M = SIZE*0.08f;

    mBitmap = new Bitmap[mNumColors];

    Paint paint = new Paint();

    paint.setColor(0xff008800);

    paint.setStyle(Paint.Style.FILL);

    paint.setAntiAlias(true);

    paint.setTextAlign(Paint.Align.CENTER);

    paint.setStyle(Paint.Style.FILL);

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

      {

      mBitmap[i] = Bitmap.createBitmap(SIZE, SIZE, Bitmap.Config.ARGB_8888);

      Canvas canvas = new Canvas(mBitmap[i]);

      paint.setColor(0xff000000);

      canvas.drawRect(0, 0, SIZE, SIZE, paint);

      paint.setColor(mFaceColors[i]);

      canvas.drawRoundRect( M, M, SIZE-M, SIZE-M, R, R, paint);

      }

    }

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

  private int translateColor(int color)

    {

    if( mColorMode==MODE_DINO_4 )

      {

      int realColor = mFaceColors[color];

      int[] hexColors = ShapeHexahedron.FACE_COLORS;

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

        if( hexColors[i]==realColor ) return i;

      }

    return color;

    }

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

  private void setupColorButtons(final RubikActivity act, final float width)

    {

    mColorButton = new ImageButton[mNumColors];

    int padding = (int)(width*RubikActivity.PADDING);

    int margin  = (int)(width*RubikActivity.SMALL_MARGIN);

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

      {

      final int ii = i;

      LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.WRAP_CONTENT,LinearLayout.LayoutParams.MATCH_PARENT, 1.0f);

      params.topMargin    = margin;

      params.bottomMargin = margin;

      params.leftMargin   = margin;

      params.rightMargin  = margin;

      mColorButton[i] = new ImageButton(act);

      mColorButton[i].setLayoutParams(params);

      mColorButton[i].setPadding(padding,0,padding,0);

      mColorButton[i].setImageBitmap(mBitmap[i]);

      mColorButton[i].setOnClickListener( new View.OnClickListener()

        {

        @Override

        public void onClick(View view)

          {

          mCurrentColor = translateColor(ii);

          mCurrentButton= ii;

          markButton(act);

          }

        });

      }

    }

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

  private void setupResetButton(final RubikActivity act)

    {

    LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT,LinearLayout.LayoutParams.MATCH_PARENT);

    mResetButton = new TransparentImageButton(act, R.drawable.ui_reset, params);

    mResetButton.setOnClickListener( new View.OnClickListener()

      {

      @Override

      public void onClick(View v)

        {

        ObjectControl control = act.getControl();

        control.resetTextureMapsEffect(RESET_DURATION);

        }

      });

    }

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

  private void setupSolveButton(final RubikActivity act)

    {

    LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT,LinearLayout.LayoutParams.MATCH_PARENT,1.0f);

    mSolveButton = new TransparentImageButton(act,R.drawable.ui_solve,params);

    mSolveButton.setOnClickListener( new View.OnClickListener()

      {

      @Override

      public void onClick(View v)

        {

        if( !mSolving )

          {

          mSolving = true;

          TwistyObject object = act.getObject();

          SolverMain solver = new SolverMain( act.getInterface(), act.getResources(), object );

          solver.start();

          }

        }

      });

    }

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

  private void setupBackButton(final RubikActivity act)

    {

    LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT,LinearLayout.LayoutParams.MATCH_PARENT,1.0f);

    mBackButton = new TransparentImageButton(act,R.drawable.ui_back,params);

    mBackButton.setOnClickListener( new View.OnClickListener()

      {

      @Override

      public void onClick(View v)

        {

        ObjectControl control = act.getControl();

        control.resetAllTextureMaps();

        ScreenList.goBack(act);

        }

      });

    }

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

  private void markButton(RubikActivity act)

    {

    if( mCurrentButton>=mNumColors )

      {

      mCurrentButton = 0;

      mCurrentColor = translateColor(0);

      }

    for(int b=0; b<mNumColors; b++)

      {

      Drawable d = mColorButton[b].getBackground();

      if( b==mCurrentButton )

        {

        d.setColorFilter(ContextCompat.getColor(act,R.color.red), PorterDuff.Mode.MULTIPLY);

        }

      else

        {

        d.clearColorFilter();

        }

      }

    }

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

  public void savePreferences(SharedPreferences.Editor editor)

    {

    editor.putInt("stateSolver_color" , mCurrentColor );

    editor.putInt("stateSolver_button", mCurrentButton);

    }

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

  public void restorePreferences(SharedPreferences preferences)

    {

    mCurrentColor = preferences.getInt("stateSolver_color" , 0);

    mCurrentButton= preferences.getInt("stateSolver_button", 0);

    }

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

  public int getCurrentColor()

    {

    return mCurrentColor;

    }

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

  public void setSolved(final String moves)

    {

    mSolving = false;

    final RubikActivity act = mWeakAct.get();

    if( act!=null )

      {

      act.runOnUiThread(new Runnable()

        {

        @Override

        public void run()

          {

          ScreenList.switchScreen(act, ScreenList.SOLU);

          RubikScreenSolution solution = (RubikScreenSolution) ScreenList.SOLU.getScreenClass();

          solution.setupMoves(act, moves);

          }

        });

      }

    }

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

  public void setSolved(final int[][] moves)

    {

    mSolving = false;

    final RubikActivity act = mWeakAct.get();

    if( act!=null )

      {

      act.runOnUiThread(new Runnable()

        {

        @Override

        public void run()

          {

          ScreenList.switchScreen(act, ScreenList.SOLU);

          RubikScreenSolution solution = (RubikScreenSolution) ScreenList.SOLU.getScreenClass();

          solution.setupMoves(act, moves);

          }

        });

      }

    }

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

  public void displayErrorDialog(String message)

    {

    mSolving = false;

    RubikActivity act = mWeakAct.get();

    if( act!=null )

      {

      RubikDialogSolverError dialog = new RubikDialogSolverError();

      Bundle bundle = new Bundle();

      bundle.putString("argument", message );

      dialog.setArguments(bundle);

      dialog.show( act.getSupportFragmentManager(), null);

      }

    }

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

  public void displayImpossibleDialog(String message)

    {

    mSolving = false;

    RubikActivity act = mWeakAct.get();

    if( act!=null )

      {

      RubikDialogSolverImpossible dialog = new RubikDialogSolverImpossible();

      Bundle bundle = new Bundle();

      bundle.putString("argument", message );

      dialog.setArguments(bundle);

      dialog.show( act.getSupportFragmentManager(), null);

      }

    }

  }