Magic Cube

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

// Copyright 2024 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Magic Cube.                                                              //

//                                                                                               //

// 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.objects;

import static org.distorted.main.MainSettingsPopup.*;

import org.distorted.main.R;

import java.util.Arrays;

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

public class RubikObjectCategories

{

  public static final int[] DIFF_IDS =

    {

    R.id.configDifficulty0,

    R.id.configDifficulty1,

    R.id.configDifficulty2,

    R.id.configDifficulty3,

    R.id.configDifficulty4

    };

  public static final int[] DIFF_IMAGES =

    {

    R.drawable.difficulty1,

    R.drawable.difficulty2,

    R.drawable.difficulty3,

    R.drawable.difficulty4,

    R.drawable.difficulty5,

    };

  public static final int[] CATEGORY_IMAGES =

    {

    R.drawable.difficulty1,

    R.drawable.difficulty2,

    R.drawable.difficulty3,

    R.drawable.difficulty4,

    R.drawable.difficulty5,

    };

  private final int mNumCategories;

  private int[][] mObjectIndices;

  private int[] mIconIDs;

  private String[] mTitles;

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

  public RubikObjectCategories(int sortMode)

    {

    switch(sortMode)

      {

      case SORT_CATEGORY  : buildSortCategory(); break;

      case SORT_DIFFICULTY: buildSortDifficulty(); break;

      case SORT_AUTHOR    : buildSortAuthor(); break;

      case SORT_YEAR      : buildSortYear(); break;

      }

    mNumCategories = mObjectIndices.length;

    switch(sortMode)

      {

      case SORT_CATEGORY  : buildIconsCategory(); break;

      case SORT_DIFFICULTY: buildIconsDifficulty(); break;

      case SORT_AUTHOR    : buildTitleAuthor(); break;

      case SORT_YEAR      : buildTitleYear(); break;

      }

    }

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

  private void buildSortStr(String[] data)

    {

    int numObjects = data.length;

    String[] sorted = new String[numObjects];

    System.arraycopy(data, 0, sorted, 0, numObjects);

    Arrays.sort(sorted);

    String[] categories = new String[numObjects];

    int numCategories = 0;

    for(int o=0; o<numObjects; o++)

      if( o==0 || !sorted[o-1].equals(sorted[o]) )

        {

        categories[numCategories] = sorted[o];

        numCategories++;

        }

    int lastChange = -1;

    int curr = 0;

    int[] numInCategory = new int[numCategories];

    for(int o=0; o<numObjects; o++)

      if( o==numObjects-1 || !sorted[o].equals(sorted[o+1]) )

        {

        numInCategory[curr] = o-lastChange;

        curr++;

        lastChange = o;

        }

    mObjectIndices = new int[numCategories][];

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

      {

      mObjectIndices[c] = new int[numInCategory[c]];

      String cat = categories[c];

      int index = 0;

      for(int o=0; o<numObjects; o++)

        if( data[o].equals(cat) ) mObjectIndices[c][index++] = o;

      }

    }

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

  private void buildSortInt(int[] data)

    {

    int numObjects = data.length;

    int[] sorted = new int[numObjects];

    System.arraycopy(data, 0, sorted, 0, numObjects);

    Arrays.sort(sorted);

    int[] categories = new int[numObjects];

    int numCategories = 0;

    for(int o=0; o<numObjects; o++)

      if( o==0 || sorted[o-1]!=sorted[o] )

        {

        categories[numCategories] = sorted[o];

        numCategories++;

        }

    int lastChange = -1;

    int curr = 0;

    int[] numInCategory = new int[numCategories];

    for(int o=0; o<numObjects; o++)

      if( o==numObjects-1 || sorted[o]!=sorted[o+1] )

        {

        numInCategory[curr] = o-lastChange;

        curr++;

        lastChange = o;

        }

    mObjectIndices = new int[numCategories][];

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

      {

      mObjectIndices[c] = new int[numInCategory[c]];

      int cat = categories[c];

      int index = 0;

      for(int o=0; o<numObjects; o++)

        if( data[o]==cat ) mObjectIndices[c][index++] = o;

      }

    }

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

  private void buildSortFloat(float[] data)

    {

    int numObjects = data.length;

    float[] sorted = new float[numObjects];

    System.arraycopy(data, 0, sorted, 0, numObjects);

    Arrays.sort(sorted);

    float[] categories = new float[numObjects];

    int numCategories = 0;

    for(int o=0; o<numObjects; o++)

      if( o==0 || sorted[o-1]!=sorted[o] )

        {

        categories[numCategories] = sorted[o];

        numCategories++;

        }

    int lastChange = -1;

    int curr = 0;

    int[] numInCategory = new int[numCategories];

    for(int o=0; o<numObjects; o++)

      if( o==numObjects-1 || sorted[o]!=sorted[o+1] )

        {

        numInCategory[curr] = o-lastChange;

        curr++;

        lastChange = o;

        }

    mObjectIndices = new int[numCategories][];

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

      {

      mObjectIndices[c] = new int[numInCategory[c]];

      float cat = categories[c];

      int index = 0;

      for(int o=0; o<numObjects; o++)

        if( data[o]==cat ) mObjectIndices[c][index++] = o;

      }

    }

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

