TwistyPuzzleLib

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

// Copyright 2021 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// Distorted 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.                                                           //

//                                                                                               //

// Distorted 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 Distorted.  If not, see <http://www.gnu.org/licenses/>.                            //

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

package org.distorted.objectlib.json;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.nio.charset.StandardCharsets;

import android.content.Context;

import org.distorted.objectlib.helpers.ObjectFaceShape;

import org.distorted.objectlib.helpers.ObjectSignature;

import org.distorted.objectlib.helpers.ObjectStickerOverride;

import org.distorted.objectlib.main.Cubit;

import org.distorted.objectlib.objects.TwistyBandagedCuboid;

import org.json.JSONArray;

import org.json.JSONException;

import org.json.JSONObject;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.helpers.ObjectShape;

import org.distorted.objectlib.helpers.ObjectSticker;

import org.distorted.objectlib.scrambling.ScrambleState;

import org.distorted.objectlib.main.ObjectType;

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

public class JsonReader

{

  private ScrambleState[] mStates;

  private int[][] mSolvedQuats;

  private Static4D[] mQuats;

  private int mSolvedFuncIndex;

  private int mNumStickerTypes;

  private float[][] mCuts;

  private boolean[][] mLayerRotatable;

  private int mMovementType, mMovementSplit;

  private int[][][] mEnabled;

  private float[] mDist3D;

  private int mNumCubitFaces, mNumFaces, mNumFaceColors;

  private float[][] mPositions;

  private ObjectShape[] mShapes;

  private ObjectFaceShape[] mFaceShapes;

  private Static4D[] mCubitQuats;

  private int mNumCubitVariants;

  private int[] mCubitVariant;

  private int[][] mVariantFaceColor, mVariantFaceIsOuter, mCubitFaceColor;

  private ObjectSticker[] mObjectSticker;

  private Static3D[] mAxis;

  private int[][] mBasicAngle;

  private String mLongName, mShortName, mInventor;

  private int mYearOfInvention, mComplexity;

  private int[] mNumLayers;

  private float mSize;

  private int mScrambleType, mNumScrambles;

  private int[] mColor;

  private int mInternalColor;

  private boolean mResetMaps;

  private String mTutorialObject;

  private String[][] mTutorials;

  private ObjectSignature mSignature;

  private int[] mCubitType;

  private float[][] mCubitRowOffset;

  private ObjectStickerOverride[] mStickerOverrides;

  private static JsonReader mThis;

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

  private JsonReader()

    {

    }

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

  public static JsonReader getInstance()

    {

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

    return mThis;

    }

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

  private void parseMetadata1(JSONObject object) throws JSONException

    {

    mLongName        = object.getString("longname");

    mShortName       = object.getString("shortname");

    mInventor        = object.getString("inventor");

    mYearOfInvention = object.getInt("year");

    mComplexity      = object.getInt("complexity");

    mSize            = (float)object.getDouble("size");

    mNumScrambles    = object.getInt("scrambles");

    mResetMaps       = object.getBoolean("resetmaps");

    mNumFaces        = object.getInt("num_faces");

    try

      {

      long signature = object.getLong("signature");

      mSignature = new ObjectSignature(signature);

      }

    catch(JSONException ex)

      {

      // objects older than Feb 2022 do not have the 'signature' field. They all use the ObjectType.ordinal

      // as their signature.

      long signature = ObjectType.getOrdinal(mShortName);

      mSignature = new ObjectSignature(signature);

      }

    }

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

  private void parseMetadata2or3or4(JSONObject object) throws JSONException

