Magic Cube

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

// Copyright 2020 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Magic Cube.                                                              //

//                                                                                               //

// Magic Cube 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.                                                           //

//                                                                                               //

// Magic Cube 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 Magic Cube.  If not, see <http://www.gnu.org/licenses/>.                           //

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

package org.distorted.main;

import android.content.Context;

import android.content.SharedPreferences;

import android.content.res.Resources;

import android.os.Bundle;

import androidx.annotation.NonNull;

import com.google.android.play.core.review.ReviewInfo;

import com.google.android.play.core.review.ReviewManager;

import com.google.android.play.core.review.ReviewManagerFactory;

import com.google.android.play.core.tasks.OnCompleteListener;

import com.google.android.play.core.tasks.OnFailureListener;

import com.google.android.play.core.tasks.Task;

import com.google.firebase.analytics.FirebaseAnalytics;

import org.distorted.dialogs.RubikDialogNewRecord;

import org.distorted.dialogs.RubikDialogSolved;

import org.distorted.effects.BaseEffect;

import org.distorted.library.message.EffectListener;

import org.distorted.objects.TwistyObject;

import org.distorted.objects.ObjectList;

import org.distorted.scores.RubikScores;

import org.distorted.states.RubikStatePlay;

import org.distorted.states.StateList;

import org.distorted.states.RubikStateSolving;

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

