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

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.dialogs.RubikDialogScoresView;

import org.distorted.library.main.DistortedScreen;

import org.distorted.library.message.EffectMessageSender;

import org.distorted.external.RubikNetwork;

import org.distorted.main.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 int mNewRecord;

  private int mLastCubitColor, mLastCubit, mLastCubitFace;

  private boolean mReviewAsked;

  private int mNumRotations, mNumScrambles;

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

  RubikObjectLibInterface(RubikActivity act)

    {

    mAct = new WeakReference<>(act);

    mLastCubitColor = -1;

    mReviewAsked = false;

    mNumRotations = 0;

    mNumScrambles = 0;

    }

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

  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 Bundle createDialogBundle()

    {

    Bundle bundle = new Bundle();

    String arg = RubikDialogScoresView.formatRecord(mNewRecord);

    bundle.putString("argument", arg );

    return bundle;

    }

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

  private void requestReview(RubikActivity act)

    {

    android.util.Log.e("D", "ASKING FOR REVIEW");

    mReviewAsked = true;

    final String name = RubikScores.getInstance().getName();

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

          {

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

          ObjectControl control = act.getControl();

          control.unblockEverything();

          }

        });

      }

    else

      {

      mNumScrambles++;

      if( mNumScrambles==10 && !mReviewAsked )

        {

        RubikActivity act = mAct.get();

        requestReview(act);

        }

      }

    }

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

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

    {

    mNumRotations++;

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

      }

    if( mNumRotations==40 && !mReviewAsked )

      {

      RubikActivity act = mAct.get();

      requestReview(act);

      }

    }

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

  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 reportScramblingProblem(int place, long pause, long resume, long time)

    {

    String error = "SCRAMBLING 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 reportRotationProblem(int place, long pause, long resume, long time)

    {

    String error = "ROTATION 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_SCRAMBLING: reportScramblingProblem(place,pause,resume,time); break;

      case BlockController.TYPE_ROTATION  : reportRotationProblem(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();

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

      RubikScores scores = RubikScores.getInstance();

      int numWins = scores.incrementNumWins();

      int numRuns = scores.getNumRuns();

      if( numRuns==3 || numRuns==6 || numWins==4 || numWins==20 || numWins==50 || numWins==80 || numWins==100)

        {

        requestReview(act);

        }

      switch(mIsNewRecord)

        {

        case RECORD_FIRST  : if( RubikActivity.USE_IAP )

                                {

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

                                int level = play.getLevel();

                                int newStars = scores.computeNumStars(level);

                                int totStars = scores.getNumStars();

                                scores.changeNumStars(newStars);

                                DistortedScreen screen = act.getScreen();

                                OverlayStars stars = new OverlayStars();

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

                                stars.startOverlay(screen,this,data);

                                }

                             else

                                {

                                Bundle bundle = createDialogBundle();

                                RubikDialogNewRecord d2 = new RubikDialogNewRecord();

                                d2.setArguments(bundle);

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

                                }

                             break;

        case RECORD_NEW    : Bundle byes = createDialogBundle();

                             RubikDialogNewRecord dyes = new RubikDialogNewRecord();

                             dyes.setArguments(byes);

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

                             break;

        case RECORD_NOT_NEW: Bundle bno = createDialogBundle();

                             RubikDialogSolved dno = new RubikDialogSolved();

                             dno.setArguments(bno);

                             dno.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 = createDialogBundle();

    RubikDialogNewRecord d = new RubikDialogNewRecord();

    d.setArguments(bundle);

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

    }

}