    {

    mLongName        = object.getString("longname");

    mShortName       = object.getString("shortname");

    mInventor        = object.getString("inventor");

    mYearOfInvention = object.getInt("year");

    mComplexity      = object.getInt("complexity");

    mSize            = (float)object.getDouble("size");

    mNumScrambles    = object.getInt("scrambles");

    mResetMaps       = object.getBoolean("resetmaps");

    mNumFaces        = object.getInt("num_faces");

    try

      {

      long signature1 = object.getLong("signature1");

      long signature2 = object.getLong("signature2");

      long signature3 = object.getLong("signature3");

      switch( TwistyBandagedCuboid.getType(mShortName,mLongName) )

        {

        case 0: mSignature = new ObjectSignature(signature1,signature2,signature3); break;

        case 1: mSignature = new ObjectSignature(mShortName,signature1,signature2,signature3); break;

        case 2: mSignature = new ObjectSignature("333",signature1,signature2,signature3); break;

        }

      }

    catch(JSONException ex)

      {

      long signature = object.getLong("signature");

      mSignature = new ObjectSignature(signature);

      }

    }

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

  private void parseCubits(JSONArray object) throws JSONException

    {

    int numCubits = object.length();

    mCubitQuats     = new Static4D[numCubits];

    mCubitVariant   = new int[numCubits];

    mPositions      = new float[numCubits][];

    mCubitFaceColor = new int[numCubits][];

    mCubitType      = new int[numCubits];

    mCubitRowOffset = new float[numCubits][];

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

      {

      JSONObject jsonCubit = object.getJSONObject(i);

      float qx = (float)jsonCubit.getDouble("qx");

      float qy = (float)jsonCubit.getDouble("qy");

      float qz = (float)jsonCubit.getDouble("qz");

      float qw = (float)jsonCubit.getDouble("qw");

      mCubitQuats[i] = new Static4D(qx,qy,qz,qw);

      mCubitVariant[i] = jsonCubit.getInt("variant");

      JSONArray jsonCenter = jsonCubit.getJSONArray("centers");

      int numCenter = jsonCenter.length();

      mPositions[i] = new float[numCenter];

      for(int j=0; j<numCenter; j++) mPositions[i][j] = (float)jsonCenter.getDouble(j);

      JSONArray jsonColor  = jsonCubit.getJSONArray("colors");

      int numColor = jsonColor.length();

      mCubitFaceColor[i] = new int[numColor];

      for(int j=0; j<numColor; j++) mCubitFaceColor[i][j] = jsonColor.getInt(j);

      mCubitType[i] = (int)jsonCubit.optInt("type", Cubit.TYPE_NORMAL);

      float xoff = (float)jsonCubit.optDouble("offsetX", 0 );

      float yoff = (float)jsonCubit.optDouble("offsetY", 0 );

      float zoff = (float)jsonCubit.optDouble("offsetZ", 0 );

      mCubitRowOffset[i] = new float[] {xoff,yoff,zoff};

      }

    }

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

  private void parseShapes(JSONArray object) throws JSONException

