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

import org.distorted.objectlib.helpers.ObjectVertexEffects;

import org.distorted.objectlib.metadata.Metadata;

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

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

public class JsonWriter

{

  public static final int VERSION_OBJECT_APP = 15;

  public static final int VERSION_EXTRAS_APP = 1;

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

      if( offset!=null )

        {

        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 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, ObjectShape shape, int[] bandIndices, int[] faceOuter, int cubit, int[] numLayers) throws JSONException

    {

    JSONArray array = new JSONArray();

    int numFaces = shape.getNumFaces();

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

    boolean multigon = shape.isMultigon();

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

    int[][][] vertIndices2 = shape.getMultigonIndices();

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

      {

      JSONObject face = new JSONObject();

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

      int stiShape = object.getVariantStickerShape(variant,i);

      face.put("sticker", stiShape);

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

      JSONArray faceArr = new JSONArray();

      if( !multigon )

        {

        int num = vertIndices1[i].length;

        for(int j=0; j<num; j++) faceArr.put(vertIndices1[i][j]);

        }

      else

        {

        int num = vertIndices2[i].length;

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

          {

          JSONArray compArr = new JSONArray();

          int com = vertIndices2[i][j].length;

          for(int k=0; k<com; k++) compArr.put(vertIndices2[i][j][k]);

          faceArr.put(compArr);

          }

        }

      face.put("vertexIndices",faceArr);

      array.put(face);

      }

    return array;

    }

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

  private JSONArray generateVertices(float[][] vertices) throws JSONException

    {

    JSONArray array = new JSONArray();

    for (float[] vertex : vertices)

      {

      JSONObject vert = new JSONObject();

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

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

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

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

        {

        if( names[i]!=null )

          {

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

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

      ObjectVertexEffects effects = object.getVertexEffects(i);

      float[] convexity  = face.getConvexityCenter();

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

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

      int[] bandIndices  = face.getBandIndices();

      int num = shape.getNumFaces();

      if( num>mNumCubitFaces ) mNumCubitFaces=num;

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

      if( convexity!=null )

        {

        JSONObject convObj = generateConvexity(convexity);

        shapeObj.put("convexity", convObj);

        }

      if( shape.isMultigon() ) shapeObj.put("facesMultigon", true);

      JSONArray verticesArr = generateVertices(vertices);

      shapeObj.put("vertices", verticesArr);

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

      shapeObj.put("faces", facesArr);

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

    int numStickers = object.getNumStickerTypes();

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

      {

      JSONObject stickerObj= new JSONObject();

      JSONArray loops      = new JSONArray();

      ObjectSticker sticker= object.retSticker(s);

      float[][][] coords   = sticker.getCoords();

      float[][] curvatures = sticker.getCurvature();

      float[][] radii      = sticker.getRadii();

      float[][] stroke     = sticker.getStrokes();

      int numLoops = coords.length;

      for(int l=0; l<numLoops; l++)

        {

        JSONArray loop = new JSONArray();

        int numVertices=coords[l].length;

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

          {

          JSONObject vertex=new JSONObject();

          vertex.put("x", coords[l][v][0]);

          vertex.put("y", coords[l][v][1]);

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

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

          vertex.put("stroke", stroke[l][v]);

          loop.put(vertex);

          }

        loops.put(loop);

        }

      stickerObj.put("loops",loops);

      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[] cubfac = objectStickerOverride.getCubitFaces();

        int color    = objectStickerOverride.getColor();

        JSONArray cubfacArray = new JSONArray();

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

        override.put("cubitfaces", cubfacArray);

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

    mesh.put("pillow"  , object.getPillowCoeff() );

    JSONArray overrides = generateOverrides(object);

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

    return mesh;

    }

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

  private JSONObject generateMetadata(TwistyObject object, Metadata meta) 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"  , meta.numScrambles() );

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

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

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

    metadata.put("price"      , meta.price() );

    metadata.put("category"   , meta.getCategory() );

    JSONArray sigArray = new JSONArray();

    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;

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

    int[] numLayers = object.getNumLayers();

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

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

    float[][] rotFactor = object.returnRotationFactor();

    int[][] minimalCubits = object.getMinimalCubiesInRow();

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

      JSONArray factorArray = new JSONArray();

      for(float rotf : rotFactor[i]) factorArray.put(rotf);

      axObject.put("factor", factorArray );

      if( minimalCubits!=null )

        {

        JSONArray minimalArray = new JSONArray();

        for(int min : minimalCubits[i]) minimalArray.put(min);

        axObject.put("minimal", minimalArray );

        }

      axis.put(axObject);

      }

    return axis;

    }

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

  private JSONObject generateScrambling(TwistyObject object) throws JSONException

    {

    JSONObject scrambling = new JSONObject();

    int scrambleType = object.getScrambleType();

    scrambling.put("scrambleType",scrambleType );

    int[][] algorithms = object.getScrambleAlgorithms();

    if( algorithms!=null )

      {

      JSONArray scrambleAlgorithms = new JSONArray();

      for(int[] algorithm : algorithms)

        {

        JSONArray algArray = new JSONArray();

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

        scrambleAlgorithms.put(algArray);

        }

      scrambling.put("algorithms", scrambleAlgorithms);

      }

    int[][] edges = object.getScrambleEdges();

    if( edges!=null )

      {

      JSONArray scrambleEdges = new JSONArray();

      for(int[] edge : edges)

        {

        JSONArray edgeArray = new JSONArray();

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

        scrambleEdges.put(edgeArray);

        }

      scrambling.put("edges", scrambleEdges);

      }

    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[] colorTable = object.getColorTable();

    int numFaceColors = colorTable.length;

    for(int i=0; i<numFaceColors; i++) jsonColors.put(colorTable[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) throws JSONException

    {

    JSONObject json = new JSONObject();

    Metadata meta = object.getMetadata();

    JSONObject metadata    = generateMetadata(object,meta);

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

    json.put("minor"       , meta.objectVersion() );

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

        }

      String name = object.getShortName();

      Metadata meta = object.getMetadata();

      json.put("major"     , VERSION_EXTRAS_APP);

      json.put("minor"     , meta.extrasVersion() );

      json.put("object"    , name );

      json.put("tutorials" , tutorials);

      return json.toString();

      }

    return null;

    }

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

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

    {

    FileOutputStream fos = new FileOutputStream(filename);

    OutputStreamWriter osw = new OutputStreamWriter(fos, 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;

    }

}