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

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.OutputStreamWriter;

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

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

public class JsonWriter

{

  public static final int VERSION_OBJECT_MAJOR = 4;

  public static final int VERSION_OBJECT_MINOR = 0;

  public static final int VERSION_EXTRAS_MAJOR = 1;

  public static final int VERSION_EXTRAS_MINOR = 0;

  private static JsonWriter mThis;

  private static int mNumCubitFaces;

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

  private JsonWriter()

    {

    }

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

  private JSONArray generateCubits(TwistyObject object) throws JSONException

    {

    JSONArray array = new JSONArray();

    int[] numLayers     = object.getNumLayers();

    float[][] positions = object.getCubitPositions(numLayers);

    int numCubits       = positions.length;

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

      {

      JSONObject cubit = new JSONObject();

      Static4D rotQuat = object.getCubitQuats(c,numLayers);

      int variant      = object.getCubitVariant(c,numLayers);

      int type         = object.getCubitType(c);

      float[] offset   = object.getCubitOffset(c);

      JSONArray pos = new JSONArray();

      int numPos = positions[c].length;

      for(int j=0; j<numPos; j++) pos.put(positions[c][j]);

      cubit.put("centers", pos);

      cubit.put("qx", rotQuat.get0() );

      cubit.put("qy", rotQuat.get1() );

      cubit.put("qz", rotQuat.get2() );

      cubit.put("qw", rotQuat.get3() );

      cubit.put("variant", variant );

      cubit.put("type", type);

      cubit.put("offsetX", offset[0]);

      cubit.put("offsetY", offset[1]);

      cubit.put("offsetZ", offset[2]);

      JSONArray colors = new JSONArray();

      for(int f=0; f<mNumCubitFaces; f++)

        {

        int cubColor = object.getCubitFaceMap(c,f);

        colors.put(cubColor);

        }

      cubit.put("colors",colors);

      array.put(cubit);

      }

    return array;

    }

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

  private JSONArray generateCorners(float[][] corners) throws JSONException

    {

    JSONArray array = new JSONArray();

    for(float[] c : corners)

      {

      JSONObject corner = new JSONObject();

      corner.put("strength", c[0]);

      corner.put("radius"  , c[1]);

      array.put(corner);

      }

    return array;

    }

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

  private JSONArray generateCenters(float[][] centers) throws JSONException

    {

    JSONArray array = new JSONArray();

    for(float[] c : centers)

      {

      JSONObject center = new JSONObject();

      center.put("x", c[0]);

      center.put("y", c[1]);

      center.put("z", c[2]);

      array.put(center);

      }

    return array;

    }

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

  private JSONArray generateBands(float[][] bands) throws JSONException

    {

    JSONArray array = new JSONArray();

    for (float[] b : bands)

      {

      JSONObject band = new JSONObject();

      band.put("height"          , b[0]);

      band.put("angle"           , b[1]);

      band.put("distanceToCenter", b[2]);

      band.put("distanceToFlat"  , b[3]);

      band.put("numOfBands"      , b[4]);

      band.put("extraI"          , b[5]);

      band.put("extraJ"          , b[6]);

      array.put(band);

      }

    return array;

    }

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

  private JSONArray generateFaces(TwistyObject object, int[][] vertIndices, int[] bandIndices, int[] faceOuter, int cubit, int[] numLayers) throws JSONException

    {

    JSONArray array = new JSONArray();

    int numFaces = vertIndices.length;

    int variant = object.getCubitVariant(cubit,numLayers);

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

      {

      JSONObject face = new JSONObject();

      face.put("bandIndex", bandIndices[i]);

      int sticker = object.getVariantFaceColor(variant,i);

      face.put("sticker", sticker);

      face.put("isOuter", faceOuter[i]);

      JSONArray vertArr = new JSONArray();

      int numV = vertIndices[i].length;

      for(int j=0; j<numV; j++) vertArr.put(vertIndices[i][j]);

      face.put("vertexIndices",vertArr);

      array.put(face);

      }

    return array;

    }

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

  private JSONArray generateVertices(float[][] vertices, int[] cornerIndices, int[] centerIndices) throws JSONException

    {

    JSONArray array = new JSONArray();

    int numVertices = vertices.length;

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

      {

      JSONObject vert = new JSONObject();

      vert.put("x", vertices[j][0]);

      vert.put("y", vertices[j][1]);

      vert.put("z", vertices[j][2]);

      vert.put("cornerIndex", cornerIndices[j]);

      vert.put("centerIndex", centerIndices[j]);

      array.put(vert);

      }

    return array;

    }

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

