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.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 android.view.View;

import android.widget.ImageButton;

import android.widget.LinearLayout;

import androidx.core.content.ContextCompat;

import androidx.fragment.app.FragmentManager;

import org.distorted.dialogs.DialogInterrupt;

import org.distorted.dialogs.DialogSolverError;

import org.distorted.dialogs.DialogSolverImpossible;

import org.distorted.dialogs.DialogSolvers;

import org.distorted.helpers.TransparentImageButton;

import org.distorted.main.MainActivity;

import org.distorted.main.R;

import org.distorted.objectlib.helpers.ObjectMove;

import org.distorted.objectlib.helpers.OperatingSystemInterface;

import org.distorted.objectlib.main.ObjectControl;

import org.distorted.objectlib.main.TwistyObject;

import org.distorted.objectlib.shape.*;

import org.distorted.objectlib.solvers.verifiers.ResultScreen;

import org.distorted.objectlib.solvers.verifiers.SolverAbstract;

import org.distorted.objectlib.solvers.verifiers.ImplementedVerifierList;

import java.lang.ref.WeakReference;

import java.util.Timer;

import java.util.TimerTask;

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

public class ScreenSetupPosition extends ScreenAbstract implements ResultScreen

  {

  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 int mNumBitmapRows;

  private float mBitmapSize;

  private WeakReference<SolverActivity> mWeakAct;

  private String mObjectUpperName;

  private String[] mPhaseNames;

  private Timer mTimer;

  private SolverAbstract mSolver;

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

  void leaveScreen(SolverActivity act)

    {

    ObjectControl control = act.getControl();

    control.unsetLock();

    }

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

  void enterScreen(final SolverActivity act)

    {

    ObjectControl control = act.getControl();

    control.setLock(false);

    float width = act.getScreenWidthInPixels();

    float heigh = act.getScreenHeightInPixels();

    mWeakAct = new WeakReference<>(act);

    mSolving = false;

    mPhaseNames = null;

    mObjectUpperName = act.getObjectName();

    control.solveOnly();

    generateFaceColors(mObjectUpperName);

    mNumBitmapRows = mNumColors>8 ? 2 : 1;

    mBitmapSize = computeBitmapSize(width,heigh);

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

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

    layoutTop.removeAllViews();

    if( mNumColors>0 )

      {

      setupBitmaps();

      setupColorButtons(act);

      markButton(act);

      addButtonsToTopLayout(act,layoutTop);

      }

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

    }

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

  private float computeBitmapSize(float width, float heigh)

    {

    final float BUTTON_RATIO = 0.75f;

    float sizeV = (heigh/mNumBitmapRows)*MainActivity.RATIO_BAR;

    float sizeH = (width*mNumBitmapRows)/mNumColors;

    return BUTTON_RATIO*Math.min(sizeV,sizeH);

    }

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

  private void addButtonsToTopLayout(SolverActivity act, LinearLayout layout)

    {

    if( mNumBitmapRows==1 )

      {

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

      }

    else if( mNumBitmapRows==2 )

      {

      LinearLayout layoutV = new LinearLayout(act);

      layoutV.setOrientation(LinearLayout.VERTICAL);

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

      layoutV.setLayoutParams(params);

      LinearLayout layoutT = new LinearLayout(act);

      layoutT.setOrientation(LinearLayout.HORIZONTAL);

      LinearLayout layoutB = new LinearLayout(act);

      layoutB.setOrientation(LinearLayout.HORIZONTAL);

      int numB = mColorButton.length;

      for(int b=0     ; b<numB/2; b++) layoutT.addView(mColorButton[b]);

      for(int b=numB/2; b<numB  ; b++) layoutB.addView(mColorButton[b]);

      layoutV.addView(layoutT);

      layoutV.addView(layoutB);

      layout.addView(layoutV);

      }

    }

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

// 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(String upper)

    {

    mColorMode = MODE_NORMAL;

    if( upper.startsWith("PYRA") || upper.startsWith("PDUO") || upper.startsWith("JING") ||

        upper.startsWith("MORP") )

      {

      mNumColors  = ShapeTetrahedron.NUM_FACES;

      mFaceColors = ShapeTetrahedron.FACE_COLORS;

      }

    else if( upper.startsWith("DIAM") || upper.startsWith("TRAJ") || upper.startsWith("PDIA") )

      {

      mNumColors  = ShapeOctahedron.NUM_FACES;

      mFaceColors = ShapeOctahedron.FACE_COLORS;

      }

    else if( upper.startsWith("CRYS") || upper.startsWith("STAR") || upper.startsWith("PENT") ||

             upper.startsWith("KILO") || upper.startsWith("MEGA") )

      {

      mNumColors  = ShapeDodecahedron.NUM_FACES;

      mFaceColors = ShapeDodecahedron.FACE_COLORS;

      }

    else if( upper.startsWith("BALL") )

      {

      mNumColors  = ShapeDiamond.NUM_FACES;

      mFaceColors = ShapeDiamond.FACE_COLORS;

      }

    else if( upper.startsWith("ICOS") )

      {

      mNumColors  = ShapeIcosahedron.NUM_FACES;

      mFaceColors = ShapeIcosahedron.FACE_COLORS;

      }

    else if( upper.startsWith("DIN4") )

      {

      mNumColors  = 4;

      mFaceColors = new int[] { ShapeColors.COLOR_YELLOW, ShapeColors.COLOR_RED, ShapeColors.COLOR_BLUE, ShapeColors.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 pressSolve(SolverActivity act)

    {

    int[] solverOrdinals = ImplementedVerifierList.getSolverOrdinals(mObjectUpperName);

    if( solverOrdinals!=null  )

      {

      ImplementedVerifierList slvList = ImplementedVerifierList.getSolver(solverOrdinals[0]);

      OperatingSystemInterface os = act.getInterface();

      TwistyObject object = act.getObject();

      SolverAbstract solver = slvList.create(os,object);

      if( solver!=null )

        {

        int[] result = solver.validatePosition(object);

        if( result[0]>=0 ) // position is valid

          {

          if( solverOrdinals.length==1 ) // just one solver - simply launch it

            {

            mSolver = solver;

            solver.solve(this,result);

            }

          else // more than one solver - pop up a choosing dialog

            {

            Bundle bundle = new Bundle();

            bundle.putString("argument", mObjectUpperName );

            DialogSolvers dialog = new DialogSolvers();

            dialog.setArguments(bundle);

            dialog.show( act.getSupportFragmentManager(), DialogSolvers.getDialogTag());

            }

          }

        else displayImpossibleDialog(result,solver.getFaceColors());

        }

      else displayErrorDialog(act.getString(R.string.solver_generic_not_implemented));

      }

    else displayErrorDialog("No solvers found for object "+mObjectUpperName );

    }

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

  public void fail(String result) {}

  public void setPhaseNames(String[] names) { mPhaseNames = names; }

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

  void setSolver(SolverAbstract solver )

    {

    mSolver = solver;

    }

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

  public void startedSolving()

    {

    if( !mSolving )

      {

      mSolving = true;

      mTimer = new Timer();

      mTimer.schedule(new TimerTask()

        {

        @Override

        public void run()

          {

          if( mSolving ) showInterruptDialog();

          }

        }, 2000);

      }

    }

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

  public void stoppedSolving()

    {

    mSolving = false;

    if( mTimer!=null )

      {

      mTimer.cancel();

      mTimer = null;

      }

    final SolverActivity act = mWeakAct.get();

    FragmentManager mana = act.getSupportFragmentManager();

    DialogInterrupt diag = (DialogInterrupt) mana.findFragmentByTag(DialogInterrupt.getDialogTag());

    if( diag!=null ) diag.dismiss();

    }

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

  void interrupt()

    {

    final SolverActivity act = mWeakAct.get();

    FragmentManager mana = act.getSupportFragmentManager();

    DialogInterrupt diag = (DialogInterrupt) mana.findFragmentByTag(DialogInterrupt.getDialogTag());

    if( diag!=null ) diag.dismiss();

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

    }

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

    private void showInterruptDialog()

      {

      final SolverActivity act = mWeakAct.get();

      act.runOnUiThread(new Runnable()

        {

        @Override

        public void run()

          {

          DialogInterrupt dialog = new DialogInterrupt();

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

          }

        });

      }

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

  private void setupColorButtons(final SolverActivity act)

    {

    mColorButton = new ImageButton[mNumColors];

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

      mColorButton[i] = new ImageButton(act);

      mColorButton[i].setLayoutParams(params);

      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 SolverActivity 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 SolverActivity 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 ) pressSolve(act);

        }

      });

    }

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

  private void setupBackButton(final SolverActivity 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(SolverActivity act)

    {

    if( mCurrentButton>=mNumColors )

      {

      mCurrentButton = 0;

      mCurrentColor = translateColor(0);

      }

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

      {

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

      int s = b==mCurrentButton ? act.getSelectedColor() : act.getNormalColor();

      d.setColorFilter(ContextCompat.getColor(act,s), PorterDuff.Mode.MULTIPLY);

      }

    }

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

  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 ObjectMove[] moves, final int phaseNumber, final int[][] subphases)

    {

    final SolverActivity act = mWeakAct.get();

    if( act!=null )

      {

      act.runOnUiThread(new Runnable()

        {

        @Override

        public void run()

          {

          if( mPhaseNames!=null )

            {

            ScreenSolutionMultiphased screen = (ScreenSolutionMultiphased) ScreenList.PHAS.getScreenClass();

            if( phaseNumber==0 )

              {

              ScreenList.switchScreen(act, ScreenList.PHAS);

              screen.updateNames(mPhaseNames);

              }

            screen.setSolution(moves, phaseNumber,subphases);

            }

          else

            {

            ScreenList.switchScreen(act, ScreenList.SOLU);

            ScreenSolutionSinglephased screen = (ScreenSolutionSinglephased) ScreenList.SOLU.getScreenClass();

            screen.setSolution(moves);

            }

          if( moves!=null && moves.length>0 ) act.doNotShowDialogAnymore();

          }

        });

      }

    }

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

  public void displayErrorDialog(String message)

    {

    SolverActivity act = mWeakAct.get();

    if( act!=null )

      {

      DialogSolverError dialog = new DialogSolverError();

      Bundle bundle = new Bundle();

      bundle.putString("argument", message );

      dialog.setArguments(bundle);

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

      }

    }

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

  public void displayImpossibleDialog(String message)

    {

    SolverActivity act = mWeakAct.get();

    if( act!=null )

      {

      DialogSolverImpossible dialog = new DialogSolverImpossible();

      Bundle bundle = new Bundle();

      bundle.putString("argument", message );

      dialog.setArguments(bundle);

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

      }

    }

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

  public void displayImpossibleDialog(int[] errorCode, int[] faceColors)

    {

    SolverActivity act = mWeakAct.get();

    if( act!=null )

      {

      String message = SolverErrors.error(act.getResources(),errorCode,faceColors);

      displayImpossibleDialog(message);

      }

    }

  }