  private void buildSortCategory()

    {

    int numObjects = RubikObjectList.getNumObjects();

    int[] cats = new int[numObjects];

    for(int o=0; o<numObjects; o++)

      {

      RubikObject obj = RubikObjectList.getObject(o);

      cats[o] = obj==null ? 0 : obj.getCategory();

      }

    buildSortInt(cats);

    }

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

  private void buildSortDifficulty()

    {

    int numObjects = RubikObjectList.getNumObjects();

    float[] diffs = new float[numObjects];

    for(int o=0; o<numObjects; o++)

      {

      RubikObject obj = RubikObjectList.getObject(o);

      diffs[o] = obj==null ? 0 : obj.getDifficulty();

      }

    buildSortFloat(diffs);

    }

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

  private void buildSortAuthor()

    {

    int numObjects = RubikObjectList.getNumObjects();

    String[] auths = new String[numObjects];

    for(int o=0; o<numObjects; o++)

      {

      RubikObject obj = RubikObjectList.getObject(o);

      auths[o] = obj==null ? "" : obj.getAuthor();

      }

    buildSortStr(auths);

    }

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

  private void buildSortYear()

    {

    int numObjects = RubikObjectList.getNumObjects();

    int[] years = new int[numObjects];

    for(int o=0; o<numObjects; o++)

      {

      RubikObject obj = RubikObjectList.getObject(o);

      years[o] = obj==null ? 0 : obj.getYearOfInvention();

      }

    buildSortInt(years);

    }

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

  private void buildIconsCategory()

    {

    mIconIDs = new int[mNumCategories];

    for(int t=0; t<mNumCategories; t++)

      {

      int obj = mObjectIndices[t][0];

      RubikObject object = RubikObjectList.getObject(obj);

      int category = object==null ? 0 : object.getCategory();

      mIconIDs[t] = CATEGORY_IMAGES[category%5];  //TODO

      }

    }

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

  private void buildIconsDifficulty()

    {

    mIconIDs = new int[mNumCategories];

    for(int t=0; t<mNumCategories; t++)

      {

      int obj = mObjectIndices[t][0];

      RubikObject object = RubikObjectList.getObject(obj);

      int difficulty = object==null ? 0 : (int)object.getDifficulty();

      mIconIDs[t] = DIFF_IMAGES[difficulty];

      }

    }

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

  private void buildTitleAuthor()

    {

    mTitles = new String[mNumCategories];

    for(int t=0; t<mNumCategories; t++)

      {

      int obj = mObjectIndices[t][0];

      RubikObject object = RubikObjectList.getObject(obj);

      mTitles[t] = object==null ? "" : object.getAuthor();

      }

    }

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

  private void buildTitleYear()

    {

    mTitles = new String[mNumCategories];

    for(int t=0; t<mNumCategories; t++)

      {

      int obj = mObjectIndices[t][0];

      RubikObject object = RubikObjectList.getObject(obj);

      int year = object==null ? 0 : object.getYearOfInvention();

      mTitles[t] = String.valueOf(year);

      }

    }

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

// PUBLIC API

  public int getNumCategories()

    {

    return mNumCategories;

    }

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

  public boolean hasIcons()

    {

    return mIconIDs!=null;

    }

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

  public int getIconId(int category)

    {

    return ( mIconIDs!=null && category>=0 && category<mNumCategories ) ? mIconIDs[category] : -1;

    }

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

  public String getTitle(int category)

    {

    return (mTitles!=null && category>=0 && category<mNumCategories) ? mTitles[category] : null;

    }

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

  public int getNumObjects(int category)

    {

    return (category>=0 && category<mNumCategories) ? mObjectIndices[category].length : 0;

    }

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

  public int getObjectIndex(int category, int index)

    {

    if( category>=0 && category<mNumCategories )

      {

      int[] objects = mObjectIndices[category];

      if( index>=0 && index<objects.length ) return objects[index];

      }

    return -1;

    }

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

  public int getCategory(int objectIndex)

    {

    int numC = mObjectIndices.length;

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

      for(int object : mObjectIndices[c])

        if( object==objectIndex ) return c;

    return -1;

    }

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

  public int getPosInCat(int category, int objectIndex)

    {

    int[] objects = mObjectIndices[category];

    int len = objects.length;

    for(int o=0; o<len; o++)

      if( objects[o]==objectIndex ) return o;

    return -1;

    }

}