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

import java.io.FileNotFoundException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.nio.charset.StandardCharsets;

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;

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

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 ObjectShape[] mShapes;

  private int mNumCubitVariants;

  private int[] mCubitVariant;

  private int[][] mVariantFaceColor, mCubitFaceColor;

  private ObjectSticker[] mObjectSticker;

  private Static3D[] mAxis;

  private int[] mNumLayers;

  private float mSize;

  private String[][] mTutorials;

  private float[][] mCubitRowOffset;

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

  private JsonReader()

    {

    }

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

  public static JsonReader getInstance()

    {

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

    return mThis;

    }

    mLongName        = object.getString("longname");

    mYearOfInvention = object.getInt("year");

    mComplexity      = object.getInt("complexity");

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

      {

      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.

      mSignature = new ObjectSignature(signature);

      }

    }

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

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

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

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

    mFaceShapes = new ObjectFaceShape[mNumCubitVariants];

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

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

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

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

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

      {

      JSONObject jsonShape = object.getJSONObject(i);

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

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

      int numVertices = jsonVertices.length();

      centerIndices[i] = new int[numVertices];

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

        {

        JSONObject vert = jsonVertices.getJSONObject(j);

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

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

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

        }

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

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

      int numFaces = jsonFaces.length();

      mVariantFaceColor[i] = new int[numFaces];

      bandIndices[i] = new int[numFaces];

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

        {

        JSONObject jsonFace = jsonFaces.getJSONObject(j);

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

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

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

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

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

      {

    }

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

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

    }

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

    int numAxis = object.length();

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

      }

    }

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

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

      int numAngles = jsonAngles.length();

      mBasicAngle[i] = new int[numAngles];

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

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

      int numFace = jsonEnabled.length();

      for(int i=0; i<numFace; 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);

          }

      }

      {

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

      }

    try

      {

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

      mDist3D = new float[num];

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

    catch( JSONException ex )

      {

    }

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

  private void parseColors(JSONArray object) throws JSONException

    {

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