  private JSONObject generateConvexity(float[] convexity) throws JSONException

    {

    JSONObject object = new JSONObject();

    object.put("x", convexity[0]);

    object.put("y", convexity[1]);

    object.put("z", convexity[2]);

    return object;

    }

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

  private int findCubitWithVariant(TwistyObject object, int variant, int numCubits, int[] numLayers)

    {

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

      {

      if( object.getCubitVariant(i,numLayers)==variant ) return i;

      }

    return -1;

    }

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

  private JSONArray generateShapes(TwistyObject object) throws JSONException

    {

    JSONArray shapes = new JSONArray();

    int[] numLayers = object.getNumLayers();

    int numVariants = object.getNumCubitVariants(numLayers);

    float[][] positions = object.getCubitPositions(numLayers);

    int[][] faceOuter   = object.getVariantFaceIsOuter();

    int numCubits = positions.length;

    mNumCubitFaces = 0;

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

      {

      JSONObject shapeObj = new JSONObject();

      ObjectShape shape = object.getObjectShape(i);

      ObjectFaceShape face = object.getObjectFaceShape(i);

      float[] convexity  = face.getConvexityCenter();

      float[][] vertices = shape.getVertices();

      int[][] vertIndices= shape.getVertIndices();

      float[][] bands    = face.getBands();

      int[] bandIndices  = face.getBandIndices();

      float[][] corners  = face.getCorners();

      int[] cornerIndices= face.getCornerIndices();

      float[][] centers  = face.getCenters();

      int[] centerIndices= face.getCenterIndices();

      int num = vertIndices.length;

      if( num>mNumCubitFaces ) mNumCubitFaces=num;

      int cubit = findCubitWithVariant(object,i,numCubits,numLayers);

      if( convexity!=null )

        {

        JSONObject convObj = generateConvexity(convexity);

        shapeObj.put("convexity", convObj);

        }

      JSONArray verticesArr = generateVertices(vertices,cornerIndices,centerIndices);

      shapeObj.put("vertices", verticesArr);

      JSONArray facesArr = generateFaces(object,vertIndices,bandIndices,faceOuter[i],cubit,numLayers);

      shapeObj.put("faces", facesArr);

      JSONArray bandsArr = generateBands(bands);

      shapeObj.put("bands", bandsArr);

      if( corners!=null )

        {

        JSONArray cornerArr = generateCorners(corners);

        shapeObj.put("cornerPush", cornerArr);

        }

      if( centers!=null )

        {

        JSONArray centerArr = generateCenters(centers);

        shapeObj.put("centerPush", centerArr);

        }

      shapes.put(shapeObj);

      }

    return shapes;

    }

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

  private JSONArray generateStickers(TwistyObject object) throws JSONException

    {

    JSONArray stickers = new JSONArray();

    int numStickers = object.getNumStickerTypes();

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

      {

      JSONObject stickerObj = new JSONObject();

      JSONArray  vertexArray= new JSONArray();

      ObjectSticker sticker = object.retSticker(i);

      float[] coords     = sticker.getCoords();

      float[] curvatures = sticker.getCurvature();

      float[] radii      = sticker.getRadii();

      float   stroke     = sticker.getStroke();

      stickerObj.put("stroke", stroke);

      int numVertices = radii.length;

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

        {

        JSONObject vertex = new JSONObject();

        vertex.put("x", coords[2*j  ]);

        vertex.put("y", coords[2*j+1]);

        vertex.put("angle", curvatures==null ? 0 : curvatures[j]);

        vertex.put("radius",radii[j]);

        vertexArray.put(vertex);

        }

      stickerObj.put("vertices", vertexArray);

      stickers.put(stickerObj);

      }

    return stickers;

    }

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

  private JSONArray generateOverrides(TwistyObject object) throws JSONException

    {

    ObjectStickerOverride[] overrides = object.getStickerOverrides();

    if( overrides!=null )

      {

      JSONArray overrideArray = new JSONArray();

      for (ObjectStickerOverride objectStickerOverride : overrides)

        {

        JSONObject override = new JSONObject();

        int cubit = objectStickerOverride.getCubit();

        int face  = objectStickerOverride.getFace();

        int color = objectStickerOverride.getColor();

        override.put("cubit", cubit);

        override.put("face" , face );

        override.put("color", color);

        overrideArray.put(override);

        }

      return overrideArray;

      }

    return null;

    }

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

