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.external;

import java.util.HashMap;

import java.util.UUID;

import android.content.Context;

import android.content.SharedPreferences;

import android.telephony.TelephonyManager;

import com.google.firebase.crashlytics.FirebaseCrashlytics;

import org.distorted.main.BuildConfig;

import org.distorted.objects.RubikObject;

import org.distorted.objects.RubikObjectList;

import static org.distorted.objectlib.main.ObjectType.MAX_SCRAMBLES;

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

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

public class RubikScores

  {

  public static final int LEVELS_SHOWN   = 8;

  public static final int RECORD_FIRST   = 0;

  public static final int RECORD_NEW     = 1;

  public static final int RECORD_NOT_NEW = 2;

  public static final int MAX_RECORD = 10;

  public static final int MULT = 1000000;

  public static final int NO_RECORD = Integer.MAX_VALUE;

  private static RubikScores mThis;

  private String mName, mCountry;

  private boolean mNameIsVerified;

  private int mNumRuns;

  private int mNumPlays;

  private int mNumWins;

  private int mDeviceID;

  private int mNumStars;

  private static class MapValue

    {

    int record;

    boolean submitted;

    MapValue(int rec,int sub)

      {

      record    = rec;

      submitted = sub!=0;

      }

    }

  private final HashMap<Integer,MapValue> mMap;

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

  private RubikScores()

    {

    mMap = new HashMap<>();

    mName = "";

    mCountry = "un";

    mNameIsVerified = false;

    mNumPlays= -1;

    mNumRuns = -1;

    mDeviceID= -1;

    mNumWins =  0;

    mNumStars=  0;

    }

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

  private int mapKey(int object,int level)

    {

    return object*MULT + level;

    }

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

  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 key: mMap.keySet())

      {

      MapValue value = mMap.get(key);

      if( value!=null ) value.submitted = true;

      }

    }

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

  int getDeviceID()

    {

    return mDeviceID;

    }

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

  synchronized boolean thereAreUnsubmittedRecords()

    {

    for(int key: mMap.keySet())

      {

      MapValue value = mMap.get(key);

      if( value!=null && !value.submitted && value.record<NO_RECORD) return true;

      }

    return false;

    }

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

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

    {

    StringBuilder builderObj = new StringBuilder();

    StringBuilder builderLvl = new StringBuilder();

    StringBuilder builderTim = new StringBuilder();

    boolean first = true;

    for(int key: mMap.keySet())

      {

      MapValue value = mMap.get(key);

      if( value!=null && !value.submitted && value.record<NO_RECORD)

        {

        if( !first )

          {

          builderObj.append(',');

          builderLvl.append(',');

          builderTim.append(',');

          }

        first=false;

        RubikObject object = RubikObjectList.getObject(key/MULT);

        if( object!=null )

          {

          builderObj.append(object.getUpperName());

          builderLvl.append(key%MULT);

          builderTim.append(value.record);

          }

        }

      }

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

    }

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

