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 org.distorted.objectlib.helpers.ObjectStateActioner;

import org.distorted.objectlib.helpers.TwistyActivity;

import org.distorted.objectlib.main.ObjectType;

import org.distorted.dialogs.RubikDialogNewRecord;

import org.distorted.dialogs.RubikDialogSolved;

import org.distorted.network.RubikScores;

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;

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

public class RubikObjectStateActioner implements ObjectStateActioner

{

  private boolean mIsNewRecord;

  private long mNewRecord;

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

  private void analyticsReport(TwistyActivity 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("pre", msg);

       }

    else

      {

      RubikActivity ract = (RubikActivity)act;

      FirebaseAnalytics analytics = ract.getAnalytics();

      if( analytics!=null )

        {

        Bundle bundle = new Bundle();

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

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

        }

      }

    }

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

  private void reportRecord(TwistyActivity act, String debug, int scrambleNum)

    {

    RubikActivity ract  = (RubikActivity)act;

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

    RubikScores scores  = RubikScores.getInstance();

    ObjectType object   = play.getObject();

    int level           = play.getLevel();

    String name         = scores.getName();

    String record = object.name()+" level "+level+" time "+mNewRecord+" isNew: "+mIsNewRecord+" scrambleNum: "+scrambleNum;

    if( BuildConfig.DEBUG )

       {

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

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

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

       }

    else

      {

      FirebaseAnalytics analytics = ract.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(TwistyActivity 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(TwistyActivity act, String debug, int scrambleNum)

     {

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

       {

       RubikActivity ract = (RubikActivity)act;

       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( ract, ScreenList.DONE);

           }

         });

       }

     }

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

   public void onScrambleEffectFinished(TwistyActivity act)

     {

     RubikActivity ract = (RubikActivity)act;

     RubikScores.getInstance().incrementNumPlays();

     act.runOnUiThread(new Runnable()

       {

       @Override

       public void run()

         {

         ScreenList.switchScreen( ract, ScreenList.READ);

         }

       });

     }

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

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

     {

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

       {

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

       solv.addMove(act, axis, row, angle);

       }

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

       {

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

       play.addMove(act, axis, row, angle);

       }

     }

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

   public void onBeginRotation(TwistyActivity act)

     {

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

       {

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

       solving.resetElapsed();

       RubikActivity ract = (RubikActivity)act;

       ract.runOnUiThread(new Runnable()

         {

         @Override

         public void run()

           {

           ScreenList.switchScreen( ract, ScreenList.SOLV);

           }

         });

       }

     }

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

    public void failedToDrag(TwistyActivity act)

      {

      ScreenList curr = ScreenList.getCurrentScreen();

      if( curr==ScreenList.PLAY )

        {

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

        play.reddenLock(act);

        }

      else if( curr==ScreenList.READ )

        {

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

        read.reddenLock(act);

        }

      else if( curr==ScreenList.SOLV )

        {

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

        solv.reddenLock(act);

        }

      }

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

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

     {

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

     return solver.getCurrentColor();

     }

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

   public int cubitIsLocked(ObjectType type, int cubit)

     {

     return SolverMain.cubitIsLocked(type,cubit);

     }

}