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.algsolvers.*;

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

import org.distorted.objectlib.algsolvers.implemented.SolverAbstract;

import org.distorted.objectlib.main.InitAssets;

import org.distorted.objectlib.main.ObjectControl;

import org.distorted.objectlib.main.TwistyObject;

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

  private SolvedObject mObject;

  private String mMoves;

  private int mNumMoves;

  private int mCurrSolver;

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

    mText = findViewById(R.id.solverMoves);

    mMoves = "";

    mNumMoves = 0;

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

    objectSpinner.setOnItemSelectedListener(this);

    mCurrSolver = 0;

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

    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(this,phaseNames);

      int ordinal = getObjectOrdinal();

      ObjectControl control = getControl();

      control.changeObject(ordinal, MODE_NORM, mAsset);

      }

    }

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

    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(this); }

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

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

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

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

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

      int[][] moves = new int[numMoves][];

      int index = 0;

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

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

      mLowerPane.setSolution(this, 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 = 26;

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

        }

      });

    }

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

  public void Scramble(View v)

    {

    ObjectControl control = getControl();

    control.fastScrambleObject(1000,20);

    mLowerPane.clearMoves(this);

    mNumMoves = 0;

    mMoves = "";

    mText.setText(mMoves);

    }

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

  public void Reset(View v)

    {

    ObjectControl control = getControl();

    control.solveObject();

    mLowerPane.clearMoves(this);

    mNumMoves = 0;

    mMoves = "";

    mText.setText(mMoves);

    }

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

  void addMove(int axis, int row, int angle)

    {

    int move = mObject.findMove(axis,row,angle);

    mMoves += (" "+move);

    mNumMoves++;

    if( mNumMoves>10 )

      {

      int space = mMoves.indexOf(' ');

      mMoves = mMoves.substring(space+1);

      mNumMoves--;

      }

    runOnUiThread(new Runnable()

      {

      @Override

      public void run() { mText.setText(mMoves); }

      });

    }

}