TwistyPuzzleLib

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

// Copyright 2021 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// 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.objectlib.json;

import static org.distorted.objectlib.objects.TwistyBandagedCuboid.OBJECT_NAME;

import static org.distorted.objectlib.scrambling.ScrambleStateBandagedCuboid.MAX_SUPPORTED_SIZE;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.nio.charset.StandardCharsets;

import org.distorted.objectlib.helpers.ObjectFaceShape;

import org.distorted.objectlib.helpers.ObjectSignature;

import org.distorted.objectlib.helpers.ObjectStickerOverride;

import org.distorted.objectlib.helpers.ObjectVertexEffects;

import org.distorted.objectlib.main.TwistyObjectCubit;

import org.distorted.objectlib.scrambling.ScrambleEdgeGenerator;

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.main.ObjectType;

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

public class JsonReader

{

  private int[][] mAlgorithms;

  private int[][] mEdges;

  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 ObjectVertexEffects[] mVertexEffects;

  private Static4D[] mCubitQuats;

  private int mNumCubitVariants;

  private int[] mCubitVariant;

  private int[][] mVariantStickerShape, 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 mPrice;

  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 float mPillowCoeff;

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

  public static ObjectSignature produceSignature(String shortName, String longName, long[] signature)

    {

    // 'BAN*_*' ( or future possible 'BA**_*' ) objects

    if( shortName.charAt(0)=='B' && shortName.charAt(1)=='A' && shortName.charAt(4)=='_' )

      {

      char second = shortName.charAt(2);

      char third  = shortName.charAt(3);

      if( (second=='N' || (second>='0' && second<='9')) && (third>='0' && third<='9') )

        {

        int size = shortName.charAt(5) - '0';

        if( size>=2 && size<=MAX_SUPPORTED_SIZE ) return new ObjectSignature(size,signature);

        }

      }

    if( longName.equals(OBJECT_NAME) ) new ObjectSignature(shortName,signature);

    return new ObjectSignature(signature);

    }

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

  private void parseMetadata(JSONObject metadata) throws JSONException

