Magic Cube

import org.distorted.external.RubikFiles;

import org.distorted.external.RubikFiles;

import org.distorted.external.RubikScores;

import org.distorted.external.RubikScores;

import org.distorted.external.RubikNetwork;

import static org.distorted.external.RubikScores.LEVELS_SHOWN;

import org.distorted.external.RubikScores;

import static org.distorted.external.RubikNetwork.MAX_PLACES;

import org.distorted.external.RubikScores;

import org.distorted.external.RubikFiles;

import org.distorted.external.RubikNetwork;

import org.distorted.external.RubikUpdates;

import org.distorted.external.RubikNetwork;

import org.distorted.external.RubikUpdates;

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

// Copyright 2022 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.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.util.Locale;

import android.content.Context;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

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

public class RubikFiles

  {

  private static RubikFiles mThis;

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

  private RubikFiles()

    {

    }

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

// PUBLIC API

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

  public static RubikFiles getInstance()

    {

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

    return mThis;

    }

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

  public InputStream openFile(Context context, String name)

    {

    File file = new File(context.getFilesDir(), name);

    try

      {

      return new FileInputStream(file);

      }

    catch(FileNotFoundException ex)

      {

      android.util.Log.e("D", "file "+name+" not found: "+ex.getMessage());

      }

    return null;

    }

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

  public Bitmap getIcon(Context context, String name)

    {

    File dir  = context.getFilesDir();

    File file = new File(dir, name);

    if( file.exists() )

      {

      String fname = dir.getAbsolutePath()+"/"+name;

      return BitmapFactory.decodeFile(fname);

      }

    return null;

    }

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

  public boolean saveFile(Context context, InputStream stream, String name)

    {

    try

      {

      File file = new File(context.getFilesDir(), name);

      OutputStream outStream = new FileOutputStream(file);

      byte[] buffer = new byte[8*1024];

      int bytesRead;

      while ((bytesRead = stream.read(buffer)) != -1)

        {

        outStream.write(buffer, 0, bytesRead);

        }

      outStream.close();

      return true;

      }

    catch(IOException ioe)

      {

      android.util.Log.e("D", "Exception trying to save "+name+" : "+ioe.getMessage() );

      return false;

      }

    }

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

  public boolean saveIcon(Context context, Bitmap bmp, String name)

    {

    try

      {

      File file = new File(context.getFilesDir(), name);

      OutputStream outStream = new FileOutputStream(file);

      bmp.compress(Bitmap.CompressFormat.PNG, 100, outStream);

      outStream.close();

      return true;

      }

    catch(Exception e)

      {

      android.util.Log.e("D", "Exception trying to save "+name+" : "+e.getMessage() );

      return false;

      }

    }

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

  public void deleteIcon(Context context, String name)

    {

    String filename = name.toLowerCase(Locale.ENGLISH) + ".png";

    boolean success = context.deleteFile(filename);

    if( !success ) android.util.Log.e("D", "failed to delete "+filename);

    else android.util.Log.e("D", "successfully deleted "+filename);

    }

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

  public void deleteJsonObject(Context context, String name)

    {

    String filename = name.toLowerCase(Locale.ENGLISH) + "_object.json";

    boolean success = context.deleteFile(filename);

    if( !success ) android.util.Log.e("D", "failed to delete "+filename);

    else android.util.Log.e("D", "successfully deleted "+filename);

    }

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

  public void deleteJsonExtras(Context context, String name)

    {

    String filename = name.toLowerCase(Locale.ENGLISH) + "_extras.json";

    boolean success = context.deleteFile(filename);

    if( !success ) android.util.Log.e("D", "failed to delete "+filename);

    else android.util.Log.e("D", "successfully deleted "+filename);

    }

  }

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

// Copyright 2019 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.io.BufferedReader;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.net.HttpURLConnection;

import java.net.URL;

import java.net.UnknownHostException;

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

import java.util.ArrayList;

import android.app.Activity;

import android.content.Context;

import android.content.pm.PackageInfo;

import android.content.pm.PackageManager;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import org.distorted.objectlib.json.JsonWriter;

import org.distorted.objects.RubikObjectList;

