Creating a Java program to use auto assignment

package com.example.bundle;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;

import com.bmc.arsys.rx.assignment.business.domain.AgentAssignmentCalculator;
import com.bmc.arsys.rx.foundation.domain.Agent;

/**
* This class implements the Agent Assignment Interface provided by
* Cognitive Services.
* Developer is supposed to provide following methods to help the assignment
* engine to pick the right assignee.
*
*/
public class AssignementCalc  extends AgentAssignmentCalculator {
    public List<Agent> applicationAgents = new ArrayList<Agent>();

   /** List of agents login Ids that should exist in Agent foundation record definition */
    public List<String> loginIds = Arrays.asList("Jason Wen", "Ashish Ghumnar", "calvin", "hobbes");

   /** The priorities. Smaller number represents higher priority. */
    public List<Integer> priorities = Arrays.asList(0, 1, 2, 3);

   /**
    * Creating an agent list (used for demo purposes). Those agents should exist in Agent
    * foundation record definition.
    */
    public AssignementCalc() {
       for (String loginId : loginIds) {
            Agent agent = new Agent();
            agent.setLoginId(loginId);
            applicationAgents.add(agent);
        }
    }

   /**
    * This method overrides the method from the Cognitive Assignment interface. It is supposed to
    * send back a list of Agents, sorted by their skill level.
    *
    * This implementation is for the assignment type "by skill level".
    *
    * @param agents
    *            List of agents provided by the assignment engine. It merely contains their login
    *            ID.
    *
    * @return List of Agents, sorted by their skill level as List<Agent>
    */
   @Override
    public List<Agent> rankAgentsBySkillLevel(List<Agent> agents) {
       // As an example we just shuffle the list.
        Collections.shuffle(agents);
       return agents;
    }

   /**
    * This method overrides the method from the Cognitive Assignment interface. It is supposed to
    * send back a list of Agents loginIds and their typical effort (in hours) by Priority. This
    * will be used to assess which developer should be assigned to a task but weighting with the
    * task priority.
    *
    * @param agents
    *            List of agents provided by the assignment engine. It merely contains their login
    *            ID.
    *
    * @return List of Agents loginIds, with a List of their typical efforts per priority as
    *         Map<String, Map<Priority, Float>>
    */
   @Override
    public Map<String, Map<Integer, Float>> getEffortsByPriorityAndByAgents(List<Agent> agents) {
       // As an example we just build a list with random values.
        Map<String, Map<Integer, Float>> effortsByPriorityAndByAgents = new HashMap<String, Map<Integer, Float>>();

       for (Agent agent : agents) {
            Map<Integer, Float> effortPriority = new HashMap<Integer, Float>();

           for (Integer currentPriority : priorities) {
                effortPriority.put(currentPriority, (float) getRandomValue(0, 50));
            }

            effortsByPriorityAndByAgents.put(agent.getLoginId(), effortPriority);
        }

       return effortsByPriorityAndByAgents;
    }

   /**
    * This method overrides the method from the Cognitive Assignment interface. It is supposed to
    * send back a list of Agents loginIds with their last assignment date.
    *
    * This implementation is for the assignment type "round robin".
    *
    * @param agents
    *            List of agents provided by the assignment engine. It merely contains their login
    *            ID.
    *
    * @return List of Agents loginIds with their last assignment date as Map<String, Date>.
    */
   @Override
    public Map<String, Date> getAgentsLastAssignTime(List<Agent> agents) {
       // As an example we just build a list with random date values.
        Map<String, Date> agentsLastAssignTime = new HashMap<String, Date>();

       for (Agent agent : agents) {
            agentsLastAssignTime.put(agent.getLoginId(), getRandomDate());
        }

       return agentsLastAssignTime;
    }

   /**
    * This method overrides the method from the Cognitive Assignment interface. It is supposed to
    * send back a list of Agents loginIds with their current number of assigned tasks.
    *
    * This implementation is for the assignment type "by number".
    *
    * @param agents
    *            List of agents provided by the assignment engine. It merely contains their login
    *            ID.
    *
    * @return List of Agents loginIds with their with their current number of assigned tasks as
    *         Map<String, Integer>.
    */
   @Override
    public Map<String, Integer> getAgentNumberOfAssignedTasks(List<Agent> agents) {
       // As an example we just build a list with random values.
        Map<String, Integer> agentNumberOfAssignedTasks = new HashMap<String, Integer>();

       for (Agent agent : agents) {
            agentNumberOfAssignedTasks.put(agent.getLoginId(), getRandomValue(0, 10));
        }

       return agentNumberOfAssignedTasks;
    }

   /**
    * This method overrides the method from the Cognitive Assignment interface. It
    * sends back a list of Agents loginIds with their actual capacity.
    *
    * This implementation is for the assignment type "by capacity".
    *
    * @param agents
    *            List of agents provided by the assignment engine. It merely contains their login
    *            ID.
    *
    * @return List of Agents loginIds with their with their actual capacity as Map<String, Float>.
    */
   @Override
    public Map<String, Float> getAgentCapacity(List<Agent> agents) {
       // As an example we just build a list with random values.
        Map<String, Float> agentCapacity = new HashMap<String, Float>();

       for (Agent agent : agents) {
            agentCapacity.put(agent.getLoginId(), (float) getRandomValue(0, 100));
        }

       return agentCapacity;
    }

   /**
    * This method overrides the method from the Cognitive Assignment interface. It is supposed to
    * send back a list of Agents loginIds with the amount of their available time between the
    * current Date and a date provided by the assignment engine. This amount, in hours, could be
    * determined by their usual schedule, PTO and current assignments.
    *
    * @param agents
    *            List of agents provided by the assignment engine. It merely contains their login
    *            ID.
    *
    * @return List of Agents loginIds with their with their amount of available time (hours) as
    *         Map<String, Float>.
    */
   @Override
    public Map<String, Float> getAvailableWorkHours(List<Agent> agents, Date date) {
       // As an example we just build a list with random values.

        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.DATE, -8);

       int hoursDifference = getDateDifference(date, cal.getTime());

        Map<String, Float> availableWorkHours = new HashMap<String, Float>();

       for (Agent agent : applicationAgents) {
            availableWorkHours.put(agent.getLoginId(), (float) getRandomValue(0, hoursDifference));
        }

       return availableWorkHours;
    }

   /**
    * Generate a random Date.
    * https://stackoverflow.com/questions/11016336/how-to-generate-a-random-timestamp-in-java
    *
    * @return a random Date in Date format.
    */
    private Date getRandomDate() {
        Random r = new Random();
       long unixtime = (long) (1293861599 + r.nextDouble() * 60 * 60 * 24 * 365);

       return new Date(unixtime);
    }

   /**
    * generate a random number in the provided range
    * https://stackoverflow.com/questions/363681/how-do-i-generate-random-integers-within-a-
    * specific-range-in-java
    *
    * @param min
    *            Minimum value for the random number.
    * @param max
    *            Maximum value for the random number.
    *
    * @return random number as an int.
    */
    private int getRandomValue(int min, int max) {
       return ThreadLocalRandom.current().nextInt(min, max + 1);
    }

   /**
    * Get difference between two dates, in hours.
    * https://stackoverflow.com/questions/2003521/find-total-hours-between-two-dates
    *
    * @param date1
    *            Begin date
    * @param date2
    *            End date
    * @return difference between both dates in hours.
    */
    private static int getDateDifference(Date date1, Date date2) {

        final int MILLI_TO_HOUR = 1000 * 60 * 60;
       return (int) (date1.getTime() - date2.getTime()) / MILLI_TO_HOUR;
    }
}