Magic Cube

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

// Copyright 2024 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.util.TypedValue;

import android.view.Gravity;

import android.view.View;

import android.widget.LinearLayout;

import android.widget.TextView;

import org.distorted.helpers.TransparentImageButton;

import org.distorted.library.effect.PostprocessEffectGlow;

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.mesh.MeshBase;

import org.distorted.library.message.EffectListener;

import org.distorted.library.type.Dynamic2D;

import org.distorted.library.type.Dynamic4D;

import org.distorted.library.type.Static2D;

import org.distorted.library.type.Static4D;

import org.distorted.main.R;

import org.distorted.objectlib.helpers.MovesFinished;

import org.distorted.objectlib.helpers.ObjectMove;

import org.distorted.objectlib.main.ObjectControl;

import org.distorted.objectlib.main.TwistyObject;

import java.lang.ref.WeakReference;

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

public class ScreenSolutionMultiphased extends ScreenAbstract implements MovesFinished, EffectListener

  {

  private static final int MOVES_PLACE_0 = 100;

  private static final int MOVES_PLACE_1 = 101;

  private static final int FLASH_TIME = 1200;

  private static final int MILLIS_PER_DEGREE = 6;

  private WeakReference<SolverActivity> mAct;

  private TransparentImageButton mPrevButton, mNextButton, mBackButton, mPrevPhase, mNextPhase;

  private float mButtonSize;

  private TextView mMovesText, mMovesPhase;

  private String[] mPhaseNames;

  private int mNumPhases;

  private ObjectMove[][] mMoves;

  private int[][] mCubitsNotInvolved;

  private int mNumMoves,mCurrMove,mCurrPhase;

  private boolean mCanMove;

  private Dynamic2D mHaloAndRadiusDyn;

  private Dynamic4D mColorDyn;

  private PostprocessEffectGlow mGlow;

  private boolean mEffectWorking;

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

  void leaveScreen(SolverActivity act)

    {

    ObjectControl control = act.getControl();

    control.solveOnly();

    }

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

  void enterScreen(final SolverActivity act)

    {

    mAct = new WeakReference<>(act);

    mHaloAndRadiusDyn = new Dynamic2D(FLASH_TIME,1.0f);

    mHaloAndRadiusDyn.add(new Static2D( 0,0));

    mHaloAndRadiusDyn.add(new Static2D(10,5));

    mColorDyn = new Dynamic4D(FLASH_TIME,1.0f);

    final int[] colors  = new int[] {1,1,1}; // white

    Static4D P1 = new Static4D(colors[0],colors[1],colors[2], 0.0f);

    Static4D P2 = new Static4D(colors[0],colors[1],colors[2], 1.0f);

    mColorDyn.add(P1);

    mColorDyn.add(P2);

    mGlow = new PostprocessEffectGlow(mHaloAndRadiusDyn,mColorDyn);

    float width = act.getScreenWidthInPixels();

    mButtonSize = width*SolverActivity.BUTTON_TEXT_SIZE;

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

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

    layoutTop.removeAllViews();

    setupPrevPhase(act);

    setupNextPhase(act);

    setupTextPhase(act,width);

    layoutTop.addView(mPrevPhase);

    layoutTop.addView(mMovesPhase);

    layoutTop.addView(mNextPhase);

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

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

    layoutBot.removeAllViews();

    LinearLayout.LayoutParams paramsL = new LinearLayout.LayoutParams((int)(width/2),LinearLayout.LayoutParams.MATCH_PARENT);

    LinearLayout.LayoutParams paramsM = new LinearLayout.LayoutParams((int)(width/6),LinearLayout.LayoutParams.MATCH_PARENT);

    LinearLayout.LayoutParams paramsR = new LinearLayout.LayoutParams((int)(width/3),LinearLayout.LayoutParams.MATCH_PARENT);

    LinearLayout layoutLeft = new LinearLayout(act);

    layoutLeft.setLayoutParams(paramsL);

    LinearLayout layoutMid = new LinearLayout(act);

    layoutMid.setLayoutParams(paramsM);

    LinearLayout layoutRight = new LinearLayout(act);

    layoutRight.setLayoutParams(paramsR);

    setupPrevButton(act);

    setupNextButton(act);

    setupTextView(act,width);

    layoutLeft.addView(mPrevButton);

    layoutLeft.addView(mMovesText);

    layoutLeft.addView(mNextButton);

    setupBackButton(act);

    layoutRight.addView(mBackButton);

    layoutBot.addView(layoutLeft);

    layoutBot.addView(layoutMid);

    layoutBot.addView(layoutRight);

    }

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

  private void setupPrevButton(final SolverActivity act)

    {

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

    mPrevButton = new TransparentImageButton(act,R.drawable.ui_left,params);

    mPrevButton.setOnClickListener( new View.OnClickListener()

      {

      @Override public void onClick(View v) { backMove(); }

      });

    }

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

  private void setupNextButton(final SolverActivity act)

    {

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

    mNextButton = new TransparentImageButton(act,R.drawable.ui_right,params);

    mNextButton.setOnClickListener( new View.OnClickListener()

      {

      @Override public void onClick(View v) { nextMove(); }

      });

    }

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

  private void setupTextView(final SolverActivity act, final float width)

    {

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

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

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

    params.topMargin    = margin;

    params.bottomMargin = margin;

    params.leftMargin   = margin;

    params.rightMargin  = margin;

    mMovesText = new TextView(act);

    mMovesText.setTextSize(20);

    mMovesText.setLayoutParams(params);

    mMovesText.setPadding(padding,0,padding,0);

    mMovesText.setGravity(Gravity.CENTER);

    mMovesText.setTextSize(TypedValue.COMPLEX_UNIT_PX, mButtonSize);

    mMovesText.setText(act.getString(R.string.mo_placeholder,mCurrMove,mNumMoves));

    }

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

  private void setupPrevPhase(final SolverActivity act)

    {

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

    mPrevPhase = new TransparentImageButton(act,R.drawable.ui_left,params);

    mPrevPhase.setOnClickListener( new View.OnClickListener()

      {

      @Override public void onClick(View v) { backPhase(); }

      });

    }

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

  private void setupNextPhase(final SolverActivity act)

    {

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

    mNextPhase = new TransparentImageButton(act,R.drawable.ui_right,params);

    mNextPhase.setOnClickListener( new View.OnClickListener()

      {

      @Override public void onClick(View v) { nextPhase(); }

      });

    }

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

  private void setupTextPhase(final SolverActivity act, final float width)

    {

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

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

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

    params.topMargin    = margin;

    params.bottomMargin = margin;

    params.leftMargin   = margin;

    params.rightMargin  = margin;

    mMovesPhase = new TextView(act);

    mMovesPhase.setTextSize(20);

    mMovesPhase.setLayoutParams(params);

    mMovesPhase.setPadding(padding,0,padding,0);

    mMovesPhase.setGravity(Gravity.CENTER);

    mMovesPhase.setTextSize(TypedValue.COMPLEX_UNIT_PX, mButtonSize);

    mMovesPhase.setText(act.getString(R.string.mo_placeholder,mCurrMove,mNumMoves));

    }

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

  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) { ScreenList.goBack(act); }

      });

    }

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

  public void savePreferences(SharedPreferences.Editor editor) { }

  public void restorePreferences(SharedPreferences preferences) { }

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

  void backPhase()

    {

    if( mMoves!=null )

      {

      SolverActivity act = mAct.get();

      ObjectControl control = act.getControl();

      if( mCurrMove>0 )

        {

        ObjectMove[] moves = transformMoves(mMoves[mCurrPhase],0,mCurrMove, false);

        control.applyScrambles(moves);

        mCurrMove = 0;

        }

      else if( mCurrPhase>0 )

        {

        mCurrPhase--;

        mNumMoves = mMoves[mCurrPhase]==null ? 0 : mMoves[mCurrPhase].length;

        mCurrMove = 0;

        ObjectMove[] moves = transformMoves(mMoves[mCurrPhase],0,mNumMoves, false);

        control.applyScrambles(moves);

        }

      else

        {

        mCurrPhase = mNumPhases-1;

        mNumMoves = mMoves[mCurrPhase]==null ? 0 : mMoves[mCurrPhase].length;

        mCurrMove = mNumMoves;

        ObjectMove[] moves = transformMoves(mMoves, true);

        control.applyScrambles(moves);

        }

      setText(act);

      }

    }

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

  void nextPhase()

    {

    if( mMoves!=null )

      {

      SolverActivity act = mAct.get();

      ObjectControl control = act.getControl();

      if( mCurrPhase<mNumPhases-1 )

        {

        glowCubits(mCubitsNotInvolved[mCurrPhase]);

        ObjectMove[] moves = transformMoves(mMoves[mCurrPhase],mCurrMove,mNumMoves, true);

        control.applyScrambles(moves);

        mCurrPhase++;

        mNumMoves = mMoves[mCurrPhase]==null ? 0 : mMoves[mCurrPhase].length;

        mCurrMove = 0;

        }

      else if( mCurrMove<mNumMoves )

        {

        glowCubits(mCubitsNotInvolved[mCurrPhase]);

        ObjectMove[] moves = transformMoves(mMoves[mCurrPhase],mCurrMove,mNumMoves, true);

        control.applyScrambles(moves);

        mCurrMove = mNumMoves;

        }

      else

        {

        mCurrPhase = 0;

        mNumMoves = mMoves[mCurrPhase]==null ? 0 : mMoves[mCurrPhase].length;

        mCurrMove = 0;

        ObjectMove[] moves = transformMoves(mMoves, false);

        control.applyScrambles(moves);

        }

      setText(act);

      }

    }

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

  private void setText(SolverActivity act)

    {

    int currMove = 0;

    int totalMove = 0;

    if( mMoves!=null )

      {

      currMove = mCurrMove;

      for(int p=0; p<mCurrPhase; p++) currMove  += (mMoves[p]==null ? 0: mMoves[p].length);

      for(int p=0; p<mNumPhases; p++) totalMove += (mMoves[p]==null ? 0: mMoves[p].length);

      }

    final int cMove = currMove;

    final int tMove = totalMove;

    act.runOnUiThread(new Runnable()

      {

      @Override

      public void run()

        {

        mMovesPhase.setText(act.getString(R.string.ph_placeholder,mPhaseNames[mCurrPhase],mCurrMove,mNumMoves));

        mMovesText.setText(act.getString(R.string.mo_placeholder,cMove,tMove));

        }

      });

    }

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

  private ObjectMove[] transformMoves(ObjectMove[] moves, int start, int end, boolean front)

    {

    int len = end-start;

    ObjectMove[] ret = new ObjectMove[len];

    for(int m=0; m<len; m++)

      {

      ObjectMove mv = moves[front ? start+m : end-1-m];

      ret[m] = new ObjectMove(mv,front);

      }

    return ret;

    }

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

  private ObjectMove[] transformMoves(ObjectMove[][] moves, boolean front)

    {

    int len = moves.length;

    int totalLen = 0;

    for( ObjectMove[] move : moves ) totalLen += (move==null ? 0 : move.length);

    ObjectMove[] ret = new ObjectMove[totalLen];

    int index = 0;

    for(int m=0; m<len; m++)

      {

      ObjectMove[] mv = moves[front ? m : len-1-m];

      int l = (mv==null ? 0 : mv.length);

      for(int p=0; p<l; p++)

        {

        ObjectMove mve = mv[front ? p : l-1-p];

        ret[index++] = new ObjectMove(mve,front);

        }

      }

    return ret;

    }

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

  private void glowCubits(int[] cubits)

    {

    if( !mEffectWorking )

      {

      mEffectWorking = true;

      SolverActivity act=mAct.get();

      ObjectControl control = act.getControl();

      TwistyObject object=control.getObject();

      DistortedEffects effects=object.getObjectEffects();

      effects.apply(mGlow);

      MeshBase mesh=object.getObjectMesh();

      mesh.setComponentsNotAffectedByPostprocessing(cubits);

      mHaloAndRadiusDyn.resetToBeginning();

      mColorDyn.resetToBeginning();

      mGlow.notifyWhenFinished(this);

      }

    }

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

  private int[] computeCubitsNotInvolved(int[][] subphases, int numCubits)

    {

    int numCubitsInvolved = 0;

    boolean[] involved = new boolean[numCubits];

    for(int[] sub : subphases)

      if( sub!=null )

        for(int s : sub)

          {

          numCubitsInvolved++;

          involved[s] = true;

          }

    int[] ret = new int[numCubits-numCubitsInvolved];

    int index = 0;

    for(int c=0; c<numCubits; c++)

      if( !involved[c] ) ret[index++] = c;

    return ret;

    }

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

  void backMove()

    {

    if( mMoves!=null && mCanMove )

      {

      SolverActivity act=mAct.get();

      if( mCurrMove>0 )

        {

        mCanMove = false;

        ObjectMove move = mMoves[mCurrPhase][--mCurrMove];

        ObjectControl control = act.getControl();

        control.blockTouch(MOVES_PLACE_0);

        control.addBackwardRotation(this, move, MILLIS_PER_DEGREE);

        }

      else if( mCurrPhase>0 )

        {

        mCurrPhase--;

        mNumMoves = mMoves[mCurrPhase]==null ? 0 : mMoves[mCurrPhase].length;

        mCurrMove = mNumMoves;

        glowCubits(mCubitsNotInvolved[mCurrPhase]);

        }

      else

        {

        mCurrPhase = mNumPhases-1;

        mNumMoves = mMoves[mCurrPhase]==null ? 0 : mMoves[mCurrPhase].length;

        mCurrMove = mNumMoves;

        ObjectMove[] moves = transformMoves(mMoves, true);

        ObjectControl control = act.getControl();

        control.applyScrambles(moves);

        glowCubits(mCubitsNotInvolved[mCurrPhase]);

        }

      setText(act);

      }

    }

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

  void nextMove()

    {

    if( mMoves!=null && mCanMove )

      {

      SolverActivity act=mAct.get();

      if( mCurrMove<mNumMoves )

        {

        mCanMove = false;

        ObjectMove move = mMoves[mCurrPhase][mCurrMove++];

        ObjectControl control = act.getControl();

        control.blockTouch(MOVES_PLACE_1);

        control.addForwardRotation(this, move, MILLIS_PER_DEGREE);

        if( mCurrMove==mNumMoves && mCurrPhase==mNumPhases-1 ) glowCubits(mCubitsNotInvolved[mCurrPhase]);

        }

      else if( mCurrPhase<mNumPhases-1 )

        {

        mCurrPhase++;

        mNumMoves = mMoves[mCurrPhase]==null ? 0 : mMoves[mCurrPhase].length;

        mCurrMove = 0;

        glowCubits(mCubitsNotInvolved[mCurrPhase-1]);

        }

      else

        {

        mCurrPhase = 0;

        mNumMoves = mMoves[mCurrPhase]==null ? 0 : mMoves[mCurrPhase].length;

        mCurrMove = 0;

        ObjectMove[] moves = transformMoves(mMoves, false);

        ObjectControl control = act.getControl();

        control.applyScrambles(moves);

        }

      setText(act);

      }

    }

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

  public void updateNames(String[] names)

    {

    mPhaseNames = names;

    mNumPhases = names.length;

    mMoves = new ObjectMove[mNumPhases][];

    mCubitsNotInvolved = new int[mNumPhases][];

    mCanMove = true;

    if( mAct!=null ) setSolution(null,0,null);

    }

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

  public void setSolution(ObjectMove[] moves, int phase, int[][] subphases)

    {

    SolverActivity act=mAct.get();

    if( subphases!=null )

      {

      ObjectControl control=act.getControl();

      TwistyObject object=control.getObject();

      int numCubits=object.getNumCubits();

      mCubitsNotInvolved[phase]= computeCubitsNotInvolved(subphases, numCubits);

      }

    mMoves[phase] = moves;

    if( phase==0 ) mNumMoves = (moves==null ? 0 : moves.length);

    mCurrPhase = 0;

    mCurrMove = 0;

    setText(act);

    }

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

  public void onActionFinished(final long effectID)

    {

    mCanMove = true;

    SolverActivity act=mAct.get();

    ObjectControl control = act.getControl();

    control.unblockRotation();

    }

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

  public void effectFinished(long id)

    {

    SolverActivity act=mAct.get();

    ObjectControl control = act.getControl();

    TwistyObject object=control.getObject();

    DistortedEffects effects=object.getObjectEffects();

    effects.abortById(id);

    mEffectWorking = false;

    }

  }