    {

    mNumCubitVariants     = object.length();

    mVariantFaceColor     = new int[mNumCubitVariants][];

    mVariantFaceIsOuter   = new int[mNumCubitVariants][];

    mShapes               = new ObjectShape[mNumCubitVariants];

    mFaceShapes           = new ObjectFaceShape[mNumCubitVariants];

    float[][][] verts     = new float[mNumCubitVariants][][];

    float[][][] bands     = new float[mNumCubitVariants][][];

    float[][][] corners   = new float[mNumCubitVariants][][];

    float[][][] centers   = new float[mNumCubitVariants][][];

    float[][] convexity   = new float[mNumCubitVariants][];

    int[][] cornerIndices = new int[mNumCubitVariants][];

    int[][] centerIndices = new int[mNumCubitVariants][];

    int[][] bandIndices   = new int[mNumCubitVariants][];

    int[][][] vertIndices = new int[mNumCubitVariants][][];

    mNumCubitFaces = -1;

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

      {

      JSONObject jsonShape = object.getJSONObject(i);

      ////// vertices /////////////////////////////////////////////////

      JSONArray jsonVertices= jsonShape.getJSONArray("vertices");

      int numVertices = jsonVertices.length();

      verts[i] = new float[numVertices][3];

      cornerIndices[i] = new int[numVertices];

      centerIndices[i] = new int[numVertices];

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

        {

        JSONObject vert = jsonVertices.getJSONObject(j);

        verts[i][j][0] = (float)vert.getDouble("x");

        verts[i][j][1] = (float)vert.getDouble("y");

        verts[i][j][2] = (float)vert.getDouble("z");

        cornerIndices[i][j] = vert.getInt("cornerIndex");

        centerIndices[i][j] = vert.getInt("centerIndex");

        }

      ////// faces ////////////////////////////////////////////////////

      JSONArray jsonFaces= jsonShape.getJSONArray("faces");

      int numFaces = jsonFaces.length();

      mVariantFaceColor[i]   = new int[numFaces];

      mVariantFaceIsOuter[i] = new int[numFaces];

      bandIndices[i] = new int[numFaces];

      vertIndices[i] = new int[numFaces][];

      if( mNumCubitFaces<numFaces ) mNumCubitFaces=numFaces;

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

        {

        JSONObject jsonFace = jsonFaces.getJSONObject(j);

        mVariantFaceColor[i][j]   = jsonFace.getInt("sticker");

        mVariantFaceIsOuter[i][j] = jsonFace.optInt("isOuter",0);

        bandIndices[i][j] = jsonFace.getInt("bandIndex");

        JSONArray vertices = jsonFace.getJSONArray("vertexIndices");

        int numV = vertices.length();

        vertIndices[i][j] = new int[numV];

        for(int k=0; k<numV; k++) vertIndices[i][j][k] = vertices.getInt(k);

        }

      ////// bands ////////////////////////////////////////////////////

      JSONArray jsonBands= jsonShape.getJSONArray("bands");

      int numBands = jsonBands.length();

      bands[i] = new float[numBands][7];

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

        {

        JSONObject jsonBand = jsonBands.getJSONObject(j);

        bands[i][j][0] = (float)jsonBand.getDouble("height");

        bands[i][j][1] = (float)jsonBand.getDouble("angle");

        bands[i][j][2] = (float)jsonBand.getDouble("distanceToCenter");

        bands[i][j][3] = (float)jsonBand.getDouble("distanceToFlat");

        bands[i][j][4] = (float)jsonBand.getDouble("numOfBands");

        bands[i][j][5] = (float)jsonBand.getDouble("extraI");

        bands[i][j][6] = (float)jsonBand.getDouble("extraJ");

        }

      ////// cornerPush ///////////////////////////////////////////////

      JSONArray jsonCornerPush= jsonShape.optJSONArray("cornerPush");

      if( jsonCornerPush!=null )

        {

        int numCornerP = jsonCornerPush.length();

        corners[i] = new float[numCornerP][2];

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

          {

          JSONObject jsonC = jsonCornerPush.getJSONObject(j);

          corners[i][j][0] = (float)jsonC.getDouble("strength");

          corners[i][j][1] = (float)jsonC.getDouble("radius");

          }

        }

      ////// centerPush ///////////////////////////////////////////////

      JSONArray jsonCenterPush= jsonShape.optJSONArray("centerPush");

      if( jsonCenterPush!=null )

        {

        int numCenterP = jsonCenterPush.length();

        centers[i] = new float[numCenterP][3];

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

          {

          JSONObject jsonC = jsonCenterPush.getJSONObject(j);

          centers[i][j][0] = (float)jsonC.getDouble("x");

          centers[i][j][1] = (float)jsonC.getDouble("y");

          centers[i][j][2] = (float)jsonC.getDouble("z");

          }

        }

      ////// convexity ///////////////////////////////////////////////

      JSONObject jsonConvexity = jsonShape.optJSONObject("convexity");

      if( jsonConvexity!=null )

        {

        convexity[i] = new float[3];

        convexity[i][0] = (float)jsonConvexity.getDouble("x");

        convexity[i][1] = (float)jsonConvexity.getDouble("y");

        convexity[i][2] = (float)jsonConvexity.getDouble("z");

        }

      }

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

      {

      mShapes[i] = new ObjectShape(verts[i],vertIndices[i]);

      mFaceShapes[i] = new ObjectFaceShape(bands[i],bandIndices[i],corners[i],cornerIndices[i],centers[i],centerIndices[i],convexity[i] );

      }

    }

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