import static org.distorted.objects.RubikObjectList.SHOW_DOWNLOADED_DEBUG;

import static org.distorted.external.RubikScores.LEVELS_SHOWN;

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

public class RubikNetwork

  {

  public interface ScoresReceiver

    {

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

    void message(String mess);

    void error(String error);

    }

  public interface IconReceiver

    {

    void iconDownloaded(int ordinal, Bitmap bitmap, boolean downloaded);

    }

  public interface Updatee

    {

    int getType();

    void receiveUpdate(RubikUpdates update);

    void objectDownloaded(String shortName);

    void errorUpdate();

    }

  public interface Downloadee

    {

    void jsonDownloaded();

    }

  public static final int MAX_PLACES = 10;

  private static final int UPDATES_RUNNING = 1;

  private static final int UPDATES_SUCCESS = 2;

  private static final int UPDATES_FAILURE = 3;

  private final String[] hex = {

    "%00", "%01", "%02", "%03", "%04", "%05", "%06", "%07",

    "%08", "%09", "%0a", "%0b", "%0c", "%0d", "%0e", "%0f",

    "%10", "%11", "%12", "%13", "%14", "%15", "%16", "%17",

    "%18", "%19", "%1a", "%1b", "%1c", "%1d", "%1e", "%1f",

    "%20", "%21", "%22", "%23", "%24", "%25", "%26", "%27",

    "%28", "%29", "%2a", "%2b", "%2c", "%2d", "%2e", "%2f",

    "%30", "%31", "%32", "%33", "%34", "%35", "%36", "%37",

    "%38", "%39", "%3a", "%3b", "%3c", "%3d", "%3e", "%3f",

    "%40", "%41", "%42", "%43", "%44", "%45", "%46", "%47",

    "%48", "%49", "%4a", "%4b", "%4c", "%4d", "%4e", "%4f",

    "%50", "%51", "%52", "%53", "%54", "%55", "%56", "%57",

    "%58", "%59", "%5a", "%5b", "%5c", "%5d", "%5e", "%5f",

    "%60", "%61", "%62", "%63", "%64", "%65", "%66", "%67",

    "%68", "%69", "%6a", "%6b", "%6c", "%6d", "%6e", "%6f",

    "%70", "%71", "%72", "%73", "%74", "%75", "%76", "%77",

    "%78", "%79", "%7a", "%7b", "%7c", "%7d", "%7e", "%7f",

    "%80", "%81", "%82", "%83", "%84", "%85", "%86", "%87",

    "%88", "%89", "%8a", "%8b", "%8c", "%8d", "%8e", "%8f",

    "%90", "%91", "%92", "%93", "%94", "%95", "%96", "%97",

    "%98", "%99", "%9a", "%9b", "%9c", "%9d", "%9e", "%9f",

    "%a0", "%a1", "%a2", "%a3", "%a4", "%a5", "%a6", "%a7",

    "%a8", "%a9", "%aa", "%ab", "%ac", "%ad", "%ae", "%af",

    "%b0", "%b1", "%b2", "%b3", "%b4", "%b5", "%b6", "%b7",

    "%b8", "%b9", "%ba", "%bb", "%bc", "%bd", "%be", "%bf",

    "%c0", "%c1", "%c2", "%c3", "%c4", "%c5", "%c6", "%c7",

    "%c8", "%c9", "%ca", "%cb", "%cc", "%cd", "%ce", "%cf",

    "%d0", "%d1", "%d2", "%d3", "%d4", "%d5", "%d6", "%d7",

    "%d8", "%d9", "%da", "%db", "%dc", "%dd", "%de", "%df",

    "%e0", "%e1", "%e2", "%e3", "%e4", "%e5", "%e6", "%e7",

    "%e8", "%e9", "%ea", "%eb", "%ec", "%ed", "%ee", "%ef",

    "%f0", "%f1", "%f2", "%f3", "%f4", "%f5", "%f6", "%f7",

    "%f8", "%f9", "%fa", "%fb", "%fc", "%fd", "%fe", "%ff"

    };

  private static final String SERVER="https://distorted.org/magic/cgi-bin/";

  private static String[][][] mCountry;

  private static String[][][] mName;

  private static int[][][] mTime;

  private static int[][] mPlaces;

  private static RubikNetwork mThis;

  private static String mScores = "";

  private static boolean mRunning = false;

  private static ArrayList<Updatee> mUpdateeList;

  private static String mVersion;

  private static int mNumObjects;

  private static RubikUpdates mUpdates;

  private static int mUpdatesState;

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

  private static void initializeStatics()

    {

    int newNum = RubikObjectList.getNumObjects();

    if( mCountry==null || newNum!=mNumObjects ) mCountry = new String[newNum][LEVELS_SHOWN+1][MAX_PLACES];

    if( mName==null    || newNum!=mNumObjects ) mName    = new String[newNum][LEVELS_SHOWN+1][MAX_PLACES];

    if( mTime==null    || newNum!=mNumObjects ) mTime    = new    int[newNum][LEVELS_SHOWN+1][MAX_PLACES];

    if( mPlaces==null  || newNum!=mNumObjects ) mPlaces  = new    int[newNum][LEVELS_SHOWN+1];

    if( mUpdates==null ) mUpdates = new RubikUpdates();

    mNumObjects = newNum;

    }

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

  private static String computeHash(String stringToHash, byte[] salt)

    {

    String generatedPassword;

    try

      {

      MessageDigest md = MessageDigest.getInstance("MD5");

      md.update(salt);

      byte[] bytes = md.digest(stringToHash.getBytes());

      StringBuilder sb = new StringBuilder();

      for (byte aByte : bytes)

        {

        sb.append(Integer.toString((aByte & 0xff) + 0x100, 16).substring(1));

        }

      generatedPassword = sb.toString();

      }

    catch (NoSuchAlgorithmException e)

      {

      return "NoSuchAlgorithm";

      }

    return generatedPassword;

    }

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

  private boolean fillValuesNormal(ScoresReceiver receiver)

    {

    int begin=-1 ,end, len = mScores.length();

    String row;

    if( len==0 )

      {

      receiver.error("1");

      return false;

      }

    else if( len<=2 )

      {

      receiver.error(mScores);

      return false;

      }

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

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

        {

        mPlaces[i][j] = 0;

        }

    while( begin<len )

      {

      end = mScores.indexOf('\n', begin+1);

      if( end<0 ) end = len;

      try

        {

        row = mScores.substring(begin+1,end);

        fillRow(row);

        }

      catch(Exception ex)

        {

        // faulty row - ignore

        }

      begin = end;

      }

    return true;

    }

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

  private void fillRow(String row)

    {

    int s1 = row.indexOf(' ');

    int s2 = row.indexOf(' ',s1+1);

    int s3 = row.indexOf(' ',s2+1);

    int s4 = row.indexOf(' ',s3+1);

    int s5 = row.length();

    if( s5>s4 && s4>s3 && s3>s2 && s2>s1 && s1>0 )

      {

      int object = RubikObjectList.getOrdinal( row.substring(0,s1) );

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

        {

        int level      = Integer.parseInt( row.substring(s1+1,s2) );

        String name    = row.substring(s2+1, s3);

        int time       = Integer.parseInt( row.substring(s3+1,s4) );

        String country = row.substring(s4+1, s5);

        if( country.equals("do") ) country = "dm"; // see RubikScores.setCountry()

        if( level>LEVELS_SHOWN ) level = LEVELS_SHOWN;

        if(level>=0)

          {

          int p = mPlaces[object][level];

          mPlaces[object][level]++;

          mCountry[object][level][p] = country;

          mName   [object][level][p] = name;

          mTime   [object][level][p] = time;

          }

        }

      }

    else

      {

      tryDoCommand(row);

      }

    }

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

  private void tryDoCommand(String row)

    {

    if( row.startsWith("comm") )

      {

      int colon = row.indexOf(':');

      if( colon>0 )

        {

        String commandNumber = row.substring(4,colon);

        int number;

        try

          {

          number = Integer.parseInt(commandNumber);

          }

        catch(NumberFormatException ex)

          {

          number=0;

          }

        if(number==1)

          {

          String country = row.substring(colon+1);

          RubikScores scores = RubikScores.getInstance();

          scores.setCountry(country);

          }

        }

      }

    }

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

  private String URLencode(String s)

    {

    StringBuilder sbuf = new StringBuilder();

    int len = s.length();

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

      {

      int ch = s.charAt(i);

           if ('A' <= ch && ch <= 'Z') sbuf.append((char)ch);

      else if ('a' <= ch && ch <= 'z') sbuf.append((char)ch);

      else if ('0' <= ch && ch <= '9') sbuf.append((char)ch);

      else if (ch == ' '             ) sbuf.append('+');

      else if (ch == '-' || ch == '_'

            || ch == '.' || ch == '!'

            || ch == '~' || ch == '*'

            || ch == '\'' || ch == '('

            || ch == ')'             ) sbuf.append((char)ch);

      else if (ch <= 0x007f)           sbuf.append(hex[ch]);

      else if (ch <= 0x07FF)

        {

        sbuf.append(hex[0xc0 | (ch >> 6)]);

        sbuf.append(hex[0x80 | (ch & 0x3F)]);

        }

      else

        {

        sbuf.append(hex[0xe0 | (ch >> 12)]);

        sbuf.append(hex[0x80 | ((ch >> 6) & 0x3F)]);

        sbuf.append(hex[0x80 | (ch & 0x3F)]);

        }

      }

    return sbuf.toString();

    }

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

  private boolean network(String url, ScoresReceiver receiver)

    {

    try

      {

      java.net.URL connectURL = new URL(url);

      HttpURLConnection conn = (HttpURLConnection)connectURL.openConnection();

      conn.setDoInput(true);

      conn.setDoOutput(true);

      conn.setUseCaches(false);

      conn.setRequestMethod("GET");

      conn.connect();

      conn.getOutputStream().flush();

      InputStream is = conn.getInputStream();

      BufferedReader r = new BufferedReader(new InputStreamReader(is));

      StringBuilder total = new StringBuilder();

      for (String line; (line = r.readLine()) != null; )

        {

        total.append(line).append('\n');

        }

      mScores = total.toString();

      conn.disconnect();

      }

    catch( final UnknownHostException e )

      {

      receiver.message("No access to Internet");

      return false;

      }

    catch( final SecurityException e )

      {

      receiver.message("Application not authorized to connect to the Internet");

      return false;

      }

    catch( final Exception e )

      {

      receiver.message(e.getMessage());

      return false;

      }

    if( mScores.length()==0 )

      {

      receiver.message("Failed to download scores");

      return false;

      }

    return true;

    }

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

  private String constructSuspiciousURL(String suspURL)

    {

    RubikScores scores = RubikScores.getInstance();

    int deviceID       = scores.getDeviceID();

    String suspicious  = URLencode(suspURL);

    return SERVER+"suspicious.cgi?i="+deviceID+"&d="+suspicious;

    }

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

  private String constructTokenURL(String token)

    {

    RubikScores scores = RubikScores.getInstance();

    String name = URLencode(scores.getName());

    int deviceID= scores.getDeviceID();

    String country = scores.getCountry();

    String version = mVersion==null ? "null" : mVersion;

    String tkn = URLencode(token);

    return SERVER+"token.cgi?n="+name+"&i="+deviceID+"&e="+version+"&c="+country+"&t="+tkn;

    }

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

  private String constructUpdatesURL()

    {

    RubikScores sco = RubikScores.getInstance();

    String name     = URLencode(sco.getName());

    int numRuns     = sco.getNumRuns();

    int numPlay     = sco.getNumPlays();

    String country  = sco.getCountry();

    int objectAPI   = JsonWriter.VERSION_OBJECT_APP;

    int tutorialAPI = JsonWriter.VERSION_EXTRAS_APP;

    String url=SERVER+"updates.cgi";

    url += "?n="+name+"&r="+numRuns+"&p="+numPlay+"&c="+country+"&e="+mVersion+"d"+"&a="+objectAPI+"&b="+tutorialAPI;

    return url;

    }

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

  private String constructDownloadURL()

    {

    RubikScores scores = RubikScores.getInstance();

    String name = URLencode(scores.getName());

    int numRuns = scores.getNumRuns();

    int numPlay = scores.getNumPlays();

    String country = scores.getCountry();

    return SERVER+"download.cgi?n="+name+"&r="+numRuns+"&p="+numPlay+"&c="+country+"&e="+mVersion;

    }

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

  private String constructSubmitURL()

    {

    RubikScores scores = RubikScores.getInstance();

    String name = URLencode(scores.getName());

    String veri = scores.isVerified() ? "1" : "";

    int numRuns = scores.getNumRuns();

    int numPlay = scores.getNumPlays();

    int deviceID= scores.getDeviceID();

    String reclist = scores.getRecordList("&o=","&l=","&t=");

    String country = scores.getCountry();

    long epoch = System.currentTimeMillis();

    String salt = "cuboid";

    String url1 = SERVER+"submit.cgi";

    String url2 = "n="+name+"&v="+veri+"&r="+numRuns+"&p="+numPlay+"&i="+deviceID+"&e="+mVersion;

    url2 += reclist+"&c="+country+"&f="+epoch;

    String hash = computeHash( url2, salt.getBytes() );

    return url1 + "?" + url2 + "&h=" + hash;

    }

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

  private boolean gottaDownload()

    {

    return ((mScores.length()==0) && !mRunning);

    }

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

  private void figureOutVersion(Activity act)

    {

    if( mVersion==null )

      {

      try

        {

        PackageInfo pInfo = act.getPackageManager().getPackageInfo( act.getPackageName(), 0);

        mVersion = pInfo.versionName;

        }

      catch (PackageManager.NameNotFoundException e)

        {

        mVersion = "0.9.2";

        }

      }

    }

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

  private void downloadThread(ScoresReceiver receiver)

    {

    boolean receiveValues=true;

    try

      {

      if( gottaDownload() )

        {

        mRunning = true;

        receiveValues = network(constructDownloadURL(),receiver);

        if( mRunning )

          {

          receiveValues = fillValuesNormal(receiver);

          mRunning = false;

          }

        }

      if( receiveValues ) receiver.receive(mCountry, mName, mTime);

      }

    catch( Exception e )

      {

      receiver.message("Exception downloading records: "+e.getMessage() );

      }

    }

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

  private void submitThread(ScoresReceiver receiver)

    {

    try

      {

      mRunning = true;

      RubikScores scores = RubikScores.getInstance();

      if( scores.thereAreUnsubmittedRecords() )

        {

        boolean receiveValues = network(constructSubmitURL(),receiver);

        if( mRunning )

          {

          receiveValues = fillValuesNormal(receiver);

          mRunning = false;

          }

        if( receiveValues )

          {

          RubikScores.getInstance().successfulSubmit();

          receiver.receive(mCountry, mName, mTime);

          }

        }

      }

    catch( Exception e )

      {

      receiver.message("Exception submitting records: "+e.getMessage() );

      }

    }

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

  private void updatesThread()

    {

    String url = constructUpdatesURL();

    try

      {

      java.net.URL connectURL = new URL(url);

      HttpURLConnection conn = (HttpURLConnection)connectURL.openConnection();

      conn.setDoInput(true);

      conn.setDoOutput(true);

      conn.setUseCaches(false);

      conn.setRequestMethod("GET");

      conn.connect();

      conn.getOutputStream().flush();

      InputStream is = conn.getInputStream();

      BufferedReader r = new BufferedReader(new InputStreamReader(is));

      StringBuilder answer = new StringBuilder();

      for( String line; (line = r.readLine()) != null; )

        {

        answer.append(line).append('\n');

        }

      String updates = answer.toString();

      conn.disconnect();

      mUpdates.parse(updates);

      if( mUpdateeList!=null )

        {

        int numUpdatees = mUpdateeList.size();

        for(int u=0; u<numUpdatees; u++)

          {

          Updatee upd = mUpdateeList.get(u);

          upd.receiveUpdate(mUpdates);

          }

        }

      mUpdatesState = UPDATES_SUCCESS;

      }

    catch( final Exception e )

      {

      if( mUpdateeList!=null )

        {

        int numUpdatees = mUpdateeList.size();

        for(int u=0; u<numUpdatees; u++)

          {

          Updatee upd = mUpdateeList.get(u);

          upd.errorUpdate();

          }

        }

      mUpdatesState = UPDATES_FAILURE;

      }

    }

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

  private void suspiciousThread(String suspURL)

    {

    String url = constructSuspiciousURL(suspURL);

    try

      {

      java.net.URL connectURL = new URL(url);

      HttpURLConnection conn = (HttpURLConnection)connectURL.openConnection();

      conn.setDoInput(true);

      conn.setDoOutput(true);

      conn.setUseCaches(false);

      conn.setRequestMethod("GET");

      conn.connect();

      conn.getOutputStream().flush();

      conn.getInputStream();

      conn.disconnect();

      }

    catch( final Exception e )

      {

      // ignore

      }

    }

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

  private void tokenThread(String token)

    {

    String url = constructTokenURL(token);

    try

      {

      java.net.URL connectURL = new URL(url);

      HttpURLConnection conn = (HttpURLConnection)connectURL.openConnection();

      conn.setDoInput(true);

      conn.setDoOutput(true);

      conn.setUseCaches(false);

      conn.setRequestMethod("GET");

      conn.connect();

      conn.getOutputStream().flush();

      conn.getInputStream();

      conn.disconnect();

      }

    catch( final Exception e )

      {

      // ignore

      }

    }

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

  private Bitmap downloadIcon(String url)

    {

    try

      {

      java.net.URL connectURL = new URL(url);

      HttpURLConnection conn = (HttpURLConnection) connectURL.openConnection();

      conn.setDoInput(true);

      conn.connect();

      InputStream input = conn.getInputStream();

      Bitmap icon = BitmapFactory.decodeStream(input);

      conn.disconnect();

      return icon;

      }

    catch (IOException e)

      {

      android.util.Log.e("D", "Failed to download "+url);

      android.util.Log.e("D", e.getMessage() );

      return null;

      }

    }

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

  private void iconThread(Context context, IconReceiver receiver)

    {

    int numC = mUpdates.getCompletedNumber();

    int numS = mUpdates.getStartedNumber();

    for(int c=0; c<numC; c++)

      {

      int iconPresent = mUpdates.getCompletedIconPresent(c);

      if( iconPresent!=0 )

        {

        boolean downloaded = false;

        Bitmap icon = mUpdates.getCompletedIcon(context,c);

        if( icon==null )

          {

          String url = mUpdates.getCompletedURL(c);

          icon = downloadIcon(url);

          downloaded = true;

          if( SHOW_DOWNLOADED_DEBUG ) android.util.Log.e("D", "Downloading icon "+url);

          }

        if( icon!=null )

          {

          mUpdates.setCompletedIcon(c,icon);

          receiver.iconDownloaded(c,icon,downloaded);

          }

        }

      }

    for(int s=0; s<numS; s++)

      {

      int iconPresent = mUpdates.getStartedIconPresent(s);

      if( iconPresent!=0 )

        {

        boolean downloaded = false;

        Bitmap icon = mUpdates.getStartedIcon(context,s);

        if( icon==null )

          {

          String url = mUpdates.getStartedURL(s);

          icon = downloadIcon(url);

          downloaded = true;

          if( SHOW_DOWNLOADED_DEBUG ) android.util.Log.e("D", "Downloading icon "+url);

          }

        if( icon!=null )

          {

          mUpdates.setStartedIcon(s,icon);

          receiver.iconDownloaded(numC+s,icon,downloaded);

          }

        }

      }

    }

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

  private InputStream downloadJSON(String name)

    {

    String url = mUpdates.getURL() + name;

    try

      {

      if( SHOW_DOWNLOADED_DEBUG ) android.util.Log.e("D", "Downloading JSON "+url);

      java.net.URL connectURL = new URL(url);

      HttpURLConnection conn = (HttpURLConnection) connectURL.openConnection();

      conn.setDoInput(true);

      conn.connect();

      return conn.getInputStream();

      }

    catch (IOException e)

      {

      android.util.Log.e("D", "Failed to download "+url);

      android.util.Log.e("D", e.getMessage() );

      return null;

      }

    }

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

  private void jsonThread(final RubikUpdates.UpdateInfo info, Downloadee downloadee)

    {

    if(info.mUpdateObject) info.mObjectStream = downloadJSON(info.mObjectShortName+"_object.json");

    if(info.mUpdateExtras) info.mExtrasStream = downloadJSON(info.mObjectShortName+"_extras.json");

    downloadee.jsonDownloaded();

    try

      {

      if( info.mObjectStream!=null ) info.mObjectStream.close();

      }

    catch(IOException ioe)

      {

      android.util.Log.e("D", "failed to close object input stream");

      }

    try

      {

      if( info.mExtrasStream!=null ) info.mExtrasStream.close();

      }

    catch(IOException ioe)

      {

      android.util.Log.e("D", "failed to close extras input stream");

      }

    }

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

  private RubikNetwork()

    {

    }

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

// PUBLIC API

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

  public static void onPause()

    {

    mRunning = false;

    mUpdateeList.clear();

    }

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

  public static RubikNetwork getInstance()

    {

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

    return mThis;

    }

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

  public void download(final ScoresReceiver receiver, final Activity act)

    {

    initializeStatics();

    figureOutVersion(act);

    Thread thread = new Thread()

      {

      public void run()

        {

        downloadThread(receiver);

        }

      };

    thread.start();

    }

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

  public void submit(ScoresReceiver receiver, final Activity act)

    {

    initializeStatics();

    figureOutVersion(act);

    Thread thread = new Thread()

      {

      public void run()

        {

        submitThread(receiver);

        }

      };

    thread.start();

    }

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

  public void downloadUpdates(final Activity act)

    {

    initializeStatics();

    figureOutVersion(act);

    mUpdatesState = UPDATES_RUNNING;

    Thread thread = new Thread()

      {

      public void run()

        {

        updatesThread();

        }

      };

    thread.start();

    }

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

  public void suspicious(final String suspicious, final Activity act)

    {

    initializeStatics();

    figureOutVersion(act);

    Thread thread = new Thread()

      {

      public void run()

        {

        suspiciousThread(suspicious);

        }

      };

    thread.start();

    }

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

  public void token(final String token)

    {

    initializeStatics();

    Thread thread = new Thread()

      {

      public void run()

        {

        tokenThread(token);

        }

      };

    thread.start();

    }

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

  public void signUpForUpdates(Updatee updatee)

    {

    if( mUpdateeList==null ) mUpdateeList = new ArrayList<>();

    int numUpdatees = mUpdateeList.size();

    int type = updatee.getType();

    for(int u=0; u<numUpdatees; u++)

      {

      Updatee upd = mUpdateeList.get(u);

      if( upd.getType()==type )

        {

        mUpdateeList.remove(u);

        break;

        }

      }

    mUpdateeList.add(updatee);

    if( mUpdatesState==UPDATES_SUCCESS )

      {

      updatee.receiveUpdate(mUpdates);

      }

    else if( mUpdatesState==UPDATES_FAILURE )

      {

      updatee.errorUpdate();

      }

    }

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

  public void downloadIcons(final Context context, final IconReceiver receiver)

    {

    initializeStatics();

    Thread thread = new Thread()

      {

      public void run()

        {

        iconThread(context,receiver);

        }

      };

    thread.start();

    }

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

  public void downloadJSON(final RubikUpdates.UpdateInfo info, final Downloadee downloadee)

    {

    initializeStatics();

    Thread thread = new Thread()

      {

      public void run()

        {

        jsonThread(info,downloadee);

        }

      };

    thread.start();

    }

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

  public void updateDone(String shortName)

    {

    mUpdates.updateDone(shortName);

    mScores = "";

    if( mUpdateeList!=null )

      {

      int numUpdatees = mUpdateeList.size();

      for(int u=0; u<numUpdatees; u++)

        {

        Updatee upd = mUpdateeList.get(u);

        upd.objectDownloaded(shortName);

        }

      }

    }

}

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

// 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.metadata.ListObjects.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;

  private 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<0 ? MULT-1 : 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);

      int level = key%MULT;

      if( level<MULT-1 && 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(level);

          builderTim.append(value.record);

          }

        }

      }

    return strObj+builderObj+strLvl+builderLvl+strTim+builderTim;

    }

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

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

    }