Magic Cube

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

// 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.dialogs;

import android.os.Bundle;

import androidx.annotation.NonNull;

import androidx.fragment.app.FragmentActivity;

import androidx.viewpager.widget.PagerAdapter;

import androidx.viewpager.widget.ViewPager;

import android.util.DisplayMetrics;

import android.view.View;

import android.view.ViewGroup;

import android.widget.LinearLayout;

import org.distorted.main.R;

import org.distorted.external.RubikScores;

import org.distorted.external.RubikNetwork;

import org.distorted.objects.RubikObject;

import org.distorted.objects.RubikObjectList;

import org.distorted.screens.RubikScreenPlay;

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

class RubikDialogScoresPagerAdapter extends PagerAdapter implements RubikNetwork.ScoresReceiver

  {

  private final FragmentActivity mAct;

  private final RubikDialogScores mDialog;

  private final RubikDialogScoresView[] mViews;

  private final ViewPager mViewPager;

  private final int mNumTabs;

  private final boolean mIsSubmitting;

  private int mToDoTab, mToDoLvl;

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

  private void prepareView()

    {

    mAct.runOnUiThread(new Runnable()

      {

      @Override

      public void run()

        {

        for(int i=0; i<mNumTabs; i++)

          {

          mViews[i].prepareView(mAct);

          }

        }

      });

    try

      {

      Thread.sleep(150);

      }

    catch( InterruptedException ignored)

      {

      }

    }

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

  private void addSection(int tab, int level, int numLevels, final RubikDialogScoresView view, final String[] country, final String[] name, final int[] time)

    {

    String title = level==numLevels ?

                   mAct.getString(R.string.levelM) :

                   mAct.getString(R.string.lv_placeholder,level+1);

    final LinearLayout section = view.createSection(mAct, tab, title, level, country, name, time);

    mAct.runOnUiThread(new Runnable()

      {

      @Override

      public void run()

        {

        view.addSection(section);

        }

      });

    try

      {

      Thread.sleep(50);

      }

    catch( InterruptedException ignored)

      {

      }

    }

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

  private void getNext(int currentTab, int[] toDoTab, int[] numLevels)

    {

    if( toDoTab[currentTab]<=numLevels[currentTab] )

      {

      mToDoTab = currentTab;

      mToDoLvl = toDoTab[currentTab];

      toDoTab[currentTab]++;

      }

    else

      {

      for(int tab=0; tab<mNumTabs; tab++)

        {

        if( toDoTab[tab]<=numLevels[tab] )

          {

          mToDoTab = tab;

          mToDoLvl = toDoTab[tab];

          toDoTab[tab]++;

          break;

          }

        }

      }

    }

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

  public void receive(final String[][][] country, final String[][][] name, final int[][][] time)

    {

    prepareView();

    int toDo=0;

    int[] toDoTab   = new int[mNumTabs];

    int[] numLevels = new int[mNumTabs];

    for(int i=0; i<mNumTabs; i++)

      {

      toDoTab[i]= 0;

      RubikObject object = RubikObjectList.getObject(i);

      int numScramble = object==null ? 1 : object.getNumScramble();

      numLevels[i] = Math.min(numScramble-1,RubikScreenPlay.LEVELS_SHOWN);

      toDo += (numLevels[i]+1);

      }

    while( toDo>0 )

      {

      toDo--;

      getNext(mViewPager.getCurrentItem(), toDoTab, numLevels);

      addSection( mToDoTab, mToDoLvl, numLevels[mToDoTab], mViews[mToDoTab], country[mToDoTab][mToDoLvl], name[mToDoTab][mToDoLvl], time[mToDoTab][mToDoLvl]);

      }

    }

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

  public void message(final String mess)

    {

    mAct.runOnUiThread(new Runnable()

      {

      @Override

      public void run()

        {

        for(int i=0; i<mNumTabs; i++) mViews[i].message(mess);

        }

      });

    }

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

  public void error(final String error)

    {

    char errorNumber = error.charAt(0);

    switch(errorNumber)

      {

      case '1': message(mAct.getString(R.string.networkError));

                break;

      case '2': RubikScores scores = RubikScores.getInstance();

                Bundle bundle = new Bundle();

                bundle.putString("argument", scores.getName() );

                RubikDialogSetName nameDiag = new RubikDialogSetName();

                nameDiag.setArguments(bundle);

                nameDiag.show(mAct.getSupportFragmentManager(), null);

                mDialog.dismiss();

                break;

      case '3': message("Server error");

                break;

      default : message("Unexpected error");

      }

    }

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

  RubikDialogScoresPagerAdapter(FragmentActivity act, ViewPager viewPager, boolean isSubmitting, RubikDialogScores diag)

    {

    mAct = act;

    mDialog = diag;

    mNumTabs = RubikObjectList.getNumObjects();

    mViews = new RubikDialogScoresView[mNumTabs];

    mViewPager = viewPager;

    mIsSubmitting = isSubmitting;

    viewPager.setAdapter(this);

    viewPager.setOffscreenPageLimit(mNumTabs-1);

    }

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

  @Override

  @NonNull

  public Object instantiateItem(@NonNull ViewGroup collection, int position)

    {

    DisplayMetrics metrics = mAct.getResources().getDisplayMetrics();

    mViews[position] = new RubikDialogScoresView(mAct, metrics.heightPixels, mIsSubmitting);

    collection.addView(mViews[position]);

    boolean allCreated = true;

    for(int i=0; i<mNumTabs; i++)

      {

      if( mViews[i]==null )

        {

        allCreated = false;

        break;

        }

      }

    if( allCreated )

      {

      RubikNetwork network = RubikNetwork.getInstance();

      if( mIsSubmitting )  network.submit  ( this, mAct );

      else                 network.download( this, mAct );

      }

    return mViews[position];

    }

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

  @Override

  public void destroyItem(ViewGroup collection, int position, @NonNull Object view)

    {

    collection.removeView((View) view);

    }

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

  @Override

  public int getCount()

    {

    return mNumTabs;

    }

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

  @Override

  public boolean isViewFromObject(@NonNull View view, @NonNull Object object)

    {

    return view == object;

    }

  }