Magic Cube

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

// Copyright 2021 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.control;

import org.distorted.library.main.DistortedNode;

import org.distorted.library.message.EffectListener;

import org.distorted.main.RubikActivity;

import org.distorted.main.RubikPreRender;

import org.distorted.objects.TwistyObject;

import java.lang.ref.WeakReference;

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

public class RubikControl implements EffectListener

  {

  WeakReference<RubikActivity> mRefAct;

  boolean mWholeReturned, mRotateReturned;

  RubikControlWhole mWhole;

  RubikControlRotate mRotate;

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

  private TwistyObject getObject()

    {

    RubikActivity act = mRefAct.get();

    if( act!=null )

      {

      RubikPreRender pre = act.getPreRender();

      return pre!=null ? pre.getObject() : null;

      }

    return null;

    }

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

  private void addWholeObjects()

    {

    TwistyObject object = getObject();

    DistortedNode[] nodes = mWhole.getNodes();

    if( object!=null && nodes!=null )

      {

      for (DistortedNode node : nodes) object.attach(node);

      }

    }

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

  private void removeWholeObjects()

    {

    TwistyObject object = getObject();

    DistortedNode[] nodes = mWhole.returnNodes();

    if( object!=null && nodes!=null )

      {

      for (DistortedNode node : nodes) object.detach(node);

      }

    }

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

  private void addRotateObjects()

    {

    TwistyObject object = getObject();

    DistortedNode[] nodes = mRotate.getNodes();

    if( object!=null && nodes!=null )

      {

      for (DistortedNode node : nodes) object.attach(node);

      }

    }

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

  private void removeRotateObjects()

    {

    TwistyObject object = getObject();

    DistortedNode[] nodes = mRotate.returnNodes();

    if( object!=null && nodes!=null )

      {

      for (DistortedNode node : nodes) object.detach(node);

      }

    }

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

  private void finishWhole()

    {

    removeWholeObjects();

    mWholeReturned = true;

    if( !mRotateReturned ) addRotateObjects();

    }

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

  private void finishRotate()

    {

    removeRotateObjects();

    mRotateReturned= true;

    RubikActivity act = mRefAct.get();

    if( act!=null ) act.unblockEverything();

    }

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

  RubikActivity getActivity()

    {

    return mRefAct.get();

    }

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

// PUBLIC

  public RubikControl()

    {

    mWhole = new RubikControlWhole(this);

    mRotate= new RubikControlRotate(this);

    }

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

  public void effectFinished(long effectID)

    {

    if( effectID==mWhole.getEffectID()  ) finishWhole();

    if( effectID==mRotate.getEffectID() ) finishRotate();

    }

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

  public void animateAll(RubikActivity act)

    {

    act.blockEverything();

    mRefAct = new WeakReference<>(act);

    mWholeReturned = false;

    mRotateReturned= false;

    addWholeObjects();

    }

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

  public void animateRotate(RubikActivity act)

    {

    act.blockEverything();

    mRefAct = new WeakReference<>(act);

    mWholeReturned = true;

    mRotateReturned= false;

    addRotateObjects();

    }

  }