// Public API

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

  public boolean isVerified()

    {

    return mNameIsVerified;

    }

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

  public int getNumPlays()

    {

    return mNumPlays;

    }

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

  public int getNumRuns()

    {

    return mNumRuns;

    }

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

  public String getName()

    {

    return mName;

    }

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

  public String getCountry()

    {

    return mCountry;

    }

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

  public void incrementNumPlays()

    {

    mNumPlays++;

    }

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

  public void incrementNumRuns()

    {

    mNumRuns++;

    }

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

  public int incrementNumWins()

    {

    mNumWins++;

    return mNumWins;

    }

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

  public void changeNumStars(int stars)

    {

    mNumStars += stars;

    if( mNumStars<0 ) mNumStars = 0;

    }

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

  public int getNumStars()

    {

    return mNumStars;

    }

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

  public void correctNumStars()

    {

    int numObjects = RubikObjectList.getNumObjects();

    for(int obj=0; obj<numObjects; obj++)

      {

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

        {

        if( isSolved(obj,level) )

          {

          int numStars = computeNumStars(level+1);

          mNumStars += numStars;

          }

        }

      }

    }

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

  public int computeNumStars(int level)

    {

    return level>LEVELS_SHOWN ? 50 : level;

    }

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

  public void setName(String newName)

    {

    mName = newName;

    }

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

  public synchronized int setRecord(int object, int level, int record)

    {

    int key = mapKey(object,level);

    MapValue oldValue = mMap.get(key);

    if( oldValue==null )

      {

      MapValue value = new MapValue(record,0);

      mMap.put(key,value);

      return RECORD_FIRST;

      }

    long oldRecord = oldValue.record;

    if( oldRecord>record)

      {

      MapValue value = new MapValue(record,0);

      mMap.put(key,value);

      return RECORD_NEW;

      }

    return RECORD_NOT_NEW;

    }

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

  public synchronized int getRecord(int object, int level)

    {

    int key = mapKey(object,level);

    MapValue value = mMap.get(key);

    return value!=null ? value.record : NO_RECORD;

    }

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

  public synchronized boolean isSolved(int object, int level)

    {

    int key = mapKey(object,level);

    MapValue value = mMap.get(key);

    return value!=null && value.record<NO_RECORD;

    }

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

  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 void setCountry(String country)

    {

    mCountry = country;

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

    }

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

  public static RubikScores getInstance()

    {

    if( mThis==null ) mThis = new RubikScores();

    return mThis;

    }

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

  public synchronized void savePreferences(SharedPreferences.Editor editor)

    {

    int numObjects = RubikObjectList.getNumObjects();

    StringBuilder builder = new StringBuilder();

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

      {

      builder.setLength(0);

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

        {

        int key = mapKey(object,level);

        RubikObject obj = RubikObjectList.getObject(object);

        MapValue value = mMap.get(key);

        if( obj!=null && value!=null && value.record<NO_RECORD )

          {

          builder.append(obj.getUpperName());

          builder.append("=");

          builder.append(value.record);

          builder.append(",");

          builder.append(value.submitted ? 1:0 );

          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"  , mNumWins );   // legacy name

    editor.putInt("scores_numStars", mNumStars );

    }

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

  public synchronized void savePreferencesMinimal(SharedPreferences.Editor editor)

    {

    editor.putInt("scores_numStars", mNumStars );

    }

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

  public synchronized void restorePreferences(SharedPreferences preferences)

    {

    String recordStr, subStr, nameStr, timeStr, submStr, errorStr="";

    int start, end, equals, comma, ordinal, subm, time;

    boolean thereWasError = false;

    int numObjects = RubikObjectList.getNumObjects();

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

      {

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

      if( recordStr==null ) continue;

      start = end = 0;

      while( end!=-1 )

        {

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

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

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

        start = end+1;

        equals = subStr.indexOf("=");

        comma  = subStr.indexOf(",");

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

          {

          nameStr = subStr.substring(0,equals);

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

          submStr = subStr.substring(comma+1);

          ordinal = RubikObjectList.getOrdinal(nameStr);

          if( ordinal>=0 && ordinal<numObjects )

            {

            try

              {

              time = Integer.parseInt(timeStr);

              subm = Integer.parseInt(submStr);

              }

            catch(NumberFormatException ex)

              {

              subm = 1;

              time = 0;

              errorStr += ("error1: timeStr="+timeStr+" submStr: "+submStr+"\n");

              thereWasError= true;

              }

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

              {

              MapValue value = new MapValue(time,subm);

              int key = mapKey(ordinal,level);

              mMap.put(key,value);

              }

            else

              {

              errorStr += ("error1: subm="+subm+" obj: "+nameStr+"\n");

              thereWasError= true;

              }

            }

          else

            {

            errorStr += ("error2: object="+ordinal+" obj: "+nameStr+"\n");

            thereWasError = true;

            }

          }

        }

      }

    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);

    mNumWins        = preferences.getInt("scores_review"  , 0);

    mNumStars       = preferences.getInt("scores_numStars", 0);

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

    if( thereWasError ) recordDBError(errorStr);

    }

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

  public int numberOfSolvedMAXes()

    {

    int numObjects = RubikObjectList.getNumObjects();

    int ret=0;

    for(int obj=0; obj<numObjects; obj++)

      {

      if( isSolved(obj,LEVELS_SHOWN) ) ret++;

      }

    return ret;

    }

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

  public void recordDBError(String message)

    {

    if( BuildConfig.DEBUG )

      {

      android.util.Log.e("scores", message);

      }

    else

      {

      Exception ex = new Exception(message);

      FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

      crashlytics.setCustomKey("scores" , message);

      crashlytics.recordException(ex);

      }

    }

  }