Magic Cube

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

// Copyright 2019 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// Distorted is free software: you can redistribute it and/or modify                             //

// it under the terms of the GNU General Public License as published by                          //

// the Free Software Foundation, either version 2 of the License, or                             //

// (at your option) any later version.                                                           //

//                                                                                               //

// Distorted is distributed in the hope that it will be useful,                                  //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //

// GNU General Public License for more details.                                                  //

//                                                                                               //

// You should have received a copy of the GNU General Public License                             //

// along with Distorted.  If not, see <http://www.gnu.org/licenses/>.                            //

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

package org.distorted.effect.solve;

import org.distorted.effect.BaseEffect;

import org.distorted.library.effect.Effect;

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.main.DistortedScreen;

import org.distorted.library.message.EffectListener;

import org.distorted.magic.RubikCube;

import org.distorted.magic.RubikRenderer;

import java.lang.reflect.Method;

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

public abstract class SolveEffect extends BaseEffect implements EffectListener

{

  public enum Type

    {

    NONE   (SolveEffectNone.class),

    SPIN   (SolveEffectSpin.class),

    ;

    final Class<? extends SolveEffect> effect;

    Type(Class<? extends SolveEffect> effect)

      {

      this.effect = effect;

      }

    }

  private static final int NUM_EFFECTS = Type.values().length;

  private static final int NUM_PHASES  = 2;

  private static final int FAKE_EFFECT_ID = -2;

  private static final Type[] types;

  static

    {

    int i=0;

    types = new Type[NUM_EFFECTS];

    for(Type type: Type.values())

      {

      types[i++] = type;

      }

    }

  private EffectListener mListener;

  private int mDuration;

  private int mEffectReturned;

  private int[] mCubeEffectNumber, mNodeEffectNumber;

  private int mPhase;

  RubikCube mCube;

  DistortedScreen mScreen;

  Effect[][] mCubeEffects;

  int[][] mCubeEffectPosition;

  Effect[][] mNodeEffects;

  int[][] mNodeEffectPosition;

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

  SolveEffect()

    {

    mPhase        =  0;

    mCubeEffectNumber   = new int[NUM_PHASES];

    mNodeEffectNumber   = new int[NUM_PHASES];

    mCubeEffectPosition = new int[NUM_PHASES][];

    mNodeEffectPosition = new int[NUM_PHASES][];

    mCubeEffects        = new Effect[NUM_PHASES][];

    mNodeEffects        = new Effect[NUM_PHASES][];

    }

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

  public static String[] getNames()

    {

    String[] names = new String[NUM_EFFECTS];

    for( int i=0; i<NUM_EFFECTS; i++)

      {

      names[i] = types[i].name();

      }

    return names;

    }

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

  public static SolveEffect create(int ordinal) throws InstantiationException, IllegalAccessException

    {

    return types[ordinal].effect.newInstance();

    }

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

  abstract void createEffectsPhase0(int duration);

  abstract void createEffectsPhase1(int duration);

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

  public void effectFinished(final long effectID)

    {

    int total = mCubeEffectNumber[mPhase]+mNodeEffectNumber[mPhase];

    for(int i=0; i<mCubeEffectNumber[mPhase]; i++)

      {

      long id = mCubeEffects[mPhase][i].getID();

      if( effectID == id )

        {

        if( ++mEffectReturned == total ) effectAction(mPhase);

        mCube.remove(id);

        return;

        }

      }

    for(int i=0; i<mNodeEffectNumber[mPhase]; i++)

      {

      long id = mNodeEffects[mPhase][i].getID();

      if( effectID == id )

        {

        if( ++mEffectReturned == total ) effectAction(mPhase);

        mCube.getEffects().abortById(id);

        return;

        }

      }

    }

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

  private void effectAction(int phase)

    {

    switch(phase)

      {

      case 0: mEffectReturned = 0;

              mPhase          = 1;

              mCube.solve();

              createEffectsPhase1(mDuration);

              assignEffects(mPhase);

              break;

      case 1: mListener.effectFinished(FAKE_EFFECT_ID);

              break;

      }

    }

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

  public long start(int duration, RubikRenderer renderer)

    {

    mScreen   = renderer.getScreen();

    mCube     = renderer.getCube();

    mListener = renderer;

    mDuration = duration;

    createEffectsPhase0(mDuration);

    assignEffects(mPhase);

    return FAKE_EFFECT_ID;

    }

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

  private void assignEffects(int phase)

    {

    mCubeEffectNumber[phase] = ( mCubeEffects[phase]!=null ) ? mCubeEffects[phase].length : 0;

    mNodeEffectNumber[phase] = ( mNodeEffects[phase]!=null ) ? mNodeEffects[phase].length : 0;

    if( mCubeEffectNumber[phase]==0 && mNodeEffectNumber[phase]==0 )

      {

      throw new RuntimeException("Cube and Node Effects ("+phase+" phase) both not created!");

      }

    for(int i=0; i<mCubeEffectNumber[phase]; i++)

      {

      mCube.apply(mCubeEffects[phase][i],mCubeEffectPosition[phase][i]);

      mCubeEffects[phase][i].notifyWhenFinished(this);

      }

    DistortedEffects nodeEffects = mCube.getEffects();

    for(int i=0; i<mNodeEffectNumber[phase]; i++)

      {

      nodeEffects.apply(mNodeEffects[phase][i],mNodeEffectPosition[phase][i]);

      mNodeEffects[phase][i].notifyWhenFinished(this);

      }

    }

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

  @SuppressWarnings("unused")

  public static void enableEffects()

    {

    Method method;

    for(Type type: Type.values())

      {

      try

        {

        method = type.effect.getDeclaredMethod("enable"); // enable not public, thus getDeclaredMethod

        }

      catch(NoSuchMethodException ex)

        {

        android.util.Log.e("SolveEffect", type.effect.getSimpleName()+": exception getting method: "+ex.getMessage());

        method = null;

        }

      try

        {

        if( method!=null ) method.invoke(null);

        }

      catch(Exception ex)

        {

        android.util.Log.e("SolveEffect", type.effect.getSimpleName()+": exception invoking method: "+ex.getMessage());

        }

      }

    }

}