Magic Cube

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

// Copyright 2019 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.main;

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 com.google.firebase.crashlytics.FirebaseCrashlytics;

import org.distorted.library.main.DistortedScreen;

import org.distorted.library.message.EffectMessageSender;

import org.distorted.external.RubikNetwork;

import org.distorted.objectlib.BuildConfig;

import org.distorted.objectlib.helpers.BlockController;

import org.distorted.objectlib.helpers.ObjectLibInterface;

import org.distorted.objectlib.main.ObjectControl;

import org.distorted.dialogs.RubikDialogNewRecord;

import org.distorted.dialogs.RubikDialogSolved;

import org.distorted.external.RubikScores;

import org.distorted.objects.RubikObject;

import org.distorted.objects.RubikObjectList;

import org.distorted.overlays.DataStars;

import org.distorted.overlays.ListenerOverlay;

import org.distorted.overlays.OverlayStars;

import org.distorted.screens.RubikScreenPlay;

import org.distorted.screens.RubikScreenReady;

import org.distorted.screens.RubikScreenSolver;

import org.distorted.screens.RubikScreenSolving;

import org.distorted.screens.ScreenList;

import org.distorted.solvers.SolverMain;

import java.lang.ref.WeakReference;

import static org.distorted.external.RubikScores.RECORD_FIRST;

import static org.distorted.external.RubikScores.RECORD_NEW;

import static org.distorted.external.RubikScores.RECORD_NOT_NEW;

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

public class RubikObjectLibInterface implements ObjectLibInterface, ListenerOverlay

{

  private final WeakReference<RubikActivity> mAct;

  private int mIsNewRecord;

  private long mNewRecord;

  private int mLastCubitColor, mLastCubit, mLastCubitFace;

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

  RubikObjectLibInterface(RubikActivity act)

    {

    mAct = new WeakReference<>(act);

    mLastCubitColor = -1;

    }

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

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

    {

    long elapsed = System.currentTimeMillis() - timeBegin;

    String msg = message+" startTime: "+timeBegin+" elapsed: "+elapsed+" name: "+name;

    if( BuildConfig.DEBUG )

       {

       android.util.Log.d("libInterface", msg);

       }

    else

      {

      FirebaseAnalytics analytics = act.getAnalytics();

      if( analytics!=null )

        {

        Bundle bundle = new Bundle();

        bundle.putString(FirebaseAnalytics.Param.CONTENT_TYPE, msg);

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

        }

      }

    }

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

  private void reportRecord(RubikActivity act, long startTime, long endTime, String debug, int scrambleNum)

    {

    RubikScreenPlay play= (RubikScreenPlay) ScreenList.PLAY.getScreenClass();

    RubikScores scores  = RubikScores.getInstance();

    int object  = RubikObjectList.getCurrObject();

    int level   = play.getLevel();

    String name = scores.getName();

    RubikObject obj = RubikObjectList.getObject(object);

    String objName = obj==null ? "NULL" : obj.getUpperName();

    String record = objName+" level "+level+" time "+mNewRecord+" isNew: "+mIsNewRecord+" scrambleNum: "+scrambleNum;

    if( BuildConfig.DEBUG )

       {

       android.util.Log.e("libInterface", debug);

       android.util.Log.e("libInterface", name);

       android.util.Log.e("libInterface", record);

       }

    else

      {

      if( level>=9 && mNewRecord<300*level )

        {

        long timeNow = System.currentTimeMillis();

        long elapsed = timeNow - startTime;

        String suspicious ="start"+startTime+"end"+endTime+"elapsed"+elapsed+"obj"+objName+"level"+level+"record"+mNewRecord+"scrambles"+scrambleNum+debug;

        RubikNetwork network = RubikNetwork.getInstance();

        network.suspicious(suspicious,act);

        }

      FirebaseAnalytics analytics = act.getAnalytics();

      if( analytics!=null )

        {

        Bundle bundle = new Bundle();

        bundle.putString(FirebaseAnalytics.Param.CONTENT_TYPE, debug);

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

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

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

        }

      }

    }

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

  private void requestReview(RubikActivity act)

