TwistyPuzzleLib

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

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

import java.io.InputStream;

import android.app.Activity;

import android.content.SharedPreferences;

import org.distorted.library.message.EffectListener;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.helpers.ObjectLibInterface;

import org.distorted.objectlib.effects.BaseEffect;

import org.distorted.objectlib.effects.scramble.ScrambleEffect;

import org.distorted.objectlib.helpers.BlockController;

import org.distorted.objectlib.helpers.MovesFinished;

import org.distorted.objectlib.shape.ShapeDodecahedron;

import org.distorted.objectlib.shape.ShapeHexahedron;

import org.distorted.objectlib.shape.ShapeOctahedron;

import org.distorted.objectlib.shape.ShapeTetrahedron;

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

public class ObjectPreRender implements EffectListener

  {

  private static final int MAX_SLOW_SCRAMBLE = 50;

  private final ObjectControl mController;

  private InputStream mJsonStream, mMeshStream;

  private int mOrdinal;

  private TwistyObject mOldObject, mNewObject;

  private SharedPreferences mPreferences;

  private MovesFinished mAddActionListener;

  private final BlockController mBlockController;

  private final ObjectLibInterface mInterface;

  private String mDebug;

  private float mMoveX, mMoveY;

  private float mScale;

  private boolean mFinishRotation, mRemoveRotation, mRemovePatternRotation, mAddRotation,

                  mSetQuat, mChangeObject, mSolveObject, mScrambleObject, mFastScrambleObject,

                  mPresentObject,mInitializeObject, mSetTextureMap, mResetAllTextureMaps, mSolve,

                  mApplyScrambles, mResetTextureEffect;

  private boolean mScramblingAndSolvingBlocked, mRotationBlocked, mIsSolved;

  private long mRotationFinishedID;

  private final long[] mEffectID;

  private int[][] mNextMoves;

  private int mScrambleObjectNum, mScrambleObjectDuration;

  private int mAddRotationAxis, mAddRotationRowBitmap, mAddRotationAngle;

  private long mAddRotationDuration;

  private int mPresentDuration, mRestickerDuration;

  private long mAddRotationID, mRemoveRotationID;

  private int mCubit, mFace, mNewColor;

  private int mNearestAngle;

  private long mScrambleStartTime, mScrambleEndTime;

  private int mMeshState, mIconMode;

  // debugging only

  private long mAddRotationTime;

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

  public ObjectPreRender(Activity act, ObjectControl controller, ObjectLibInterface actioner)

    {

    mInterface = actioner;

    mController = controller;

    mFinishRotation       = false;

    mRemoveRotation       = false;

    mRemovePatternRotation= false;

    mAddRotation          = false;

    mSetQuat              = false;

    mChangeObject         = false;

    mSolveObject          = false;

    mSolve                = false;

    mScrambleObject       = false;

    mFastScrambleObject   = false;

    mPresentObject        = false;

    mResetTextureEffect   = false;

    mOldObject = null;

    mNewObject = null;

    mDebug = "";

    mScrambleObjectNum = 0;

    mScale = 1.0f;

    mEffectID = new long[BaseEffect.Type.LENGTH];

    mBlockController = new BlockController(act,this);

    unblockEverything();

    }

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

  private void createObjectNow(int ordinal, int meshState, int iconMode, InputStream jsonStream, InputStream meshStream)

    {

    long time1 = System.currentTimeMillis();

    Static3D move = new Static3D(mMoveX,mMoveY,0);

    Static4D quat = mController.getQuat();

    TwistyObject tmp;

    boolean error = false;

    if( jsonStream==null )

      {

      tmp = ObjectType.create( ordinal, meshState, iconMode, quat, move, mScale, meshStream);

      }

    else

      {

      tmp = new TwistyJson( jsonStream, meshState, iconMode, quat, move, mScale, meshStream);

      error = tmp.getError();

      }

    if( error )

      {

      String errorString = tmp.getErrorString();

      mInterface.reportJSONError(errorString,ordinal);

      }

    else

      {

      if( mOldObject!=null ) mOldObject.releaseResources();

      mOldObject = mNewObject;

      mNewObject = tmp;

      long time2 = System.currentTimeMillis();

      mInterface.onObjectCreated(time2-time1);

      if( mNewObject!=null )

        {

        mNewObject.setLibInterface(mInterface);

        mController.setTouchControl(mNewObject);

        mNewObject.setObjectRatioNow(mScale, mController.getScalingSize() );

        if( mPreferences!=null )

          {

          mNewObject.restorePreferences(mPreferences);

          mPreferences = null;

          }

        mIsSolved = mNewObject.isSolved();

        }

      }

    }

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

// do all 'adjustable' effects (SizeChange, Solve, Scramble)

  private void doEffectNow(BaseEffect.Type type, int duration)

    {

    try

      {

      int index = type.ordinal();

      mEffectID[index] = type.startEffect(this,duration);

      }

    catch( Exception ex )

      {

      android.util.Log.e("renderer", "exception starting effect: "+ex.getMessage());

      unblockEverything();

      }

    }

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

  private void removeRotationNow()

    {

    mRemoveRotation=false;

    mNewObject.removeRotationNow();

    boolean solved = mNewObject.isSolved();

    if( solved && !mIsSolved )

      {

      mInterface.onSolved();

      unblockEverything();

      int duration = BaseEffect.Type.WIN.getDuration();

      doEffectNow( BaseEffect.Type.WIN, duration );

      }

    else

      {

      unblockEverything();

      }

    mIsSolved = solved;

    }

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

  private void removeRotation()

    {

    mRemoveRotation = true;

    }

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

  private void removePatternRotation()

    {

    mRemovePatternRotation = true;

    }

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

  private void removePatternRotationNow()

    {

    mRemovePatternRotation=false;

    mNewObject.removeRotationNow();

    mAddActionListener.onActionFinished(mRemoveRotationID);

    }

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

  private void addRotationNow()

    {

    mAddRotation = false;

    if( mNewObject.getNumAxis() > mAddRotationAxis )

      {

      mAddRotationID = mNewObject.addNewRotation( mAddRotationAxis, mAddRotationRowBitmap,

                                                  mAddRotationAngle, mAddRotationDuration, this);

      // failed to add effect (previous rotation hasn't been removed yet)

      if( mAddRotationID==0 )

        {

        mAddActionListener.onActionFinished(0);

        }

      // the rotation we have just added has forced a finish() of an ongoing

      // manual rotation. So the effect that's going to finish is not the manual

      // rotation (we have just removed it) but the rotation we have just added

      // here - so set mRotationFinishedID to 0

      else if( mAddRotationID<0 )

        {

        mAddRotationID = -mAddRotationID;

        mRotationFinishedID = 0;

        }

      }

    else // should never happen but Firebase says it sometimes does

      {

      long timeNow = System.currentTimeMillis();

      Class<? extends MovesFinished> clazz = mAddActionListener.getClass();

      String name = clazz.getSimpleName();

      String error = "time now: "+timeNow+" add time: "+mAddRotationTime+" axis="+mAddRotationAxis+

                      "object: "+mNewObject.getShortName()+" "+name;

      mInterface.reportProblem(error,true);

      unblockEverything();

      }

    }

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

  private void finishRotationNow()

    {

    mFinishRotation = false;

    blockEverything(BlockController.PLACE_0);

    mRotationFinishedID = mNewObject.finishRotationNow(this, mNearestAngle);

    if( mRotationFinishedID==0 ) // failed to add effect - should never happen

      {

      unblockEverything();

      }

    }

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

  private void changeObjectNow()

    {

    mChangeObject = false;

    blockEverything(BlockController.PLACE_1);

    createObjectNow(mOrdinal,mMeshState,mIconMode,mJsonStream,mMeshStream);

    int duration = BaseEffect.Type.SIZECHANGE.getDuration();

    doEffectNow( BaseEffect.Type.SIZECHANGE, duration );

    }

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

  private void scrambleObjectNow()

    {

    mScrambleObject = false;

    mIsSolved       = false;

    blockEverything(BlockController.PLACE_3);

    if( mScrambleObjectNum<MAX_SLOW_SCRAMBLE )

      {

      int duration = BaseEffect.Type.SCRAMBLE.getDuration();

      doEffectNow( BaseEffect.Type.SCRAMBLE, duration );

      }

    else

      {

      int duration = BaseEffect.Type.FAST_SCRAMBLE.getDuration();

      doEffectNow( BaseEffect.Type.FAST_SCRAMBLE, duration );

      }

    }

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

  private void fastScrambleObjectNow()

    {

    mFastScrambleObject = false;

    mIsSolved           = false;

    blockEverything(BlockController.PLACE_5);

    doEffectNow( BaseEffect.Type.FAST_SCRAMBLE, mScrambleObjectDuration );

    }

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

  private void resetTextureNow()

    {

    mResetTextureEffect = false;

    doEffectNow( BaseEffect.Type.RESTICKER, mRestickerDuration );

    }

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

  private void presentObjectNow()

    {

    mPresentObject = false;

    doEffectNow( BaseEffect.Type.PRESENT, mPresentDuration );

    }

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

  private void solveObjectNow()

    {

    mSolveObject = false;

    blockEverything(BlockController.PLACE_4);

    int duration = BaseEffect.Type.SOLVE.getDuration();

    doEffectNow( BaseEffect.Type.SOLVE, duration );

    }

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

  private void solveNow()

    {

    mSolve = false;

    if( mNewObject!=null ) mNewObject.solve();

    }

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

  private void initializeObjectNow()

    {

    mInitializeObject = false;

    mNewObject.initializeObject(mNextMoves);

    }

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

  private void applyScramblesNow()

    {

    mApplyScrambles = false;

    mNewObject.applyScrambles(mNextMoves);

    }

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

  private void setTextureMapNow()

    {

    mSetTextureMap = false;

    if( mNewObject!=null ) mNewObject.setTextureMap(mCubit,mFace,mNewColor);

    }

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

  private void resetAllTextureMapsNow()

    {

    mResetAllTextureMaps = false;

    if( mNewObject!=null ) mNewObject.resetAllTextureMaps();

    }

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

  private void setQuatNow()

    {

    mSetQuat = false;

    mController.setQuat();

    }

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

  private int computeRowFromBitmap(int rowBitmap)

    {

    int index = 0;

    while(index<32)

      {

      if( (rowBitmap&0x1) != 0 ) return index;

      rowBitmap>>=1;

      index++;

      }

    return 0;

    }

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

  private void blockEverything(int place)

    {

    mScramblingAndSolvingBlocked = true;

    mRotationBlocked = true;

    mBlockController.rotationBlocked(place);

    mBlockController.scramblingAndSolvingBlocked(place);

    }

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

// called from ObjectControl; this from app when we switch the screen to READ post-scrambling.

// The point: we only unblock having completed the screen switch so that it is impossible to

// click the solve button then.

  void unblockEverything()

    {

    mScramblingAndSolvingBlocked = false;

    mRotationBlocked = false;

    mBlockController.rotationUnblocked();

    mBlockController.scramblingAndSolvingUnblocked();

    }

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

  void rememberMove(int axis, int row, int angle)

    {

    mDebug += (mNewObject==null ? "[null]" : mNewObject.reportState() );

    mDebug += ("(m "+axis+" "+(1<<row)+" "+angle+" "+(System.currentTimeMillis()-mScrambleEndTime))+")";

    }

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

  void finishRotation(int nearestAngle)

    {

    mNearestAngle   = nearestAngle;

    mFinishRotation = true;

    }

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

  void setTextureMap(int cubit, int face, int newColor)

    {

    mSetTextureMap = true;

    mCubit    = cubit;

    mFace     = face;

    mNewColor = newColor;

    }

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

  void setQuatOnNextRender()

    {

    mSetQuat = true;

    }

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

  void setMove(float xmove, float ymove)

    {

    mMoveX = xmove;

    mMoveY = ymove;

    }

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

  void setScale(float scale)

    {

    mScale = scale;

    }

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

// INTERNAL API

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

  public int getNumScrambles()

    {

    return mScrambleObjectNum;

    }

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

  public TwistyObject getOldObject()

    {

    return mOldObject;

    }

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

  public float getMoveX()

    {

    return mMoveX;

    }

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

  public float getMoveY()

    {

    return mMoveY;

    }

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

  public ObjectLibInterface getInterface()

    {

    return mInterface;

    }

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

// PUBLIC API

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

  public void savePreferences(SharedPreferences.Editor editor)

    {

    if( mNewObject!=null )

      {

      mNewObject.savePreferences(editor);

      }

    }

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

  public void restorePreferences(SharedPreferences preferences)

    {

    mPreferences = preferences;

    }

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

  public void changeObject(int ordinal, int meshState, int iconMode, InputStream jsonStream, InputStream meshStream)

    {

    mChangeObject = true;

    mOrdinal    = ordinal;

    mMeshState  = meshState;

    mIconMode   = iconMode;

    mJsonStream = jsonStream;

    mMeshStream = meshStream;

    }

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

  public void setDefaultRotation(int numFaces)

    {

    if( mController!=null && mController.getRotateOnCreation() )

      {

      switch(numFaces)

        {

        case  4: mController.rotateNow(ShapeTetrahedron.DEFAULT_ROT ); break;

        case  6: mController.rotateNow(ShapeHexahedron.DEFAULT_ROT  ); break;

        case  8: mController.rotateNow(ShapeOctahedron.DEFAULT_ROT  ); break;

        case 12: mController.rotateNow(ShapeDodecahedron.DEFAULT_ROT); break;

        }

      }

    }

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

  public boolean isRotationBlocked()

    {

    return mRotationBlocked;

    }

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

  public boolean isScramblingAndSolvingNotBlocked()

    {

    return !mScramblingAndSolvingBlocked;

    }

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

  public void blockRotation(int place)

    {

    mRotationBlocked = true;

    mBlockController.rotationBlocked(place);

    }

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

  public void unblockRotation()

    {

    mRotationBlocked = false;

    mBlockController.rotationUnblocked();

    }

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

  public void unblockScramblingAndSolving()

    {

    mScramblingAndSolvingBlocked = false;

    mBlockController.scramblingAndSolvingUnblocked();

    }

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

  public void preRender()

    {

    if( mSolve                 ) solveNow();

    if( mSetQuat               ) setQuatNow();

    if( mFinishRotation        ) finishRotationNow();

    if( mRemoveRotation        ) removeRotationNow();

    if( mRemovePatternRotation ) removePatternRotationNow();

    if( mChangeObject          ) changeObjectNow();

    if( mSolveObject           ) solveObjectNow();

    if( mScrambleObject        ) scrambleObjectNow();

    if( mFastScrambleObject    ) fastScrambleObjectNow();

    if( mPresentObject         ) presentObjectNow();

    if( mAddRotation           ) addRotationNow();

    if( mInitializeObject      ) initializeObjectNow();

    if( mApplyScrambles        ) applyScramblesNow();

    if( mResetAllTextureMaps   ) resetAllTextureMapsNow();

    if( mSetTextureMap         ) setTextureMapNow();

    if( mResetTextureEffect    ) resetTextureNow();

    }

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

  public void addRotation(MovesFinished listener, int axis, int rowBitmap, int bareAngle, int millPreDegree)

    {

    int[][] basicAngles = mNewObject==null ? null : mNewObject.getBasicAngles();

    int length = basicAngles==null ? 0 : basicAngles.length;

    if( axis<length )

      {

      int row = computeRowFromBitmap(rowBitmap);

      if( row<basicAngles[axis].length )

        {

        int basicAngle= basicAngles[axis][row];

        int angle     = bareAngle*(360/basicAngle);

        int duration  = Math.abs(angle)*millPreDegree;

        mAddActionListener    = listener;

        mAddRotationAxis      = axis;

        mAddRotationRowBitmap = rowBitmap;

        mAddRotationAngle     = angle;

        mAddRotationDuration  = duration;

        mAddRotationTime      = System.currentTimeMillis();

        mAddRotation          = true;

        if( listener instanceof ScrambleEffect )

          {

          mDebug += (mNewObject==null ? "null" : mNewObject.reportState() );

          mDebug += ("(a "+axis+" "+rowBitmap+" "+angle+" "+(mAddRotationTime-mScrambleStartTime))+")";

          }

        }

      }

    }

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

  public void initializeObject(int[][] moves)

    {

    mInitializeObject = true;

    mNextMoves = moves;

    }

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

  public void applyScrambles(int[][] moves)

    {

    mApplyScrambles = true;

    mNextMoves = moves;

    }

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

  public boolean scrambleObject(int num)

    {

    if( !mScramblingAndSolvingBlocked )

      {

      mScrambleObject = true;

      mScrambleObjectNum = num;

      mDebug = "";

      mScrambleStartTime = System.currentTimeMillis();

      return true;

      }

    return false;

    }

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

  public boolean fastScrambleObject(int duration, int num)

    {

    if( !mScramblingAndSolvingBlocked )

      {

      mFastScrambleObject = true;

      mScrambleObjectNum = num;

      mScrambleObjectDuration = duration;

      mDebug = "";

      mScrambleStartTime = System.currentTimeMillis();

      return true;

      }

    return false;

    }

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

  public void presentObject(int num, int duration)

    {

    mScrambleObjectNum = num;

    mPresentDuration = duration;

    mPresentObject = true;

    }

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

// this starts the Solve Effect

  public void solveObject()

    {

    if( !mScramblingAndSolvingBlocked )

      {

      mSolveObject = true;

      }

    }

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

// this only sets the cubits state to solved

  public void solveOnly()

    {

    mSolve = true;

    }

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

  public void resetTextureMapsEffect(int duration)

    {

    mRestickerDuration = duration;

    mResetTextureEffect = true;

    }

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

  public void resetAllTextureMaps()

    {

    mResetAllTextureMaps = true;

    }

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

  public TwistyObject getObject()

    {

    return mNewObject;

    }

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

  public TwistyObjectNode getObjectNode()

    {

    return mController.getNode();

    }

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

  public void effectFinished(final long effectID)

    {

    if( effectID == mRotationFinishedID )

      {

      mRotationFinishedID = 0;

      removeRotation();

      }

    else if( effectID == mAddRotationID )

      {

      mAddRotationID = 0;

      mRemoveRotationID = effectID;

      removePatternRotation();

      }

    else

      {

      for(int i=0; i<BaseEffect.Type.LENGTH; i++)

        {

        if( effectID == mEffectID[i] )

          {

          if( i==BaseEffect.Type.SCRAMBLE.ordinal() )

            {

            mScrambleEndTime = System.currentTimeMillis();

            mInterface.onScrambleEffectFinished();

            }

          else if( i==BaseEffect.Type.WIN.ordinal()      )

            {

            mInterface.onWinEffectFinished(mScrambleStartTime,mScrambleEndTime-mScrambleStartTime,mDebug,mScrambleObjectNum);

            }

          else

            {

            unblockEverything();

            }

          break;

          }

        }

      }

    }

  }