TwistyPuzzleLib

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

// Copyright 2021 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// along with the code. If not, check https://distorted.org/magic/License-Magic-Cube.html        //

package org.distorted.objectlib.json;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.OutputStreamWriter;

import java.nio.charset.StandardCharsets;

import org.json.JSONException;

import org.json.JSONObject;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.helpers.ObjectSticker;

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

public class JsonWriter

{

  public static final int VERSION_EXTRAS_MAJOR = 1;

  public static final int VERSION_EXTRAS_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);

      JSONObject cubit = new JSONObject();

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

      int type         = object.getCubitType(c);

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

      JSONArray pos = new JSONArray();

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

      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( offset!=null )

        {

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

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

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

        }

      JSONArray colors = new JSONArray();

        }

      cubit.put("colors",colors);

      array.put(cubit);

      }

    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;

    }

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

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

      face.put("sticker", stiShape);

      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;

    }

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

    JSONArray array = new JSONArray();

      JSONObject vert = new JSONObject();

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

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

      }

    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 JSONObject generateEffect(String name, float[] var, float[] center, float[] region, boolean use) throws JSONException

    {

    JSONObject object = new JSONObject();

    object.put("name",name);

    object.put("var0", var[0]);

    object.put("var1", var[1]);

    object.put("var2", var[2]);

    object.put("var3", var[3]);

    object.put("var4", var[4]);

    object.put("center0", center[0]);

    object.put("center1", center[1]);

    object.put("center2", center[2]);

    object.put("region0", region[0]);

    object.put("region1", region[1]);

    object.put("region2", region[2]);

    object.put("region3", region[3]);

    object.put("use", use);

    return object;

    }

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

  private JSONArray generateEffects(String[] names, float[][] vars, float[][] centers, float[][] regions, boolean[] uses) throws JSONException

    {

    int numEffects = names==null ? 0 : names.length;

    if( numEffects>0 )

      {

      JSONArray array = new JSONArray();

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

        {

          {

          JSONObject object = generateEffect(names[i],vars[i],centers[i],regions[i],uses[i]);

          array.put(object);

          }

      return array;

      }

    return null;

    }

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

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

      {

      JSONObject shapeObj = new JSONObject();

      ObjectShape shape = object.getObjectShape(i);

      int[] bandIndices  = face.getBandIndices();

      if( num>mNumCubitFaces ) mNumCubitFaces=num;

      if( convexity!=null )

        {

        JSONObject convObj = generateConvexity(convexity);

        shapeObj.put("convexity", convObj);

        }

      JSONArray bandsArr = generateBands(bands);

      shapeObj.put("bands", bandsArr);

      if( effects!=null )

        {

        String[] effNames = effects.getNames();

        float[][] effVars = effects.getVariables();

        float[][] effCent = effects.getCenters();

        float[][] effRegi = effects.getRegions();

        boolean[] effUses = effects.getUses();

        JSONArray effectsArr = generateEffects(effNames,effVars,effCent,effRegi,effUses);

        if( effectsArr!=null ) shapeObj.put("effects", effectsArr);

        }

      shapes.put(shapeObj);

      }

    return shapes;

    }

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

  private JSONArray generateStickers(TwistyObject object) throws JSONException

    {

    JSONArray stickers = new JSONArray();

    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 color    = objectStickerOverride.getColor();

        JSONArray cubfacArray = new JSONArray();

        for (int cf : cubfac) cubfacArray.put(cf);

        overrideArray.put(override);

        }

      return overrideArray;

      }

    return null;

    }

  private JSONObject generateMesh(TwistyObject object) throws JSONException

    {

    JSONObject mesh = new JSONObject();

    JSONArray stickers = generateStickers(object);

    mesh.put("shapes"  , shapes);

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

    }

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

    JSONObject metadata = new JSONObject();

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

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

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

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

    long[] sig = object.getSignature().getArray();

    for (long l : sig) sigArray.put(l);

    metadata.put("signature" , sigArray );

    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;

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

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

      axObject.put("basicAngles", angleArray);

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

    int scrambleType = object.getScrambleType();

    scrambling.put("scrambleType",scrambleType );

        for (int entry : algorithm) algArray.put(entry);

        scrambleAlgorithms.put(algArray);

        }

      }

      {

      JSONArray scrambleEdges = new JSONArray();

        {

        JSONArray edgeArray = new JSONArray();

        for (int entry : edge) edgeArray.put(entry);

        scrambleEdges.put(edgeArray);

    return scrambling;

    }

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

  private JSONObject generateTouchControl(TwistyObject object) throws JSONException

    {

    JSONObject touchControl = new JSONObject();

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

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

        for(int[] sectionEnabled : faceEnabled)

          {

          JSONArray sectionArray = new JSONArray();

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

          faceArray.put(sectionArray);

          }

        enabledArray.put(faceArray);

      }

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

    if( dist3D!=null )

      {

      JSONArray distArray = new JSONArray();

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

      touchControl.put("dist3D", distArray);

      }

    }

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

    }

  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;

    }

    JSONObject json = new JSONObject();

    JSONArray  axis        = generateAxis(object);

    JSONArray  quats       = generateQuats(object);

    JSONObject scrambling  = generateScrambling(object);

    JSONObject touchControl= generateTouchControl(object);

    json.put("minor"       , VERSION_OBJECT_MINOR);

    json.put("mesh"        , mesh);

    json.put("axis"        , axis);

    json.put("quats"       , quats);

    json.put("scrambling"  , scrambling);

    json.put("touchcontrol", touchControl);

    return json.toString();

    }

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