Magic Cube

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

// Copyright 2020 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.scores;

import android.content.Context;

import android.content.SharedPreferences;

import android.telephony.TelephonyManager;

import org.distorted.objects.ObjectList;

import java.util.UUID;

import static org.distorted.objects.ObjectList.MAX_NUM_OBJECTS;

import static org.distorted.objects.ObjectList.NUM_OBJECTS;

import static org.distorted.objects.ObjectList.MAX_LEVEL;

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

// hold my own scores, and some other statistics.

public class RubikScores

  {

  public static final long NO_RECORD = Long.MAX_VALUE;

  private static RubikScores mThis;

  private long[][][] mRecords;

  private int [][][] mSubmitted;

  private String mName, mCountry;

  private boolean mNameIsVerified;

  private int mNumRuns;

  private int mNumPlays;

  private int mNumReviews;

  private int mDeviceID;

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

  private RubikScores()

    {

    mRecords   = new long[NUM_OBJECTS][MAX_NUM_OBJECTS][MAX_LEVEL];

    mSubmitted = new int [NUM_OBJECTS][MAX_NUM_OBJECTS][MAX_LEVEL];

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

      for(int j=0; j<MAX_NUM_OBJECTS; j++)

        for(int k=0; k<MAX_LEVEL; k++)

          {

          mRecords[i][j][k]   = NO_RECORD;

          mSubmitted[i][j][k] = 0;

          }

    mName = "";

    mCountry = "un";

    mNameIsVerified = false;

    mNumPlays   = -1;

    mNumRuns    = -1;

    mDeviceID   = -1;

    mNumReviews =  0;

    }

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

  private int privateGetDeviceID()

    {

    int id;

    try

      {

      String s = UUID.randomUUID().toString();

      id = s.hashCode();

      }

    catch(Exception ex)

      {

      id = 0;

      android.util.Log.e("scores", "Exception in getDeviceID()");

      }

    return id<0 ? -id : id;

    }

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

  synchronized void successfulSubmit()

    {

    mNameIsVerified = true;

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

      for(int j=0; j<MAX_NUM_OBJECTS; j++)

        for(int k=0; k<MAX_LEVEL; k++)

          {

          mSubmitted[i][j][k]=1;

          }

    }

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

  int getDeviceID()

    {

    return mDeviceID;

    }

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

  boolean isVerified()

    {

    return mNameIsVerified;

    }

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

  synchronized boolean thereAreUnsubmittedRecords()

    {

    ObjectList list;

    int length;

    for(int object=0; object<NUM_OBJECTS; object++)

      {

      list = ObjectList.getObject(object);

      length = list.getSizes().length;

      for(int size=0; size<length; size++)

        for(int level=0; level<MAX_LEVEL; level++)

          {

          if( mSubmitted[object][size][level]==0 && mRecords[object][size][level]<NO_RECORD )

            {

            return true;

            }

          }

      }

    return false;

    }

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

  synchronized String getRecordList(String strObj, String strLvl, String strTim)

    {

    ObjectList list;

    StringBuilder builderObj = new StringBuilder();

    StringBuilder builderLvl = new StringBuilder();

    StringBuilder builderTim = new StringBuilder();

    boolean first = true;

    int[] sizes;

    int length;

    for(int object=0; object<NUM_OBJECTS; object++)

      {

      list = ObjectList.getObject(object);

      sizes = list.getSizes();

      length = sizes.length;

      for(int size=0; size<length; size++)

        {

        for(int level=0; level<MAX_LEVEL; level++)

          {

          if( mSubmitted[object][size][level]==0 && mRecords[object][size][level]<NO_RECORD )

            {

            if( !first )

              {

              builderObj.append(',');

              builderLvl.append(',');

              builderTim.append(',');

              }

            else

              {

              first=false;

              }

            builderObj.append(list.name());

            builderObj.append("_");

            builderObj.append(sizes[size]);

            builderLvl.append(level);

            builderTim.append(mRecords[object][size][level]);

            }

          }

        }

      }

    return strObj+builderObj.toString()+strLvl+builderLvl.toString()+strTim+builderTim.toString();

    }

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

// Public API

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

  public synchronized long getRecord(int object, int size, int level)

    {

    int maxsize = ObjectList.getObject(object).getSizes().length;

    if( object>=0 && object<NUM_OBJECTS && size>=0 && size<maxsize && level>=0 && level<MAX_LEVEL )

      {

      return mRecords[object][size][level];

      }

    return -1;

    }

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

  public synchronized boolean isSubmitted(int object, int size, int level)

    {

    int maxsize = ObjectList.getObject(object).getSizes().length;

    if( object>=0 && object<NUM_OBJECTS && size>=0 && size<maxsize && level>=0 && level<MAX_LEVEL )

      {

      return mSubmitted[object][size][level]==1;

      }

    return false;

    }

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

  public int getNumPlays()

    {

    return mNumPlays;

    }

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

  public int getNumRuns()

    {

    return mNumRuns;

    }

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

  public int getNumReviews()

    {

    return mNumReviews;

    }

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

  public String getName()

    {

    return mName;

    }

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

  public String getCountry()

    {

    return mCountry;

    }

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

  public void incrementNumPlays()

    {

    mNumPlays++;

    }

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

  public void incrementNumRuns()

    {

    mNumRuns++;

    }

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

  public void incrementNumReviews()

    {

    mNumReviews++;

    }

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

  public void setName(String newName)

    {

    mName = newName;

    }

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

  public void setCountry(String country)

    {

    mCountry = country;

    if( mCountry.equals("do") ) mCountry = "dm";  // see above

    }

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

  public synchronized boolean isSolved(int object, int size, int level)

    {

    int maxsize = ObjectList.getObject(object).getSizes().length;

    if( object>=0 && object<NUM_OBJECTS && size>=0 && size<maxsize && level>=0 && level<MAX_LEVEL )

      {

      return mRecords[object][size][level]<NO_RECORD;

      }

    return false;

    }

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

  public void setCountry(Context context)

    {

    TelephonyManager tM =((TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE));

    if( tM!=null )

      {

      mCountry = tM.getSimCountryIso();

      if( mCountry==null || mCountry.length()<=1 )

        {

        mCountry = tM.getNetworkCountryIso();

        }

      }

    // Special case: Dominicana. Its ISO-3166-alpha-2 country code is 'do' which we can't have here

    // because we later on map this to a resource name (the flag) and 'do' is a reserved Java keyword

    // and can't be a resource name.

    if( mCountry.equals("do") ) mCountry = "dm";

    }

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

  public static RubikScores getInstance()

    {

    if( mThis==null )

      {

      mThis = new RubikScores();

      }

    return mThis;

    }

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

  public synchronized void savePreferences(SharedPreferences.Editor editor)

    {

    StringBuilder builder = new StringBuilder();

    ObjectList list;

    int[] sizes;

    int length;

    for(int level=0; level<MAX_LEVEL; level++)

      {

      builder.setLength(0);

      for(int object=0; object<NUM_OBJECTS; object++)

        {

        list = ObjectList.getObject(object);

        sizes = list.getSizes();

        length = sizes.length;

        for(int size=0; size<length; size++)

          {

          builder.append(list.name());

          builder.append("_");

          builder.append(sizes[size]);

          builder.append("=");

          builder.append(mRecords[object][size][level]);

          builder.append(",");

          builder.append(mSubmitted[object][size][level]);

          builder.append(" ");

          }

        }

      editor.putString("scores_record"+level, builder.toString());

      }

    editor.putString("scores_name"  , mName  );

    editor.putBoolean("scores_isVerified", mNameIsVerified);

    editor.putInt("scores_numPlays", mNumPlays);

    editor.putInt("scores_numRuns" , mNumRuns);

    editor.putInt("scores_deviceid", mDeviceID);

    editor.putInt("scores_review"  , mNumReviews);

    }

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

  public synchronized void restorePreferences(SharedPreferences preferences)

    {

    String recordStr, subStr, nameStr, sizeStr, timeStr, submStr;

    int start, end, equals, underscore, comma;

    int object, sizeIndex, subm;

    long time;

    for(int level=0; level<MAX_LEVEL; level++)

      {

      start = end = 0;

      recordStr = preferences.getString("scores_record"+level, "");

      while( end!=-1 )

        {

        end = recordStr.indexOf(" ", start);

        if( end==-1 ) subStr = recordStr.substring(start);

        else          subStr = recordStr.substring(start,end);

        start = end+1;

        underscore = subStr.indexOf("_");

        equals = subStr.indexOf("=");

        comma = subStr.indexOf(",");

        if( underscore>=0 && equals>=0 && comma>=0 )

          {

          nameStr = subStr.substring(0,underscore);

          sizeStr = subStr.substring(underscore+1, equals);

          timeStr = subStr.substring(equals+1,comma);

          submStr = subStr.substring(comma+1);

          object = ObjectList.getOrdinal(nameStr);

          if( object>=0 && object< NUM_OBJECTS )

            {

            sizeIndex = ObjectList.getSizeIndex(object,Integer.parseInt(sizeStr));

            time = Long.parseLong(timeStr);

            subm = Integer.parseInt(submStr);

            if( sizeIndex>=0 && sizeIndex<MAX_NUM_OBJECTS && subm>=0 && subm<=1 )

              {

              mRecords  [object][sizeIndex][level] = time;

              mSubmitted[object][sizeIndex][level] = subm;

              }

            else

              {

              android.util.Log.e("scores", "error: size="+sizeIndex+" subm="+subm);

              }

            }

          else

            {

            android.util.Log.e("scores", "error: object="+object);

            }

          }

        }

      }

    mName           = preferences.getString("scores_name"  , "" );

    mNameIsVerified = preferences.getBoolean("scores_isVerified", false);

    mNumPlays       = preferences.getInt("scores_numPlays", 0);

    mNumRuns        = preferences.getInt("scores_numRuns" , 0);

    mDeviceID       = preferences.getInt("scores_deviceid",-1);

    mNumReviews     = preferences.getInt("scores_review"  ,-3);

    if( mDeviceID==-1 ) mDeviceID = privateGetDeviceID();

    }

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

  public synchronized boolean setRecord(int object, int size, int level, long timeTaken)

    {

    int maxsize = ObjectList.getObject(object).getSizes().length;

    if( object>=0 && object<NUM_OBJECTS && size>=0 && size<maxsize && level>=1 && level<=MAX_LEVEL )

      {

      if( mRecords[object][size][level-1]> timeTaken )

        {

        mRecords  [object][size][level-1] = timeTaken;

        mSubmitted[object][size][level-1] = 0;

        return true;

        }

      }

    return false;

    }

  }