    {

    mLongName        = metadata.getString("longname");

    mShortName       = metadata.getString("shortname");

    mInventor        = metadata.getString("inventor");

    mYearOfInvention = metadata.getInt("year");

    mComplexity      = metadata.getInt("complexity");

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

    mNumScrambles    = metadata.getInt("scrambles");

    mResetMaps       = metadata.getBoolean("resetmaps");

    mNumFaces        = metadata.getInt("num_faces");

    try

      {

      JSONArray sigArray = metadata.getJSONArray("signature");

      int size = sigArray.length();

      long[] signature = new long[size];

      for(int i=0; i<size; i++) signature[i] = sigArray.getLong(i);

      mSignature = produceSignature(mShortName,mLongName,signature);

      }

    catch(JSONException ex)

      {

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

      mSignature = new ObjectSignature(signature);

      }

    boolean free = metadata.optBoolean("free", true);

    if( free ) mPrice = 0;

    else mPrice = metadata.optInt("price", ObjectType.DEFAULT_PRICE_OF_OLD_OBJECTS );

    }

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

  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] = jsonCubit.optInt("type", TwistyObjectCubit.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();

    mVariantStickerShape  = new int[mNumCubitVariants][];

    mVariantFaceIsOuter   = new int[mNumCubitVariants][];

    mShapes               = new ObjectShape[mNumCubitVariants];

    mFaceShapes           = new ObjectFaceShape[mNumCubitVariants];

    mVertexEffects        = new ObjectVertexEffects[mNumCubitVariants];

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

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

    float[][] convexity   = new float[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];

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

        }

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

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

      int numFaces = jsonFaces.length();

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

        mVariantStickerShape[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");

        }

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

        }

      ////// effects /////////////////////////////////////////////////

      JSONArray jsonEffects = jsonShape.optJSONArray("effects");

      if( jsonEffects!=null )

        {

        int numEffects = jsonEffects.length();

        String[] name    = new String[numEffects];

        float[][] vars   = new float[numEffects][5];

        float[][] center = new float[numEffects][3];

        float[][] region = new float[numEffects][4];

        boolean[] use    = new boolean[numEffects];

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

          {

          JSONObject jsonEffect = jsonEffects.getJSONObject(j);

          name[j] = jsonEffect.getString("name");

          vars[j][0] = (float)jsonEffect.getDouble("var0");

          vars[j][1] = (float)jsonEffect.getDouble("var1");

          vars[j][2] = (float)jsonEffect.getDouble("var2");

          vars[j][3] = (float)jsonEffect.getDouble("var3");

          vars[j][4] = (float)jsonEffect.getDouble("var4");

          center[j][0] = (float)jsonEffect.getDouble("center0");

          center[j][1] = (float)jsonEffect.getDouble("center1");

          center[j][2] = (float)jsonEffect.getDouble("center2");

          region[j][0] = (float)jsonEffect.getDouble("region0");

          region[j][1] = (float)jsonEffect.getDouble("region1");

          region[j][2] = (float)jsonEffect.getDouble("region2");

          region[j][3] = (float)jsonEffect.getDouble("region3");

          use[j] = jsonEffect.getBoolean("use");

          }

        mVertexEffects[i] = new ObjectVertexEffects(name,vars,center,region,use);

        }

      }

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

      {

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

      mFaceShapes[i] = new ObjectFaceShape(bands[i],bandIndices[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

    {

    if( object!=null )

      {

      int numOverrides = object.length();

      mStickerOverrides= new ObjectStickerOverride[numOverrides];

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

        {

        JSONObject override  = object.getJSONObject(i);

        JSONArray cubitArray = override.getJSONArray("cubitfaces");

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

        int numCubits = cubitArray.length();

        int[] cubitface = new int[numCubits];

        for(int j=0; j<numCubits; j++) cubitface[j] = cubitArray.getInt(j);

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

        }

      }

    else

      {

      mStickerOverrides = null;

      }

    }

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

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

    parseOverrides(overrides);

    mPillowCoeff = (float)object.optDouble("pillow",1.0);

    }

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

  private void parseAxis(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 int getAlgorithmIndex(int ax, int layer, int angle)

    {

    int numAlgs = mAlgorithms.length;

    for(int alg=0; alg<numAlgs; alg++)

      {

      int[] a = mAlgorithms[alg];

      if( a.length>=3 && a[0]==ax && a[1]==layer && a[2]==angle ) return alg;

      }

    return -1;

    }

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

  private int[] produceEdge(int[][] scramblingData)

    {

    int index=0, length=0;

    int numAxis = scramblingData.length;

    for (int[] scramblingDatum : scramblingData) length += scramblingDatum.length;

    int[] ret = new int[2*length/3];

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

      {

      int[] data = scramblingData[ax];

      int num = data.length/3;

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

        {

        int layer = data[3*j];

        int angle = data[3*j+1];

        int state = data[3*j+2];

        ret[2*index  ] = getAlgorithmIndex(ax,layer,angle);

        ret[2*index+1] = state;

        index++;

        }

      }

    return ret;

    }

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

  private void parseScrambling6(JSONObject object) throws JSONException

    {

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

    int numStates = jsonStates.length();

    int[][][] scramblingData = new int[numStates][][];

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

      {

      JSONArray jsonState = jsonStates.getJSONArray(i);

      int numAxis = jsonState.length();

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

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

        {

        JSONArray jsonData = jsonState.getJSONArray(j);

        int numData = jsonData.length();

        scramblingData[i][j] = new int[numData];

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

        }

      }

    mAlgorithms = ScrambleEdgeGenerator.getScramblingAlgorithms(mBasicAngle);

    mEdges = new int[numStates][];

    for(int i=0; i<numStates; i++) mEdges[i] = produceEdge(scramblingData[i]);

    }

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

  private void parseScrambling7orMore(JSONObject object) throws JSONException

    {

    JSONArray jsonAlgorithms = object.getJSONArray("algorithms");

    int numAlgs = jsonAlgorithms.length();

    mAlgorithms = new int[numAlgs][];

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

      {

      JSONArray jsonAlg = jsonAlgorithms.getJSONArray(i);

      int numEntries = jsonAlg.length();

      mAlgorithms[i] = new int[numEntries];

      for(int j=0; j<numEntries; j++) mAlgorithms[i][j] = jsonAlg.getInt(j);

      }

    JSONArray jsonEdges = object.getJSONArray("edges");

    int numEdges = jsonEdges.length();

    mEdges = new int[numEdges][];

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

      {

      JSONArray jsonEdge = jsonEdges.getJSONArray(i);

      int numEntries = jsonEdge.length();

      mEdges[i] = new int[numEntries];

      for(int j=0; j<numEntries; j++) mEdges[i][j] = jsonEdge.getInt(j);

      }

    }

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

  private void parseScrambling(JSONObject object, int major) throws JSONException

    {

    mScrambleType = object.getInt("scrambleType");

    if( mScrambleType==0 )

      {

      if( major==6 ) parseScrambling6(object);

      else           parseScrambling7orMore(object);

      }

    }

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

  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 parseFile(JSONObject object, int major) throws JSONException

    {

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

    parseMetadata(metadata);

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

    parseMesh(mesh);

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

    parseAxis(axis);

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

    parseQuats(quats);

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

    parseScrambling(scrambling,major);

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

    parseTouchcontrol(touchcontrol);

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

    parseColors(colors);

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

    parseSolved(solved);

    }

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

  private void parseTutorial(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");

      }

    }

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

// PUBLIC

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

  public void parseJsonFile(InputStream jsonStream) throws JSONException, IOException

    {

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

    StringBuilder contents = new StringBuilder();

    String line;

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

    br.close();

    jsonStream.close();

    String contentsString = contents.toString();

    JSONObject object = new JSONObject(contentsString);

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

    if( major>=6 )

      {

      parseFile(object,major);

      }

    else

      {

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