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 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 static org.distorted.external.RubikScores.LEVELS_SHOWN;

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

class RubikDialogScoresPagerAdapter extends PagerAdapter implements RubikNetwork.ScoresReceiver

  {

  private static final int NETWORK_NOT_READY = 0;

  private static final int NETWORK_SUCCESS   = 1;

  private static final int NETWORK_FAILURE   = 2;

  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 final int[] mNumLevels;

  private String[][][] mCountry, mName;

  private int[][][] mTime;

  private String mMessage;

  private int mNetworkState;

  private final Object mObj;

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

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

    {

    synchronized(mObj)

      {

      RubikDialogScoresThread thr = RubikDialogScoresThread.getInstance();

      thr.equip(mAct,mViewPager);

      mNetworkState = NETWORK_SUCCESS;

      mCountry = country;

      mName = name;

      mTime = time;

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

        if( mViews[t]!=null )

          {

          int num = mNumLevels[t];

          String[][] c = country[t];

          String[][] n = name[t];

          int[][] tm = time[t];

          for(int l=0; l<=num; l++)  thr.newWork(t, l, num, mViews[t], c[l], n[l], tm[l]);

          }

      }

    }

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

  public void message(final String mess)

    {

    mNetworkState = NETWORK_FAILURE;

    mMessage = mess;

    mAct.runOnUiThread(new Runnable()

      {

      @Override

      public void run()

        {

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

          if( mViews[i]!=null ) 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)

    {

    mObj = new Object();

    mAct = act;

    mDialog = diag;

    mNumTabs = RubikObjectList.getNumObjects();

    mViews = new RubikDialogScoresView[mNumTabs];

    mViewPager = viewPager;

    mIsSubmitting = isSubmitting;

    mNetworkState = NETWORK_NOT_READY;

    mNumLevels = new int[mNumTabs];

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

      {

      RubikObject object = RubikObjectList.getObject(i);

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

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

      }

    viewPager.setAdapter(this);

    viewPager.setOffscreenPageLimit(1);

    RubikNetwork network = RubikNetwork.getInstance();

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

    else                 network.download( this, mAct );

    }

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

  @Override

  @NonNull

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

    {

    RubikDialogScoresView view;

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

    synchronized(mObj)

      {

      view = new RubikDialogScoresView(mAct, metrics.heightPixels, mIsSubmitting, mNetworkState==NETWORK_SUCCESS );

      collection.addView(view);

      if( mNetworkState==NETWORK_SUCCESS )

        {

        int num = mNumLevels[position];

        String[][] c = mCountry[position];

        String[][] n = mName[position];

        int[][] tm = mTime[position];

        RubikDialogScoresThread thr = RubikDialogScoresThread.getInstance();

        thr.equip(mAct,mViewPager);

        for(int l=0; l<=num; l++)  thr.newWork(position, l, num, view, c[l], n[l], tm[l]);

        }

      else if( mNetworkState==NETWORK_FAILURE )

        {

        view.message(mMessage);

        }

      }

    mViews[position] = view;

    return view;

    }

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

  @Override

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

    {

    collection.removeView((View) view);

    mViews[position] = null;

    }

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

  @Override

  public int getCount()

    {

    return mNumTabs;

    }

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

  @Override

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

    {

    return view == object;

    }

  }