Magic Cube

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

// Copyright 2023 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.playui;

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;

import android.os.Bundle;

import androidx.annotation.NonNull;

import java.lang.ref.WeakReference;

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.RubikDialogNewRecord;

import org.distorted.dialogs.RubikDialogScoresView;

import org.distorted.dialogs.RubikDialogSolved;

import org.distorted.external.RubikNetwork;

import org.distorted.external.RubikScores;

import org.distorted.library.message.EffectMessageSender;

import org.distorted.objectlib.helpers.BlockController;

import org.distorted.objectlib.helpers.ObjectLibInterface;

import org.distorted.objectlib.main.ObjectControl;

import org.distorted.objects.RubikObject;

import org.distorted.objects.RubikObjectList;

import org.distorted.main.BuildConfig;

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

public class PlayLibInterface implements ObjectLibInterface

{

  private final WeakReference<PlayActivity> mAct;

  private int mIsNewRecord;

  private int mNewRecord;

  private boolean mReviewAsked;

  private int mNumRotations, mNumScrambles;

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

  PlayLibInterface(PlayActivity act)

    {

    mAct = new WeakReference<>(act);

    mReviewAsked = false;

    mNumRotations = 0;

    mNumScrambles = 0;

    }

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

  public void onObjectCreated(long time) { }

  public void onReplaceModeDown(int cubit, int face) { }

  public void onReplaceModeUp() { }

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

  private void analyticsReport(PlayActivity 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(PlayActivity act, long startTime, long endTime, String debug, int scrambleNum)

    {

    RubikScores scores  = RubikScores.getInstance();

    int object  = RubikObjectList.getCurrObject();

    String name = scores.getName();

    RubikObject obj = RubikObjectList.getObject(object);

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

    String record = objName+" 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( scrambleNum>=9 && mNewRecord<300*scrambleNum )

        {

        long timeNow = System.currentTimeMillis();

        long elapsed = timeNow - startTime;

        String suspicious ="start"+startTime+"end"+endTime+"elapsed"+elapsed+"obj"+objName+"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(PlayActivity 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()

    {

    if( ScreenList.getCurrentScreen()==ScreenList.SCRA )

      {

      PlayActivity act = mAct.get();

      RubikScores.getInstance().incrementNumPlays();

      act.runOnUiThread(new Runnable()

        {

        @Override

        public void run()

          {

          ScreenScrambling screen = (ScreenScrambling)ScreenList.SCRA.getScreenClass();

          screen.setReady();

          ObjectControl control = act.getControl();

          control.unblockEverything();

          }

        });

      }

    mNumScrambles++;

    if( mNumScrambles==10 && !mReviewAsked )

      {

      PlayActivity act = mAct.get();

      requestReview(act);

      }

    }

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

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

    {

    mNumRotations++;

    PlayActivity act = mAct.get();

    if( act!=null )

      {

      ScreenList screen = ScreenList.getCurrentScreen();

      if( screen==ScreenList.FREE ||

          screen==ScreenList.SOLV  ) ((ScreenBase)screen.getScreenClass()).addMove(act,axis,row,angle);

      }

    if( mNumRotations==40 && !mReviewAsked )

      {

      requestReview(act);

      }

    }

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

  public void onBeginRotation()

    {

    if( ScreenList.getCurrentScreen()==ScreenList.SCRA )

      {

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

      solving.resetElapsed();

      PlayActivity act = mAct.get();

      act.runOnUiThread(new Runnable()

        {

        @Override

        public void run()

          {

          ScreenList.switchScreen( act,ScreenList.SOLV );

          }

        });

      }

    }

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

  public void failedToDrag()

    {

    PlayActivity act = mAct.get();

    if( act!=null )

      {

      ScreenList screen = ScreenList.getCurrentScreen();

      if( screen==ScreenList.FREE ||

          screen==ScreenList.SOLV ||

          screen==ScreenList.SCRA  ) ((ScreenBase)screen.getScreenClass()).reddenLock(act);

      }

    }

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

  public void onSolved()

    {

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

      {

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

      mNewRecord = solving.stopTimerAndGetRecord();

      mIsNewRecord = solving.setRecord();

      }

    }

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

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

    {

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

      {

      PlayActivity 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  :

        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 reportProblem(String problem, boolean reportException)

    {

    if( BuildConfig.DEBUG )

      {

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

      }

    else

      {

      if( reportException )

        {

        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("D", 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("D", 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("D", 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);

      }

    }

}