public class RubikPreRender implements EffectListener

  {

  public interface ActionFinishedListener

    {

    void onActionFinished(long effectID);

    }

  private RubikSurfaceView mView;

  private boolean mFinishRotation, mRemoveRotation, mRemovePatternRotation, mAddRotation,

                  mSetQuat, mChangeObject, mSetupObject, mSolveObject, mScrambleObject,

                  mInitializeObject, mSetTextureMap, mResetAllTextureMaps;

  private boolean mCanRotate, mCanPlay;

  private boolean mIsSolved;

  private ObjectList mNextObject;

  private int mNextSize;

  private long mRotationFinishedID;

  private long[] mEffectID;

  private boolean mIsNewRecord;

  private long mNewRecord;

  private int mScreenWidth;

  private SharedPreferences mPreferences;

  private int[][] mNextMoves;

  private TwistyObject mOldObject, mNewObject;

  private int mScrambleObjectNum;

  private int mAddRotationAxis, mAddRotationRowBitmap, mAddRotationAngle;

  private long mAddRotationDuration;

  private ActionFinishedListener mAddActionListener;

  private long mAddRotationID, mRemoveRotationID;

  private int mCubit, mFace, mNewColor;

  private int mNearestAngle;

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

  RubikPreRender(RubikSurfaceView view)

    {

    mView = view;

    mFinishRotation       = false;

    mRemoveRotation       = false;

    mRemovePatternRotation= false;

    mAddRotation          = false;

    mSetQuat              = false;

    mChangeObject         = false;

    mSetupObject          = false;

    mSolveObject          = false;

    mScrambleObject       = false;

    mCanRotate = true;

    mCanPlay   = true;

    mOldObject = null;

    mNewObject = null;

    mScreenWidth = 0;

    mScrambleObjectNum = 0;

    mEffectID = new long[BaseEffect.Type.LENGTH];

    }

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

  private void createObjectNow(ObjectList object, int size, int[][] moves)

    {

    boolean firstTime = (mNewObject==null);

    if( mOldObject!=null ) mOldObject.releaseResources();

    mOldObject = mNewObject;

    Context con = mView.getContext();

    Resources res = con.getResources();

    mNewObject = object.create(size, mView.getQuat(), moves, res, mScreenWidth);

    if( mNewObject!=null )

      {

      mNewObject.createTexture();

      mView.setMovement(object.getObjectMovementClass());

      if( firstTime ) mNewObject.restorePreferences(mPreferences);

      if( mScreenWidth!=0 )

        {

        mNewObject.recomputeScaleFactor(mScreenWidth);

        }

      mIsSolved = mNewObject.isSolved();

      }

    }

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

// do all 'adjustable' effects (SizeChange, Solve, Scramble)

  private void doEffectNow(BaseEffect.Type type)

    {

    int index = type.ordinal();

    try

      {

      mEffectID[index] = type.startEffect(mView.getRenderer().getScreen(),this);

      }

    catch( Exception ex )

      {

      android.util.Log.e("renderer", "exception starting effect: "+ex.getMessage());

      mCanPlay   = true;

      mCanRotate = true;

      }

    }

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

  private void removeRotationNow()

    {

    mRemoveRotation=false;

    mNewObject.removeRotationNow();

    boolean solved = mNewObject.isSolved();

    if( solved && !mIsSolved )

      {

      if( StateList.getCurrentState()== StateList.SOLV )

        {

        RubikStateSolving solving = (RubikStateSolving) StateList.SOLV.getStateClass();

        mNewRecord = solving.getRecord();

        if( mNewRecord< 0 )

          {

          mNewRecord = -mNewRecord;

          mIsNewRecord = false;

          }

        else

          {

          mIsNewRecord = true;

          }

        }

      mCanRotate = true;

      mCanPlay = false;

      doEffectNow( BaseEffect.Type.WIN );

      }

    else

      {

      mCanRotate = true;

      mCanPlay = true;

      }

    mIsSolved = solved;

    }

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

  private void removeRotation()

    {

    mRemoveRotation = true;

    }

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

  private void removePatternRotation()

    {

    mRemovePatternRotation = true;

    }

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

  private void removePatternRotationNow()

    {

    mRemovePatternRotation=false;

    mNewObject.removeRotationNow();

    mAddActionListener.onActionFinished(mRemoveRotationID);

    }

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

  private void addRotationNow()

    {

    mAddRotation = false;

    mAddRotationID = mNewObject.addNewRotation( mAddRotationAxis, mAddRotationRowBitmap,

                                                mAddRotationAngle, mAddRotationDuration, this);

    }

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

  private void finishRotationNow()

    {

    mFinishRotation = false;

    mCanRotate      = false;

    mCanPlay        = false;

    mRotationFinishedID = mNewObject.finishRotationNow(this, mNearestAngle);

    if( mRotationFinishedID==0 ) // failed to add effect - should never happen

      {

      mCanRotate = true;

      mCanPlay   = true;

      }

    }

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

  private void changeObjectNow()

    {

    mChangeObject = false;

    if ( mNewObject==null || mNewObject.getObjectList()!=mNextObject || mNewObject.getSize()!=mNextSize)

      {

      mCanRotate= false;

      mCanPlay  = false;

      createObjectNow(mNextObject, mNextSize, null);

      doEffectNow( BaseEffect.Type.SIZECHANGE );

      }

    }

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

  private void setupObjectNow()

    {

    mSetupObject = false;

    if ( mNewObject==null || mNewObject.getObjectList()!=mNextObject || mNewObject.getSize()!=mNextSize)

      {

      mCanRotate= false;

      mCanPlay  = false;

      createObjectNow(mNextObject, mNextSize, mNextMoves);

      doEffectNow( BaseEffect.Type.SIZECHANGE );

      }

    else

      {

      mNewObject.initializeObject(mNextMoves);

      }

    }

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

  private void scrambleObjectNow()

    {

    mScrambleObject = false;

    mCanRotate      = false;

    mCanPlay        = false;

    mIsSolved       = false;

    RubikScores.getInstance().incrementNumPlays();

    doEffectNow( BaseEffect.Type.SCRAMBLE );

    }

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

  private void solveObjectNow()

    {

    mSolveObject = false;

    mCanRotate   = false;

    mCanPlay     = false;

    doEffectNow( BaseEffect.Type.SOLVE );

    }

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

  private void initializeObjectNow()

    {

    mInitializeObject = false;

    mNewObject.initializeObject(mNextMoves);

    }

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

  private void setTextureMapNow()

    {

    mSetTextureMap = false;

    if( mNewObject!=null ) mNewObject.setTextureMap(mCubit,mFace,mNewColor);

    }

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

  private void resetAllTextureMapsNow()

    {

    mResetAllTextureMaps = false;

    if( mNewObject!=null ) mNewObject.resetAllTextureMaps();

    }

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

  private void setQuatNow()

    {

    mSetQuat = false;

    mView.setQuat();

    }

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

  private void reportRecord()

    {

    RubikStatePlay play = (RubikStatePlay) StateList.PLAY.getStateClass();

    RubikScores scores = RubikScores.getInstance();

    int object      = play.getObject();

    int size        = play.getSize();

    int level       = play.getLevel();

    ObjectList list = ObjectList.getObject(object);

    String name     = scores.getName();

    String record = list.name()+"_"+size+" level "+level+" time "+mNewRecord+" isNew: "+mIsNewRecord+" name: "+name;

    final RubikActivity act = (RubikActivity)mView.getContext();

    FirebaseAnalytics analytics = act.getAnalytics();

    if( analytics!=null )

      {

      Bundle bundle = new Bundle();

      bundle.putString(FirebaseAnalytics.Param.LEVEL, record);

      analytics.logEvent(FirebaseAnalytics.Event.LEVEL_END, bundle);

      }

    }

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

  private void requestReview()

    {

    final RubikScores scores = RubikScores.getInstance();

    int numRuns   = scores.getNumRuns();

    int numPlay   = scores.getNumPlays();

    int numReview = scores.getNumReviews();

    if( numRuns>=2 && numPlay>6 && numReview<1 )

      {

      final RubikActivity act = (RubikActivity)mView.getContext();

      final ReviewManager manager = ReviewManagerFactory.create(act);

      Task<ReviewInfo> request = manager.requestReviewFlow();

      request.addOnCompleteListener(new OnCompleteListener<ReviewInfo>()

        {

        @Override

        public void onComplete (@NonNull Task<ReviewInfo> task)

          {

          if (task.isSuccessful())

            {

            final String name = scores.getName();

            scores.incrementNumReviews();

            ReviewInfo reviewInfo = task.getResult();

            Task<Void> flow = manager.launchReviewFlow(act, reviewInfo);

            flow.addOnFailureListener(new OnFailureListener()

              {

              @Override

              public void onFailure(Exception e)

                {

                analyticsReport(act,"Review Flow Failed", name);

                }

              });

            flow.addOnCompleteListener(new OnCompleteListener<Void>()

              {

              @Override

              public void onComplete(@NonNull Task<Void> task)

                {

                analyticsReport(act,"Review Flow Complete", name);

                }

              });

            }

          else

            {

            String name = scores.getName();

            analyticsReport(act,"Request review flow not successful", name);

            }

          }

        });

      }

    }

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

  private void analyticsReport(RubikActivity act, String message, String name)

    {

    if( BuildConfig.DEBUG )

       {

       android.util.Log.d("pre", message);

       android.util.Log.d("pre", name);

       }

    else

      {

      FirebaseAnalytics analytics = act.getAnalytics();

      if( analytics!=null )

        {

        Bundle bundle = new Bundle();

        bundle.putString(FirebaseAnalytics.Param.ITEM_NAME, message);

        bundle.putString(FirebaseAnalytics.Param.CHARACTER, name);

        analytics.logEvent(FirebaseAnalytics.Event.CAMPAIGN_DETAILS, bundle);

        }

      }

    }

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

//

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

  void setScreenSize(int width)

    {

    if( mNewObject!=null )

      {

      mNewObject.createTexture();

      mNewObject.recomputeScaleFactor(width);

      }

    mScreenWidth  = width;

    }

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

  void savePreferences(SharedPreferences.Editor editor)

    {

    if( mNewObject!=null )

      {

      mNewObject.savePreferences(editor);

      }

    }

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

  void restorePreferences(SharedPreferences preferences)

    {

    mPreferences = preferences;

    }

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

  void finishRotation(int nearestAngle)

    {

    mNearestAngle   = nearestAngle;

    mFinishRotation = true;

    }

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

  void changeObject(ObjectList object, int size)

    {

    if( size>0 )

      {

      mChangeObject = true;

      mNextObject = object;

      mNextSize   = size;

      }

    }

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

  void setupObject(ObjectList object, int size, int[][] moves)

    {

    if( size>0 )

      {

      mSetupObject= true;

      mNextObject = object;

      mNextSize   = size;

      mNextMoves  = moves;

      }

    }

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

  void setTextureMap(int cubit, int face, int newColor)

    {

    mSetTextureMap = true;

    mCubit    = cubit;

    mFace     = face;

    mNewColor = newColor;

    }

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

  boolean canRotate()

    {

    return mCanRotate;

    }

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

  public boolean canPlay()

    {

    return mCanPlay;

    }

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

  void setQuatOnNextRender()

    {

    mSetQuat = true;

    }

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

  void preRender()

    {

    if( mSetQuat               ) setQuatNow();

    if( mFinishRotation        ) finishRotationNow();

    if( mRemoveRotation        ) removeRotationNow();

    if( mRemovePatternRotation ) removePatternRotationNow();

    if( mChangeObject          ) changeObjectNow();

    if( mSetupObject           ) setupObjectNow();

    if( mSolveObject           ) solveObjectNow();

    if( mScrambleObject        ) scrambleObjectNow();

    if( mAddRotation           ) addRotationNow();

    if( mInitializeObject      ) initializeObjectNow();

    if( mResetAllTextureMaps   ) resetAllTextureMapsNow();

    if( mSetTextureMap         ) setTextureMapNow();

    }

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

// PUBLIC API

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

  public void addRotation(ActionFinishedListener listener, int axis, int rowBitmap, int angle, long duration)

    {

    mAddRotation = true;

    mAddActionListener    = listener;

    mAddRotationAxis      = axis;

    mAddRotationRowBitmap = rowBitmap;

    mAddRotationAngle     = angle;

    mAddRotationDuration  = duration;

    }

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

  public void initializeObject(int[][] moves)

    {

    mInitializeObject = true;

    mNextMoves = moves;

    }

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

  public void scrambleObject(int num)

    {

    if( mCanPlay )

      {

      mScrambleObject = true;

      mScrambleObjectNum = num;

      }

    }

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

  public void solveObject()

    {

    if( mCanPlay )

      {

      mSolveObject = true;

      }

    }

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

  public void resetAllTextureMaps()

    {

    mResetAllTextureMaps = true;

    }

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

  public TwistyObject getObject()

    {

    return mNewObject;

    }

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

  public TwistyObject getOldObject()

    {

    return mOldObject;

    }

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

  public int getNumScrambles()

    {

    return mScrambleObjectNum;

    }

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

  public void effectFinished(final long effectID)

    {

    if( effectID == mRotationFinishedID )

      {

      mRotationFinishedID = 0;

      removeRotation();

      }

    else if( effectID == mAddRotationID )

      {

      mAddRotationID = 0;

      mRemoveRotationID = effectID;

      removePatternRotation();

      }

    else

      {

      for(int i=0; i<BaseEffect.Type.LENGTH; i++)

        {

        if( effectID == mEffectID[i] )

          {

          mCanRotate = true;

          mCanPlay   = true;

          if( i==BaseEffect.Type.SCRAMBLE.ordinal() )

            {

            final RubikActivity act = (RubikActivity)mView.getContext();

            act.runOnUiThread(new Runnable()

              {

              @Override

              public void run()

                {

                StateList.switchState( act, StateList.READ);

                }

              });

            }

          if( i==BaseEffect.Type.WIN.ordinal() )

            {

            if( StateList.getCurrentState()== StateList.SOLV )

              {

              final RubikActivity act = (RubikActivity)mView.getContext();

              Bundle bundle = new Bundle();

              bundle.putLong("time", mNewRecord );

              reportRecord();

              requestReview();

              if( mIsNewRecord )

                {

                RubikDialogNewRecord dialog = new RubikDialogNewRecord();

                dialog.setArguments(bundle);

                dialog.show( act.getSupportFragmentManager(), RubikDialogNewRecord.getDialogTag() );

                }

              else

                {

                RubikDialogSolved dialog = new RubikDialogSolved();

                dialog.setArguments(bundle);

                dialog.show( act.getSupportFragmentManager(), RubikDialogSolved.getDialogTag() );

                }

              act.runOnUiThread(new Runnable()

                {

                @Override

                public void run()

                  {

                  StateList.switchState( act, StateList.DONE);

                  }

                });

              }

            }

          break;

          }

        }

      }

    }

  }