/* Listen to achievement events*/
// Incoming achievement
entity.getEvents().addListener("updateAchievement", this::updateAchievementsUI);
// Event to clear achievement after RENDER_INTERVAL
entity.getEvents().addListener("clear", this::clear);
// Event to display achievement in render queue
entity.getEvents().addListener("display", this::display);

/**
 * Renders the current achievement notification on the table
 *
 * @param achievement Configuration with properties and conditions for corresponding achievement
 */
private void renderAchievement(BaseAchievementConfig achievement) {
        CharSequence text = achievement.message;
        achievementLabel = new Label(text, skin, "small");
        achievementImg = new Image(ServiceLocator.getResourceService()
                .getAsset(achievement.iconPath, Texture.class));
        table.add(achievementImg).size(300f, 150f);
        table.row();
        table.add(achievementLabel);
}

@Override
 public void create() {
        super.create();
        AchievementsHelper.getInstance().getEvents()
                .addListener(AchievementsHelper.HEALTH_EVENT, this::setHealth);
        AchievementsHelper.getInstance().getEvents()
                .addListener(AchievementsHelper.ITEM_PICKED_UP_EVENT, this::setItemCount);
}

    /**
     * Checks if an achievement is valid
     * Unlocks the achievement if it is valid and triggers an event
     * pertaining to a new unlocked achievement
     *
     * @param achievement achievement to be validated
     * @return valid returns true if valid, false otherwise
     */
    private boolean isValid(BaseAchievementConfig achievement) {
        if (achievement.unlocked) {
            return true;
        }

        boolean valid = false;

        for (String cond : propertyList.keySet()) {
            // Operation to perform when checking if achievement property has been satisfied or not
            String operation = propertyList.get(cond).operation;
            // Default game variable values
            double defaultConditionVal = propertyList.get(cond).defaultValue;
            // Current game variable values (current time, score etc)
            double currentPropertyVal = gameConditions.getOrDefault(cond, defaultConditionVal);

            int conditionVal = achievement.getConditionMap().get(cond);

            if (conditionVal != -1) {
                if (cond.equals("time")) {
                    // Convert minutes to milliseconds, since the time in config is supplied in minutes
                    conditionVal = conditionVal * 60000;
                }
                // Perform comparisons to check if conditions of the achievement have been satisfied
                switch (operation) {
                    case "==":
                        valid = conditionVal == currentPropertyVal;
                        break;
                    case "<=":
                        valid = conditionVal <= currentPropertyVal;
                        break;
                    default:
                        // Unknown operation
                        valid = false;
                        break;
                }
                // Stop looping if a condition of achievement was not satisfied
                if (!valid) {
                    break;
                }
            }
        }

        // Finally, if the achievement is valid, unlock it.
        if (valid) {
            achievement.unlocked = true;
            // Emit an event if the achievement is valid
            entity.getEvents().trigger("updateAchievement", achievement);
        }

        return valid;
    }

/**
 * Triggers an event when an item is picked up for
 * the achievements system
 */
 public void trackItemPickedUpEvent() {
     handler.trigger(ITEM_PICKED_UP_EVENT);
 }

 /**
  * Tracks changes in the health property of the player
  * and triggers an event for the achievements system
  * @param health the player's health
  */
 public void trackHealthEvent(int health) {
        handler.trigger(HEALTH_EVENT, health);
 }

// Notify the Achievements System when an item is picked up
AchievementsHelper.getInstance().trackItemPickedUpEvent();
// Notify the Achievements System when the health is updated
AchievementsHelper.getInstance().trackHealthEvent(int health);

/**
 * Factory to create Achievement entities with predefined conditions.
 *
 * <p>Each Achievement entity type should have a creation method that returns a corresponding entity.
 * Predefined achievement entity conditions can be loaded from configs stored as json files 
 * which are defined in "achieve.json".
 */
public class AchievementFactory {
    private static final AchievementConfigs configs =
            FileLoader.readClass(AchievementConfigs.class, "configs/achieve.json");

    /**
     * Returns a list of achievements from the "achieve.json" file
     * @return achievements - A list of achievements inflated from the JSON file
     */
    public static Entity createAchievementEntity(){
        return new Entity()
                .addComponent(new AchievementsStatsComponent())
                .addComponent(new AchievementsDisplay());
    }

    public static List<BaseAchievementConfig> getAchievements(){
        return configs.achievements;
    }

    /**
     * Returns a list of paths to corresponding achievement texture images
     * @return paths - A list of paths inflated from achievement list generated using getAchievements()
     */
    public static String[] getTextures(){
        return configs.achievements
                .stream().map(achievement -> achievement.iconPath).collect(Collectors.toList())
                .toArray(new String[configs.achievements.size()]);
    }
}

/**
 * Defines an Arraylist to store a basic set of achievement properties stored in 
 * achievement config files (achieve.json) to be loaded by Achievement Factory
 */
public class AchievementConfigs {
    public List<BaseAchievementConfig> achievements = new ArrayList<>();
}

/**
      * Returns a mapping of the achievement name and value for easy processing
      * This makes it very easy to iterate through all the properties and fetch
      * the values, and saves a lot of technical debt. In simple words, a mapping
      * of member variables and values of the 'ConditionConfig' object is
      * returned by this function.
      *
      * @return conditionProps mapping of condition name and associated value
      */
     public Map<String, Integer> getConditionMap() {
          Map<String, Integer> conditionProps = new LinkedHashMap<>();
          // Get all the member fields of the condition object
          Field[] fields = ConditionConfig.class.getFields();

          for (Field field : fields) {
               String name = field.getName();
               // Get value of the fields
               int value = -1;
               try {
                    value = field.getInt(condition);
               } catch (IllegalAccessException e) {
                    e.printStackTrace();
               }

               conditionProps.put(name, value);
          }
          return conditionProps;
     }

"propertyList": {
    "class": "java.util.LinkedHashMap",
    "distance": {
      "operation": "<=",
      "defaultValue": 0
    },
    // ...
    "gold": {
      "operation": "==",
      "defaultValue": 0
    },
    // ...
    "health": {
      "operation": "<=",
      "defaultValue": 100
    }
    // ...
}

public class PropertyListDefaults {
    public String operation = "NONE";
    public int defaultValue = 0;
}

    /**
     * Achievement UI updates are guaranteed to execute sequentially,
     * and no more than one update will be active at any given time
     *
     * @param achievement Configuration with properties and conditions for corresponding achievement
     */
    private void updateAchievementsUI(BaseAchievementConfig achievement) {
        /* Queue expensive task to run on a separate single thread
         * to run asynchronously. */
        AsyncTaskQueue.enqueueTask(() -> {
            try {
                /* Render achievement card */
                renderAchievement(achievement);
                /* Wait for some time */
                Thread.sleep(RENDER_DURATION);
                /* Remove card from screen */
                table.clear();
            } catch (InterruptedException ignored) {
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
    }

 @Override
 public void dispose() {
        super.dispose();

        /* If the in game screen is out of focus, cancel all future tasks. This has to be
         * done in order to prevent memory leaks, unforeseen exceptions and
         * other nasty bugs.*/
        AsyncTaskQueue.cancelFutureTasksNow();

       // ...
}