Phased Solver

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

// 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.phasedsolver;

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

import android.app.Activity;

import android.content.SharedPreferences;

import android.os.Bundle;

import android.view.View;

import android.widget.AdapterView;

import android.widget.ArrayAdapter;

import android.widget.Spinner;

import android.widget.TextView;

import android.widget.Toast;

import androidx.preference.PreferenceManager;

import org.distorted.library.main.DistortedLibrary;

import org.distorted.objectlib.helpers.ObjectMove;

import org.distorted.objectlib.solvers.implemented.PhasedSolverList;

import org.distorted.objectlib.solvers.implemented.PhasedSolverAbstract;

import org.distorted.objectlib.main.InitAssets;

import org.distorted.objectlib.main.ObjectControl;

import org.distorted.objectlib.main.TwistyObject;

import org.distorted.objectlib.solvers.algorithmic.SolutionListener;

import org.distorted.objectlib.solvers.algorithmic.SolvedObject;

import org.distorted.os.OSInterface;

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

public class SolverActivity extends Activity implements SolutionListener, AdapterView.OnItemSelectedListener

{

  private InitAssets mAsset;

  private SharedPreferences mPreferences;

  private SolverLowerPane mLowerPane;

  private TextView mTextView;

  private SolvedObject mObject;

  private String mText;

  private int mCurrSolver, mCurrMode;

  private PhasedSolverAbstract mSolver;

  private long mTime;

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

  @Override

  protected void onCreate(Bundle icicle)

    {

    super.onCreate(icicle);

    mPreferences = PreferenceManager.getDefaultSharedPreferences(this);

    DistortedLibrary.onCreate();

    setContentView(R.layout.mainlayout);

    SolverSurfaceView view = findViewById(R.id.solverView);

    OSInterface os = view.getInterface();

    mAsset = new InitAssets(null, null, os);

    mTextView = findViewById(R.id.solverTextView);

    mText = "";

    mCurrSolver = 0;

    Spinner objectSpinner = findViewById(R.id.solverSpinner);

    objectSpinner.setOnItemSelectedListener(this);

    String[] solverNames = createSolverNames();

    ArrayAdapter<String> objAdapter = new ArrayAdapter<>(this, android.R.layout.simple_spinner_item, solverNames);

    objAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);

    objectSpinner.setAdapter(objAdapter);

    mCurrMode = 0;

    Spinner modeSpinner = findViewById(R.id.solverMode);

    modeSpinner.setOnItemSelectedListener(this);

    String[] solverMode = { "MOVE", "CUBIT" };

    ArrayAdapter<String> modeAdapter = new ArrayAdapter<>(this, android.R.layout.simple_spinner_item, solverMode);

    modeAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);

    modeSpinner.setAdapter(modeAdapter);

    String[] phaseNames = createSolver();

    mLowerPane = new SolverLowerPane(this,phaseNames);

    }

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

  @Override

  protected void onPause()

    {

    super.onPause();

    SolverSurfaceView view = findViewById(R.id.solverView);

    view.onPause();

    DistortedLibrary.onPause();

    savePreferences();

    }

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

  @Override

  protected void onResume()

    {

    super.onResume();

    SolverSurfaceView view = findViewById(R.id.solverView);

    view.onResume();

    DistortedLibrary.onResume();

    restorePreferences();

    int ordinal = getObjectOrdinal();

    ObjectControl control = getControl();

    control.changeObject(ordinal, MODE_NORM, mAsset);

    }

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

  @Override

  protected void onDestroy()

    {

    DistortedLibrary.onDestroy();

    super.onDestroy();

    }

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

  public void onItemSelected(AdapterView<?> parent, View view, int pos, long id)

    {

    if( parent.getId()==R.id.solverSpinner && mCurrSolver!=pos )

      {

      mCurrSolver = pos;

      String[] phaseNames = createSolver();

      mLowerPane.updateNames(phaseNames);

      int ordinal = getObjectOrdinal();

      ObjectControl control = getControl();

      control.changeObject(ordinal, MODE_NORM, mAsset);

      resetTexts();

      }

    if( parent.getId()==R.id.solverMode && mCurrMode!=pos )

      {

      mCurrMode = pos;

      resetTexts();

      SolverSurfaceView sv = findViewById(R.id.solverView);

      sv.switchMode();

      }

    }

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

  public void onNothingSelected(AdapterView<?> parent) { }

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

  private String[] createSolverNames()

    {

    int num = PhasedSolverList.NUM_OBJECTS;

    String[] ret = new String[num];

    for(int s=0; s<num; s++) ret[s] = PhasedSolverList.getName(s);

    return ret;

    }

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

  private int getObjectOrdinal()

    {

    return PhasedSolverList.getPuzzleOrdinal(mCurrSolver);

    }

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

  private String[] createSolver()

    {

    mSolver = PhasedSolverList.create(mCurrSolver);

    if( mSolver!=null )

      {

      mObject = mSolver.getObject();

      int numPhases = mSolver.getNumPhases();

      String[] names = new String[numPhases];

      for(int p=0; p<numPhases; p++) names[p] = mSolver.getPhaseName(p);

      return names;

      }

    return new String[] {"NONE"};

    }

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

  public void Left(View v)       { mLowerPane.backMove(); }

  public void Right(View v)      { mLowerPane.nextMove(); }

  public void PhaseLeft(View v)  { mLowerPane.backPhase(); }

  public void PhaseRight(View v) { mLowerPane.nextPhase(); }

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

  ObjectControl getControl()

    {

    SolverSurfaceView view = findViewById(R.id.solverView);

    return view.getObjectControl();

    }

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

  private void savePreferences()

    {

    SharedPreferences.Editor editor = mPreferences.edit();

    SolverSurfaceView view = findViewById(R.id.solverView);

    OSInterface os = view.getInterface();

    os.setEditor(editor);

    view.getObjectControl().savePreferences();

    editor.apply();

    }

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

  private void restorePreferences()

    {

    SolverSurfaceView view = findViewById(R.id.solverView);

    OSInterface os = view.getInterface();

    os.setPreferences(mPreferences);

    view.getObjectControl().restorePreferences();

    }

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

  public void receiveSolution(int[] solution, int phase)

    {

    if( solution==null )

      {

      String message = "Phase "+phase+": FAIL";

      Toast.makeText(this,message,Toast.LENGTH_LONG).show();

      }

    else

      {

      int numMoves = solution[0];

      ObjectMove[] moves = new ObjectMove[numMoves];

      int index = 0;

      for(int m=1; m<=numMoves; m++)

        moves[index++] = mObject.findMove(solution[m]);

      mLowerPane.setSolution(moves, phase, mSolver.getSubPhases(phase));

      }

    long time = System.currentTimeMillis();

    long diff = time - mTime;

    mTime = time;

    System.out.println("Phase "+phase+" solved in "+diff+"ms. Moves: "+(solution==null ? 0:solution[0]));

    }

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

  public void Solve(View v)

    {

    TwistyObject object = getControl().getObject();

    int numCubits= object.getNumCubits();

    int[] qi = new int[numCubits];

    for(int i=0; i<numCubits; i++) qi[i] = object.getCubitQuatIndex(i);

    final SolutionListener listener = this;

    mTime = System.currentTimeMillis();

    runOnUiThread(new Runnable()

      {

      @Override public void run() { mSolver.solution(listener, qi); }

      });

    }

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

  private void resetTexts()

    {

    mText = "";

    mTextView.setText(mText);

    }

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

  public void Scramble(View v)

    {

    ObjectControl control = getControl();

    control.fastScrambleObject(20,1000);

    mLowerPane.clearMoves();

    resetTexts();

    }

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

  public void Reset(View v)

    {

    ObjectControl control = getControl();

    control.solveObject();

    mLowerPane.clearMoves();

    resetTexts();

    }

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

  void addSticker(int cubit, int face)

    {

    if( mCurrMode==1 )

      {

      mText += ("("+cubit+" "+face+") ");

      while( mText.length()>32 )

        {

        int space = mText.indexOf(')');

        mText = mText.substring(space+1);

        }

      runOnUiThread(new Runnable()

        {

        @Override public void run() { mTextView.setText(mText); }

        });

      }

    }

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

  void addMove(int axis, int rowBitmap, int degrees)

    {

    if( mCurrMode==0 )

      {

      int move = mObject.findMove(axis,rowBitmap,degrees);

      mText += (" " + move);

      while( mText.length()>28 )

        {

        int space = mText.indexOf(' ');

        mText = mText.substring(space+1);

        }

      runOnUiThread(new Runnable()

        {

        @Override public void run() { mTextView.setText(mText); }

        });

      }

    }

}