  private void parseStickers(JSONArray object) throws JSONException

    {

    mNumStickerTypes = object.length();

    mObjectSticker = new ObjectSticker[mNumStickerTypes];

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

      {

      JSONObject sticker = object.getJSONObject(i);

      float stroke = (float)sticker.getDouble("stroke");

      JSONArray vertices = sticker.getJSONArray("vertices");

      int numVertices = vertices.length();

      float[] coords     = new float[2*numVertices];

      float[] curvatures = new float[numVertices];

      float[] radii      = new float[numVertices];

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

        {

        JSONObject vertex = vertices.getJSONObject(j);

        coords[2*j  ] = (float)vertex.getDouble("x");

        coords[2*j+1] = (float)vertex.getDouble("y");

        curvatures[j] = (float)vertex.getDouble("angle");

        radii[j]      = (float)vertex.getDouble("radius");

        }

      mObjectSticker[i] = new ObjectSticker(coords,curvatures,radii,stroke);

      }

    }

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

  private void parseOverrides(JSONArray object) throws JSONException

    {

    int numOverrides = object.length();

    mStickerOverrides= new ObjectStickerOverride[numOverrides];

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

      {

      JSONObject override = object.getJSONObject(i);

      int cubit = override.getInt("cubit");

      int face  = override.getInt("face");

      int color = override.getInt("color");

      mStickerOverrides[i] = new ObjectStickerOverride(cubit,face,color);

      }

    }

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

  private void parseMesh(JSONObject object) throws JSONException

    {

    JSONArray cubits   = object.getJSONArray("cubits");

    parseCubits(cubits);

    JSONArray shapes   = object.getJSONArray("shapes");

    parseShapes(shapes);

    JSONArray stickers = object.getJSONArray("stickers");

    parseStickers(stickers);

    JSONArray overrides= object.optJSONArray("overrides");

    if( overrides!=null ) parseOverrides(overrides);

    }

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

  private void parseAxis1(JSONArray object) throws JSONException

    {

    int numAxis = object.length();

    mBasicAngle     = new int[numAxis][];

    mAxis           = new Static3D[numAxis];

    mCuts           = new float[numAxis][];

    mLayerRotatable = new boolean[numAxis][];

    mNumLayers      = new int[numAxis];

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

      {

      JSONObject jsonAx = object.getJSONObject(i);

      float x = (float)jsonAx.getDouble("x");

      float y = (float)jsonAx.getDouble("y");

      float z = (float)jsonAx.getDouble("z");

      mAxis[i] = new Static3D(x,y,z);

      JSONArray jsonCuts = jsonAx.getJSONArray("cuts");

      int numCuts = jsonCuts.length();

      mCuts[i] = new float[numCuts];

      for(int j=0; j<numCuts; j++) mCuts[i][j] = (float)jsonCuts.getDouble(j);

      JSONArray jsonRota = jsonAx.getJSONArray("rotatable");

      int numRota = jsonRota.length();

      mLayerRotatable[i] = new boolean[numRota];

      for(int j=0; j<numRota; j++) mLayerRotatable[i][j] = jsonRota.getBoolean(j);

      mBasicAngle[i] = new int[numRota];

      int basicAngle = jsonAx.getInt("basicAngle");

      for(int j=0; j<numRota; j++) mBasicAngle[i][j] = basicAngle;

      mNumLayers[i] = numRota;

      }

    }

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

  private void parseAxis2or3or4(JSONArray object) throws JSONException

