Magic Cube

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

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

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.network.RubikScores;

import org.distorted.objects.RubikObject;

import org.distorted.objects.RubikObjectList;

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;

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

public class RubikObjectLibInterface implements ObjectLibInterface

{

  private final WeakReference<RubikActivity> mAct;

  private boolean 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, 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.getName();

    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

      {

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

    if( numWins==7 || numWins==30 || numWins==100 || numWins==200)

      {

      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 onWinEffectFinished(String debug, int scrambleNum)

    {

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

      {

      RubikActivity act = mAct.get();

      Bundle bundle = new Bundle();

      bundle.putLong("time", mNewRecord );

      reportRecord(act,debug,scrambleNum);

      requestReview(act);

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

          {

          ScreenList.switchScreen( act, ScreenList.DONE);

          }

        });

      }

    }

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

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

      if( mNewRecord< 0 )

        {

        mNewRecord = -mNewRecord;

        mIsNewRecord = false;

        }

      else

        {

        mIsNewRecord = true;

        }

      }

    }

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

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

      }

    }

}