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.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 addSection(int tab, int level, int lastLevel, final RubikDialogScoresView view, final String[] country, final String[] name, final float[] time)

    {

    String title = level==lastLevel-1 ?

                   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[] maxTab, int[] lastTab)

    {

    if( toDoTab[currentTab]<maxTab[currentTab] )

      {

      mToDoTab = currentTab;

      mToDoLvl = toDoTab[currentTab]<maxTab[currentTab]-1 ? toDoTab[currentTab] : lastTab[currentTab]-1;

      toDoTab[currentTab]++;

      }

    else

      {

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

        {

        if( toDoTab[tab]<maxTab[tab] )

          {

          mToDoTab = tab;

          mToDoLvl = toDoTab[tab]<maxTab[tab]-1 ? toDoTab[tab] : lastTab[tab]-1;

          toDoTab[tab]++;

          break;

          }

        }

      }

    }

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

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

    {

    prepareView();

    int MAX = RubikScreenPlay.LEVELS_SHOWN+1;

    int toDo=0;

    int[] toDoTab = new int[mNumTabs];

    int[] maxTab  = new int[mNumTabs];

    int[] lastTab = new int[mNumTabs];

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

      {

      lastTab[i]= RubikObjectList.getDBLevel(i);

      maxTab[i] = Math.min(lastTab[i],MAX);

      toDoTab[i]= 0;

      toDo += maxTab[i];

      }

    while( toDo>0 )

      {

      toDo--;

      getNext(mViewPager.getCurrentItem(),toDoTab,maxTab,lastTab);

      addSection( mToDoTab,mToDoLvl, lastTab[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("name", 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");

      }

    }

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

  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)

      {

      }

    }

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

  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;

    }

  }