    {

    int numAxis = object.length();

    mBasicAngle     = new int[numAxis][];

    mAxis           = new Static3D[numAxis];

    mCuts           = new float[numAxis][];

    mLayerRotatable = new boolean[numAxis][];

    mNumLayers      = new int[numAxis];

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

      {

      JSONObject jsonAx = object.getJSONObject(i);

      float x = (float)jsonAx.getDouble("x");

      float y = (float)jsonAx.getDouble("y");

      float z = (float)jsonAx.getDouble("z");

      mAxis[i] = new Static3D(x,y,z);

      JSONArray jsonAngles = jsonAx.getJSONArray("basicAngles");

      int numAngles = jsonAngles.length();

      mBasicAngle[i] = new int[numAngles];

      for(int j=0; j<numAngles; j++) mBasicAngle[i][j] = jsonAngles.getInt(j);

      JSONArray jsonCuts = jsonAx.getJSONArray("cuts");

      int numCuts = jsonCuts.length();

      mCuts[i] = new float[numCuts];

      for(int j=0; j<numCuts; j++) mCuts[i][j] = (float)jsonCuts.getDouble(j);

      JSONArray jsonRota = jsonAx.getJSONArray("rotatable");

      int numRota = jsonRota.length();

      mLayerRotatable[i] = new boolean[numRota];

      for(int j=0; j<numRota; j++) mLayerRotatable[i][j] = jsonRota.getBoolean(j);

      mNumLayers[i] = numRota;

      }

    }

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

  private void parseQuats(JSONArray object) throws JSONException

    {

    int numQuats = object.length();

    mQuats = new Static4D[numQuats];

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

      {

      JSONObject jsonQuat = object.getJSONObject(i);

      float x = (float)jsonQuat.getDouble("x");

      float y = (float)jsonQuat.getDouble("y");

      float z = (float)jsonQuat.getDouble("z");

      float w = (float)jsonQuat.getDouble("w");

      mQuats[i] = new Static4D(x,y,z,w);

      }

    }

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

  private void parseScrambling(JSONObject object) throws JSONException

    {

    mScrambleType = object.getInt("scrambleType");

    if( mScrambleType==0 )

      {

      JSONArray jsonStates = object.getJSONArray("scrambleStates");

      int numStates = jsonStates.length();

      mStates = new ScrambleState[numStates];

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

        {

        JSONArray jsonState = jsonStates.getJSONArray(i);

        int numAxis = jsonState.length();

        int[][] scramblingData = new int[numAxis][];

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

          {

          JSONArray jsonData = jsonState.getJSONArray(j);

          int numData = jsonData.length();

          scramblingData[j] = new int[numData];

          for(int k=0; k<numData; k++) scramblingData[j][k] = jsonData.getInt(k);

          }

        mStates[i] = new ScrambleState(scramblingData);

        }

      }

    }

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

  private void parseTouchcontrol(JSONObject object) throws JSONException

    {

    mMovementType = object.getInt("movementType");

    mMovementSplit= object.getInt("movementSplit");

    try

      {

      JSONArray jsonEnabled = object.getJSONArray("enabledAxis");

      int numFace = jsonEnabled.length();

      mEnabled = new int[numFace][][];

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

        {

        JSONArray jsonSection = jsonEnabled.getJSONArray(i);

        int numSection = jsonSection.length();

        mEnabled[i] = new int[numSection][];

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

          {

          JSONArray jsonAx = jsonSection.getJSONArray(j);

          int numAxis = jsonAx.length();

          mEnabled[i][j] = new int[numAxis];

          for(int k=0; k<numAxis; k++) mEnabled[i][j][k] = jsonAx.getInt(k);

          }

        }

      }

    catch( JSONException ex )

      {

      // ignore, the object does not have to have 'enabledAxis' defined at all.

      }

    try

      {

      JSONArray jsonDist = object.getJSONArray("dist3D");

      int num = jsonDist.length();

      mDist3D = new float[num];

      for(int j=0; j<num; j++) mDist3D[j] = (float)jsonDist.getDouble(j);

      }

    catch( JSONException ex )

      {

      // ignore, the object does not have a 'dist3D' which is possible.

      }

    }

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

  private void parseColors(JSONArray object) throws JSONException

    {

    mNumFaceColors = object.length()-1;

    mColor = new int[mNumFaceColors];

    for(int i=0; i<mNumFaceColors; i++) mColor[i] = object.getInt(i);

    mInternalColor = object.getInt(mNumFaceColors);

    }

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

  private void parseSolved(JSONObject solved) throws JSONException