    {

    final RubikScores scores = RubikScores.getInstance();

    int numWins = scores.incrementNumWins();

    int numRuns = scores.getNumRuns();

    if( numRuns==3 || numRuns==6 || numWins==7 || numWins==30 || numWins==50 || numWins==80 || numWins==100)

      {

      final long timeBegin = System.currentTimeMillis();

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

            ReviewInfo reviewInfo = task.getResult();

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

            flow.addOnFailureListener(new OnFailureListener()

              {

              @Override

              public void onFailure(Exception e)

                {

                analyticsReport(act,"Failed", name, timeBegin);

                }

              });

            flow.addOnCompleteListener(new OnCompleteListener<Void>()

              {

              @Override

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

                {

                analyticsReport(act,"Complete", name, timeBegin);

                }

              });

            }

          else

            {

            String name = scores.getName();

            analyticsReport(act,"Not Successful", name, timeBegin);

            }

          }

        });

      }

    }

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

  public void onScrambleEffectFinished()

    {

    RubikScreenPlay play = (RubikScreenPlay) ScreenList.PLAY.getScreenClass();

    if( play.shouldReactToEndOfScrambling() )

      {

      RubikActivity act = mAct.get();

      RubikScores.getInstance().incrementNumPlays();

      act.runOnUiThread(new Runnable()

        {

        @Override

        public void run()

        {

        ScreenList.switchScreen( act, ScreenList.READ);

        }

        });

      }

    }

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

  public void onFinishRotation(int axis, int row, int angle)

    {

    if( ScreenList.getCurrentScreen()== ScreenList.SOLV )

      {

      RubikScreenSolving solv = (RubikScreenSolving) ScreenList.SOLV.getScreenClass();

      solv.addMove(mAct.get(), axis, row, angle);

      }

    if( ScreenList.getCurrentScreen()== ScreenList.PLAY )

      {

      RubikScreenPlay play = (RubikScreenPlay) ScreenList.PLAY.getScreenClass();

      play.addMove(mAct.get(), axis, row, angle);

      }

    }

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

  public void onBeginRotation()

    {

    if( ScreenList.getCurrentScreen()== ScreenList.READ )

      {

      RubikScreenSolving solving = (RubikScreenSolving) ScreenList.SOLV.getScreenClass();

      solving.resetElapsed();

      RubikActivity act = mAct.get();

      act.runOnUiThread(new Runnable()

        {

        @Override

        public void run()

          {

          ScreenList.switchScreen( act, ScreenList.SOLV);

          }

        });

      }

    }

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

  public void failedToDrag()

    {

    ScreenList curr = ScreenList.getCurrentScreen();

    if( curr==ScreenList.PLAY )

      {

      RubikScreenPlay play = (RubikScreenPlay) ScreenList.PLAY.getScreenClass();

      play.reddenLock(mAct.get());

      }

    else if( curr==ScreenList.READ )

      {

      RubikScreenReady read = (RubikScreenReady) ScreenList.READ.getScreenClass();

      read.reddenLock(mAct.get());

      }

    else if( curr==ScreenList.SOLV )

      {

      RubikScreenSolving solv = (RubikScreenSolving) ScreenList.SOLV.getScreenClass();

      solv.reddenLock(mAct.get());

      }

    }

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

  public void onSolved()

    {

    if( ScreenList.getCurrentScreen()== ScreenList.SOLV )

      {

      RubikScreenSolving solving = (RubikScreenSolving) ScreenList.SOLV.getScreenClass();

      mNewRecord = solving.stopTimerAndGetRecord();

      mIsNewRecord = solving.setRecord();

      }

    }

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

  public void onObjectCreated(long time)

    {

    }

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

  public void reportProblem(String problem, boolean recordException)

    {

    if( BuildConfig.DEBUG )

      {

      android.util.Log.e("libInterface", problem);

      }

    else

      {

      if( recordException )

        {

        Exception ex = new Exception(problem);

        FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

        crashlytics.setCustomKey("problem" , problem);

        crashlytics.recordException(ex);

        }

      else

        {

        FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

        crashlytics.log(problem);

        }

      }

    }

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

  private void reportUIProblem(int place, long pause, long resume, long time)

    {

    String error = "UI BLOCK "+place+" blocked for "+time;

    if( BuildConfig.DEBUG )

       {

       android.util.Log.e("libInterface", error);

       }

    else

      {

      Exception ex = new Exception(error);

      FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

      crashlytics.setCustomKey("pause" , pause );

      crashlytics.setCustomKey("resume", resume );

      crashlytics.recordException(ex);

      }

    }

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

  private void reportTouchProblem(int place, long pause, long resume, long time)

    {

    String error = "TOUCH BLOCK "+place+" blocked for "+time;

    if( BuildConfig.DEBUG )

       {

       android.util.Log.e("libInterface", error);

       }

    else

      {

      Exception ex = new Exception(error);

      FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

      crashlytics.setCustomKey("pause" , pause );

      crashlytics.setCustomKey("resume", resume);

      crashlytics.recordException(ex);

      }

    }

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

  private void reportThreadProblem(int place, long pause, long resume, long time)

    {

    String error = EffectMessageSender.reportState();

    if( BuildConfig.DEBUG )

       {

       android.util.Log.e("libInterface", error);

       }

    else

      {

      Exception ex = new Exception(error);

      FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

      crashlytics.setCustomKey("pause" , pause  );

      crashlytics.setCustomKey("resume", resume );

      crashlytics.recordException(ex);

      }

    }

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

  public void reportBlockProblem(int type, int place, long pause, long resume, long time)

    {

    switch(type)

      {

      case BlockController.TYPE_UI    : reportUIProblem(place,pause,resume,time); break;

      case BlockController.TYPE_TOUCH : reportTouchProblem(place,pause,resume,time); break;

      case BlockController.TYPE_THREAD: reportThreadProblem(place,pause,resume,time); break;

      }

    }

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

  public void reportJSONError(String error, int ordinal)

    {

    RubikObject object = RubikObjectList.getObject(ordinal);

    String name = object==null ? "NULL" : object.getUpperName();

    if( BuildConfig.DEBUG )

       {

       android.util.Log.e("libInterface", "name="+name+" JSON error: "+error);

       }

    else

      {

      Exception ex = new Exception(error);

      FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

      crashlytics.setCustomKey("name" , name );

      crashlytics.setCustomKey("JSONerror", error );

      crashlytics.recordException(ex);

      }

    }

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

  public void onReplaceModeDown(int cubit, int face)

    {

    RubikScreenSolver solver = (RubikScreenSolver) ScreenList.SVER.getScreenClass();

    int color = solver.getCurrentColor();

    int currObject = RubikObjectList.getCurrObject();

    mLastCubitColor = SolverMain.cubitIsLocked(currObject,cubit);

    mLastCubit = cubit;

    mLastCubitFace = face;

    ObjectControl control = mAct.get().getControl();

    control.setTextureMap( cubit, face, color );

    }

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

  public void onReplaceModeUp()

    {

    if( mLastCubitColor>=0 )

      {

      ObjectControl control = mAct.get().getControl();

      control.setTextureMap( mLastCubit, mLastCubitFace, mLastCubitColor );

      mLastCubitColor = -1;

      }

    }

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

  public void onWinEffectFinished(long startTime, long endTime, String debug, int scrambleNum)

    {

    if( ScreenList.getCurrentScreen()== ScreenList.SOLV )

      {

      RubikActivity act = mAct.get();

      Bundle bundle = new Bundle();

      bundle.putLong("time", mNewRecord );

      reportRecord(act,startTime,endTime,debug,scrambleNum);

      requestReview(act);

      switch(mIsNewRecord)

        {

        case RECORD_FIRST  : /*

                             // temporarily switch off the 'stars' animation

                             RubikScreenPlay play = (RubikScreenPlay) ScreenList.PLAY.getScreenClass();

                             int level = play.getLevel();

                             RubikScores scores = RubikScores.getInstance();

                             int totStars = scores.getNumStars();

                             int newStars = RubikObjectList.computeNumStars(level);

                             DistortedScreen screen = act.getScreen();

                             OverlayStars stars = new OverlayStars();

                             DataStars data  = new DataStars(totStars,newStars,act.getResources());

                             stars.startOverlay(screen,this,data);

                             break;

                             */

        case RECORD_NEW    : RubikDialogNewRecord d2 = new RubikDialogNewRecord();

                             d2.setArguments(bundle);

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

                             break;

        case RECORD_NOT_NEW: RubikDialogSolved d3 = new RubikDialogSolved();

                             d3.setArguments(bundle);

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

                             break;

        }

      act.runOnUiThread(new Runnable()

        {

        @Override

        public void run()

          {

          ScreenList.switchScreen( act, ScreenList.DONE);

          }

        });

      }

    }

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

  public void overlayFinished(long id)

    {

    RubikActivity act = mAct.get();

    Bundle bundle = new Bundle();

    bundle.putLong("time", mNewRecord );

    RubikDialogNewRecord d2 = new RubikDialogNewRecord();

    d2.setArguments(bundle);

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

    }

}