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.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.helpers.ScrambleState;

import org.distorted.objectlib.main.TwistyObject;

import org.distorted.objectlib.main.ObjectType;

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

public class JsonWriter

{

  private static final int VERSION_MAJOR = 1;

  private static final int VERSION_MINOR = 0;

  private static JsonWriter mThis;

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

  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;

    int numFaces = object.getNumCubitFaces();

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

      {

      JSONObject cubit = new JSONObject();

      Static4D rotQuat  = object.getQuat(i,numLayers);

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

      int[] solvedQuats = object.getSolvedQuats(i,numLayers);

      JSONArray pos = new JSONArray();

      int numPos = positions[i].length;

      for(int j=0; j<numPos; j++) pos.put(positions[i][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 );

      if( solvedQuats!=null )

        {

        JSONArray solved = new JSONArray();

        for (int solvedQuat : solvedQuats) solved.put(solvedQuat);

        cubit.put("solvedQuats",solved);

        }

      JSONArray colors = new JSONArray();

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

        {

        int cubColor = object.getCubitFaceColor(i,j,numLayers);

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

      face.put("sticker",sticker);

      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(double[][] 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 numCubits = positions.length;

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

      {

      JSONObject shapeObj = new JSONObject();

      ObjectShape shape = object.getObjectShape(i);

      float[] convexity  = shape.getConvexityCenter();

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

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

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

      int[] bandIndices  = shape.getBandIndices();

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

      int[] cornerIndices= shape.getCornerIndices();

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

      int[] centerIndices= shape.getCenterIndices();

      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,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[] numLayers = object.getNumLayers();

    int numStickers = object.getNumStickerTypes(numLayers);

    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 JSONObject generateMesh(TwistyObject object) throws JSONException

    {

    JSONObject mesh = new JSONObject();

    JSONArray cubits   = generateCubits(object);

    JSONArray shapes   = generateShapes(object);

    JSONArray stickers = generateStickers(object);

    mesh.put("cubits"  , cubits);

    mesh.put("shapes"  , shapes);

    mesh.put("stickers", stickers);

    return mesh;

    }

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

  private JSONObject generateMetadata(TwistyObject object) throws JSONException

    {

    JSONObject metadata = new JSONObject();

    ObjectType type = object.getObjectType();

    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("solved_func", object.getSolvedFunctionIndex() );

    metadata.put("scrambles"  , type.getNumScramble() );

    metadata.put("shortname"  , type.name() );

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

    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.getBasicAngle();

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

      axObject.put("basicAngle", basicAngle[i] );

      JSONArray cutsArray = new JSONArray();

      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.getMovementType() );

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

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

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

    return jsonColors;

    }

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

  public String createJsonString(TwistyObject object) throws JSONException

    {

    JSONObject json = new JSONObject();

    JSONObject metadata    = generateMetadata(object);

    JSONObject mesh        = generateMesh(object);

    JSONArray  axis        = generateAxis(object);

    JSONArray  quats       = generateQuats(object);

    JSONObject scrambling  = generateScrambling(object);

    JSONObject touchControl= generateTouchControl(object);

    JSONArray  colors      = generateColors(object);

    json.put("major"       , VERSION_MAJOR);

    json.put("minor"       , VERSION_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);

    return json.toString();

    }

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

  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;

    }

}