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.helpers.BlockController;

import org.distorted.library.main.DistortedNode;

import org.distorted.library.main.DistortedScreen;

import org.distorted.library.message.EffectListener;

import org.distorted.library.type.Static4D;

import org.distorted.main.RubikActivity;

import org.distorted.main.RubikSurfaceView;

import org.distorted.objectlib.TwistyObject;

import java.lang.ref.WeakReference;

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

public class RubikControl implements EffectListener

  {

  private static RubikControl mControl;

  WeakReference<RubikActivity> mRefAct;

  boolean mWholeReturned, mRotateReturned;

  RubikControlWhole mWhole;

  RubikControlRotate mRotate;

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

  DistortedScreen getScreen()

    {

    RubikActivity act = mRefAct.get();

    return act!=null ? act.getScreen() : null;

    }

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

  TwistyObject getObject()

    {

    RubikActivity act = mRefAct.get();

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

    }

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

  Static4D getCurrQuat()

    {

    RubikActivity act = mRefAct.get();

    return act!=null ? act.getCurrQuat() : null;

    }

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

  RubikSurfaceView getSurfaceView()

    {

    RubikActivity act = mRefAct.get();

    return act!=null ? act.getSurfaceView() : null;

    }

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

  private void addWholeObjects()

    {

    DistortedScreen screen = getScreen();

    DistortedNode[] nodes = mWhole.getNodes();

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

      {

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

      }

    }

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

  private void removeWholeObjects()

    {

    DistortedScreen screen = getScreen();

    DistortedNode[] nodes = mWhole.returnNodes();

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

      {

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

      }

    }

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

  private void addRotateObjects()

    {

    DistortedScreen screen = getScreen();

    DistortedNode[] screenNodes = mRotate.getScreenNodes();

    if( screen!=null && screenNodes!=null )

      {

      for (DistortedNode node : screenNodes) screen.attach(node);

      }

    DistortedNode object = getObject();

    DistortedNode[] objectNodes = mRotate.getObjectNodes();

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

      {

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

      }

    }

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

  private void removeRotateObjects()

    {

    DistortedScreen screen = getScreen();

    DistortedNode[] screenNodes = mRotate.returnScreenNodes();

    if( screen!=null && screenNodes!=null )

      {

      for (DistortedNode node : screenNodes) screen.detach(node);

      }

    DistortedNode object = getObject();

    DistortedNode[] objectNodes = mRotate.returnObjectNodes();

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

      {

      for (DistortedNode node : objectNodes) 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();

    }

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

  private RubikControl()

    {

    mWhole = new RubikControlWhole(this);

    mRotate= new RubikControlRotate(this);

    }

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

// PUBLIC

  public static RubikControl getInstance()

    {

    if( mControl==null ) mControl = new RubikControl();

    return mControl;

    }

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

  public void postDrawFrame(long time)

    {

    mWhole.postDrawFrame(time);

    }

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

  public void effectFinished(long effectID)

    {

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

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

    }

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

  public void animateAll(RubikActivity act)

    {

    act.blockEverything(BlockController.CONTROL_PLACE_0);

    mRefAct = new WeakReference<>(act);

    mWholeReturned = false;

    mRotateReturned= false;

    addWholeObjects();

    }

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

  public void animateRotate(RubikActivity act)

    {

    act.blockEverything(BlockController.CONTROL_PLACE_1);

    mRefAct = new WeakReference<>(act);

    mWholeReturned = true;

    mRotateReturned= false;

    addRotateObjects();

    }

  }