    {

    mSolvedFuncIndex = solved.getInt("functionIndex");

    try

      {

      JSONArray groupArray= solved.getJSONArray("groups");

      int numGroups = groupArray.length();

      mSolvedQuats  = new int[numGroups][];

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

        {

        JSONArray groupElements = groupArray.getJSONArray(i);

        int groupSize = groupElements.length();

        mSolvedQuats[i] = new int[groupSize];

        for(int j=0; j<groupSize; j++) mSolvedQuats[i][j] = groupElements.getInt(j);

        }

      }

    catch( JSONException ex )

      {

      // ignore, the object does not have to have an array of solved groups.

      }

    }

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

  private void parseVersion1(JSONObject object) throws JSONException

    {

    JSONObject metadata    = object.getJSONObject("metadata");

    parseMetadata1(metadata);

    JSONObject mesh        = object.getJSONObject("mesh");

    parseMesh(mesh);

    JSONArray axis         = object.getJSONArray("axis");

    parseAxis1(axis);

    JSONArray quats        = object.getJSONArray("quats");

    parseQuats(quats);

    JSONObject scrambling  = object.getJSONObject("scrambling");

    parseScrambling(scrambling);

    JSONObject touchcontrol= object.getJSONObject("touchcontrol");

    parseTouchcontrol(touchcontrol);

    JSONArray colors       = object.getJSONArray("colors");

    parseColors(colors);

    JSONObject solved      = object.getJSONObject("solved");

    parseSolved(solved);

    }

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

  private void parseVersion2or3or4(JSONObject object) throws JSONException

    {

    JSONObject metadata    = object.getJSONObject("metadata");

    parseMetadata2or3or4(metadata);

    JSONObject mesh        = object.getJSONObject("mesh");

    parseMesh(mesh);

    JSONArray axis         = object.getJSONArray("axis");

    parseAxis2or3or4(axis);

    JSONArray quats        = object.getJSONArray("quats");

    parseQuats(quats);

    JSONObject scrambling  = object.getJSONObject("scrambling");

    parseScrambling(scrambling);

    JSONObject touchcontrol= object.getJSONObject("touchcontrol");

    parseTouchcontrol(touchcontrol);

    JSONArray colors       = object.getJSONArray("colors");

    parseColors(colors);

    JSONObject solved      = object.getJSONObject("solved");

    parseSolved(solved);

    }

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

  private void parseVersion1Tutorial(JSONObject object) throws JSONException

    {

    mTutorialObject = object.getString("object");

    JSONArray tuts= object.getJSONArray("tutorials");

    int len = tuts.length();

    mTutorials = new String[len][4];

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

      {

      JSONObject tut = tuts.getJSONObject(i);

      mTutorials[i][0] = tut.getString("language");

      mTutorials[i][1] = tut.getString("link");

      mTutorials[i][2] = tut.getString("title");

      mTutorials[i][3] = tut.getString("author");

      }

    }

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

  private void parseVersion1Metadata(JSONObject object) throws JSONException

    {

    JSONObject metadata = object.getJSONObject("metadata");

    parseMetadata1(metadata);

    }

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

  private void parseVersion2or3or4Metadata(JSONObject object) throws JSONException

    {

    JSONObject metadata = object.getJSONObject("metadata");

    parseMetadata2or3or4(metadata);

    }

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

  public void parseJsonFile(InputStream jsonStream)

    {

    BufferedReader br = new BufferedReader(new InputStreamReader(jsonStream, StandardCharsets.UTF_8));

    try

      {

      StringBuilder contents = new StringBuilder();

      String tmp;

      while( (tmp = br.readLine()) != null) contents.append(tmp);

      br.close();

      jsonStream.close();

      JSONObject object = new JSONObject(contents.toString());

      int major = object.getInt("major");

      if( major==1 )

        {

        parseVersion1(object);

        }

      else if( major==2 || major==3 || major==4 )

        {

        parseVersion2or3or4(object);

        }

      else

        {

        android.util.Log.e("readJsonFile", "Unknown version "+major);

        }

      }

    catch(IOException e)

      {

      android.util.Log.e("readJsonFile", "Error reading JSON file: "+e.toString());