  private JSONObject generateMesh(TwistyObject object) throws JSONException

    {

    JSONObject mesh = new JSONObject();

    JSONArray shapes   = generateShapes(object);  // do this before cubits so we calculate numCubitFaces

    JSONArray cubits   = generateCubits(object);

    JSONArray stickers = generateStickers(object);

    mesh.put("shapes"  , shapes);

    mesh.put("cubits"  , cubits);

    mesh.put("stickers", stickers);

    JSONArray overrides = generateOverrides(object);

    if( overrides!=null ) mesh.put("overrides", overrides);

    return mesh;

    }

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

  private JSONObject generateMetadata(TwistyObject object, int numScramble) throws JSONException

    {

    JSONObject metadata = new JSONObject();

    metadata.put("longname"   , object.getObjectName() );

    metadata.put("inventor"   , object.getInventor());

    metadata.put("year"       , object.getYearOfInvention());

    metadata.put("complexity" , object.getComplexity());

    metadata.put("size"       , object.getSize() );

    metadata.put("scrambles"  , numScramble );

    metadata.put("shortname"  , object.getShortName() );

    metadata.put("resetmaps"  , object.shouldResetTextureMaps() );

    metadata.put("num_faces"  , object.getNumFaces() );

    ObjectSignature signature = object.getSignature();

    metadata.put("signature1" , signature.getLong1() );

    metadata.put("signature2" , signature.getLong2() );

    metadata.put("signature3" , signature.getLong3() );

    return metadata;

    }

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

  private JSONArray generateQuats(TwistyObject object) throws JSONException

    {

    JSONArray quatsArray = new JSONArray();

    Static4D[] quats = object.getQuats();

    for(Static4D quat : quats)

      {

      JSONObject q = new JSONObject();

      q.put("x",quat.get0());

      q.put("y",quat.get1());

      q.put("z",quat.get2());

      q.put("w",quat.get3());

      quatsArray.put(q);

      }

    return quatsArray;

    }

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

  private JSONArray generateAxis(TwistyObject object) throws JSONException

    {

    JSONArray axis = new JSONArray();

    Static3D[] rotAxis = object.getRotationAxis();

    int numAxis = rotAxis.length;

    int[][] basicAngle = object.getBasicAngles();

    int[] numLayers = object.getNumLayers();

    float[][] cuts = object.getCuts(numLayers);

    boolean[][] rotatable = object.getLayerRotatable(numLayers);

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

      {

      JSONObject axObject = new JSONObject();

      Static3D ax = rotAxis[i];

      axObject.put("x", ax.get0() );

      axObject.put("y", ax.get1() );

      axObject.put("z", ax.get2() );

      JSONArray angleArray = new JSONArray();

      for(float angle : basicAngle[i]) angleArray.put(angle);

      axObject.put("basicAngles", angleArray);

      JSONArray cutsArray = new JSONArray();

      if( cuts[i]!=null ) for(float cut : cuts[i]) cutsArray.put(cut);

      axObject.put("cuts", cutsArray);

      JSONArray rotaArray = new JSONArray();

      for(boolean rot : rotatable[i]) rotaArray.put(rot);

      axObject.put("rotatable", rotaArray );

      axis.put(axObject);

      }

    return axis;

    }

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

  private JSONObject generateScrambling(TwistyObject object) throws JSONException

    {

    JSONObject scrambling = new JSONObject();

    ScrambleState[] states = object.getScrambleStates();

    int scrambleType = object.getScrambleType();

    scrambling.put("scrambleType",scrambleType );

    if( states!=null )

      {

      JSONArray scrambleStates = new JSONArray();

      for(ScrambleState state : states)

        {

        JSONArray axisArray = new JSONArray();

        int numAxis = state.getNumAxis();

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

          {

          JSONArray axArray = new JSONArray();

          int[] axData = state.getAx(ax);

          if( axData!=null )

            for(int data : axData) axArray.put(data);

          axisArray.put(axArray);

          }

        scrambleStates.put(axisArray);

        }

      scrambling.put("scrambleStates", scrambleStates);

      }

    return scrambling;

    }

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

