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.res.Resources;

import org.distorted.objectlib.algsolvers.SolutionListener;

import org.distorted.objectlib.algsolvers.SolvedObject;

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

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

import org.distorted.objectlib.helpers.OperatingSystemInterface;

import org.distorted.objectlib.main.TwistyObject;

import org.distorted.solverui.ScreenList;

import org.distorted.solverui.ScreenPhasedSolution;

import org.distorted.solverui.ScreenSolver;

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

public abstract class SolverAlgorithmic implements SolvingInterface, SolutionListener

{

  private final SolvedObject mSolvedObject;

  private final PhasedSolverAbstract mSolver;

  private final OperatingSystemInterface mOS;

  private final Resources mRes;

  private final TwistyObject mObject;

  private long mTime;

  private ScreenSolver mScreen;

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

// PUBLIC API

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

  public SolverAlgorithmic(OperatingSystemInterface os, Resources res, TwistyObject object)

    {

    mOS     = os;

    mRes    = res;

    mObject = object;

    mSolver = new PhasedSolver3x3Beginner();

    mSolvedObject = mSolver.getObject();

    }

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

  abstract int[] validatePosition(TwistyObject object);

  abstract String getError(Resources res);

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

  public void solve(ScreenSolver screen)

    {

    mScreen = screen;

    int[] quats = validatePosition(mObject);

    if( quats!=null )

      {

      int numPhases = mSolver.getNumPhases();

      String[] names = new String[numPhases];

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

      ScreenPhasedSolution solScreen = (ScreenPhasedSolution) ScreenList.PHAS.getScreenClass();

      solScreen.updateNames(names);

      mTime = System.currentTimeMillis();

      mSolver.solution(this,quats);

      }

    else

      {

      String error = getError(mRes);

      screen.displayImpossibleDialog(error);

      }

    }

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

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

    {

    if( solution==null )

      {

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

      System.out.println(message);

      }

    else

      {

      int numMoves = solution[0];

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

      int index = 0;

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

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

      int[][] subphases = mSolver.getSubPhases(phaseNumber);

      mScreen.setSolved(moves,phaseNumber,subphases);

      }

    long time = System.currentTimeMillis();

    long diff = time - mTime;

    mTime = time;

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

    }

}