  private JSONObject generateTouchControl(TwistyObject object) throws JSONException

    {

    JSONObject touchControl = new JSONObject();

    touchControl.put("movementType" , object.getTouchControlType() );

    touchControl.put("movementSplit", object.getTouchControlSplit() );

    int[][][] enabled = object.getEnabled();

    if( enabled!=null )

      {

      JSONArray enabledArray = new JSONArray();

      for(int[][] faceEnabled : enabled)

        {

        JSONArray faceArray = new JSONArray();

        for(int[] sectionEnabled : faceEnabled)

          {

          JSONArray sectionArray = new JSONArray();

          for(int ax : sectionEnabled) sectionArray.put(ax);

          faceArray.put(sectionArray);

          }

        enabledArray.put(faceArray);

        }

      touchControl.put("enabledAxis", enabledArray);

      }

    int[] numLayers = object.getNumLayers();

    float[] dist3D = object.getDist3D(numLayers);

    if( dist3D!=null )

      {

      JSONArray distArray = new JSONArray();

      for( float dist: dist3D ) distArray.put(dist);

      touchControl.put("dist3D", distArray);

      }

    return touchControl;

    }

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

  private JSONArray generateColors(TwistyObject object)

    {

    JSONArray jsonColors = new JSONArray();

    int numFaceColors = object.getNumFaceColors();

    for(int i=0; i<numFaceColors; i++) jsonColors.put(object.getColor(i));

    jsonColors.put(object.getInternalColor());

    return jsonColors;

    }

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

  private JSONObject generateSolved(TwistyObject object) throws JSONException

    {

    JSONObject solved = new JSONObject();

    int[][] solvedGroups = object.getSolvedQuats();

    solved.put("functionIndex", object.getSolvedFunctionIndex() );

    if( solvedGroups!=null )

      {

      JSONArray groupArray = new JSONArray();

      for( int[] group : solvedGroups )

        {

        JSONArray groupElements = new JSONArray();

        for( int element : group ) groupElements.put(element);

        groupArray.put(groupElements);

        }

      solved.put("groups", groupArray );

      }

    return solved;

    }

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

  public String createObjectString(TwistyObject object,int numScramble) throws JSONException

    {

    JSONObject json = new JSONObject();

    JSONObject metadata    = generateMetadata(object,numScramble);

    JSONObject mesh        = generateMesh(object);

    JSONArray  axis        = generateAxis(object);

    JSONArray  quats       = generateQuats(object);

    JSONObject scrambling  = generateScrambling(object);

    JSONObject touchControl= generateTouchControl(object);

    JSONArray  colors      = generateColors(object);

    JSONObject solved      = generateSolved(object);

    json.put("major"       , VERSION_OBJECT_MAJOR);

    json.put("minor"       , VERSION_OBJECT_MINOR);

    json.put("metadata"    , metadata);

    json.put("mesh"        , mesh);

    json.put("axis"        , axis);

    json.put("quats"       , quats);

    json.put("scrambling"  , scrambling);

    json.put("touchcontrol", touchControl);

    json.put("colors"      , colors);

    json.put("solved"      , solved);

    return json.toString();

    }

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

  public String createExtrasString(TwistyObject object) throws JSONException

    {

    String[][] tuts = object.getTutorials();

    if( tuts!=null )

      {

      JSONObject json = new JSONObject();

      JSONArray  tutorials = new JSONArray();

      for(String[] tut : tuts)

        {

        String language = tut[0];

        String link     = tut[1];

        String title    = tut[2];

        String author   = tut[3];

        JSONObject oneTut = new JSONObject();

        oneTut.put("language", language);

        oneTut.put("link"    , link    );

        oneTut.put("title"   , title   );

        oneTut.put("author"  , author  );

        tutorials.put(oneTut);

        }

      json.put("major"     , VERSION_EXTRAS_MAJOR);

      json.put("minor"     , VERSION_EXTRAS_MINOR);

      json.put("object"    , object.getShortName() );

      json.put("tutorials" , tutorials);

      return json.toString();

      }

    return null;

    }

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

  public void write(String filename, String contents) throws IOException

    {

    OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(filename), StandardCharsets.UTF_8);

    BufferedWriter bw = new BufferedWriter(osw);

    bw.write(contents);

    bw.flush();

    }

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

  public static JsonWriter getInstance()

    {

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

    return mThis;

    }

}