selection

package amazonOnsite;

import java.util.*;
import java.util.Map.Entry;

import test.Test;
import amazonOnsite.Scheduler2.TimeNode;
import amazonOnsite.Scheduler2.Type;


public class Selection {

    private static final int NUMBER_OF_AREAS = 6;
    
    public static void select(List<ScheduleRequest> scheduleRequests, List<Integer> selectionRequests) {
        List<ScheduleRequest> selected = new ArrayList<>(NUMBER_OF_AREAS);
        List<String> locations = getLocations(scheduleRequests);
        //TODO what to do with empty selected contents
        Map<Integer, List<ScheduleRequest>> candidates = getCandidates(scheduleRequests, selectionRequests);
        //put commercials into lists
        for (Integer request : candidates.keySet()) {
            Map<String, ScheduleRequest> selectedContents = selectContents(getCommercialsByArea(candidates.get(request), locations));
            Test.print(selectedContents);
        }
    }
    
    private static List<String> getLocations(List<ScheduleRequest> scheduleRequests) {
        // TODO
        Set<String> locationSet = new HashSet<>();
        for (ScheduleRequest scheduleRequest : scheduleRequests) {
            if (!locationSet.contains(scheduleRequest.locationId)) {
                locationSet.add(scheduleRequest.locationId);
            }
        }
        List<String> locationList = new ArrayList<>();
        locationList.addAll(locationSet);
        //TODO sort this list by it's frequency
        return locationList;
    }

    private static Map<Integer, List<ScheduleRequest>> getCandidates(List<ScheduleRequest> scheduleRequests, List<Integer> requests) {
        List<TimeNode> timeNodes = getTimeNodes(scheduleRequests);
        Map<Integer, List<ScheduleRequest>> result = new HashMap<Integer, List<ScheduleRequest>>();
        Collections.sort(timeNodes, TimeNode.timeComparator);
        Collections.sort(requests);
        //node Index
        int nodeIndex = 0;
        //request Index
        int reqIndex = 0;
        //scan the requests
        Set<ScheduleRequest> overlappedCommercials = new HashSet<>();
        while (reqIndex < requests.size() && nodeIndex < timeNodes.size()) {
            TimeNode node = timeNodes.get(nodeIndex);
            while (reqIndex < requests.size() && node.getTime() >= requests.get(reqIndex)) {
                List<ScheduleRequest> newCommercials = new ArrayList<>(overlappedCommercials.size());
                newCommercials.addAll(overlappedCommercials);
                result.put(requests.get(reqIndex), newCommercials);
                reqIndex++;
            }
            if (node.getType() == Type.start) {
                overlappedCommercials.add(scheduleRequests.get(node.getIndex()));
            }
            if (node.getType() == Type.end) {
                overlappedCommercials.remove(scheduleRequests.get(node.getIndex()));
            }
            nodeIndex++;
        }
        if (reqIndex != requests.size()) {
            while (reqIndex < requests.size()) {
                result.put(requests.get(reqIndex), new ArrayList<ScheduleRequest>());
            }
        }
        return result;
    }
    
    private static List<TimeNode> getTimeNodes(List<ScheduleRequest> scheduleRequests) {
        List<TimeNode> timeNodes = new ArrayList<TimeNode>(scheduleRequests.size() * 2);
        for (int i = 0; i < scheduleRequests.size(); i++) {
            timeNodes.addAll(TimeNode.constructNodes(scheduleRequests.get(i), i));
        }
        return timeNodes;
    }
    
    
    private static Map<String, List<ScheduleRequest>> getCommercialsByArea(List<ScheduleRequest> scheduleRequests, List<String> locations) {
        Map<String, List<ScheduleRequest>> commercialsByArea = new HashMap<>();
        for (ScheduleRequest scheduleRequest : scheduleRequests) {
            if (!commercialsByArea.containsKey(scheduleRequest.locationId)) {
                commercialsByArea.put(scheduleRequest.locationId, new ArrayList<ScheduleRequest>());
            }
            commercialsByArea.get(scheduleRequest.locationId).add(scheduleRequest);
        }
        for (String location : locations) {
            if (!commercialsByArea.containsKey(location)) {
                //TODO sort by value
                //TODO deal with empty list
                commercialsByArea.put(location, new ArrayList<ScheduleRequest>());
            }
            commercialsByArea.get(location).add(new ScheduleRequest(location, location, 0, 0, 0));
        }
        return commercialsByArea;
    }
    
    private static Map<String, ScheduleRequest> selectContents(Map<String, List<ScheduleRequest>> candidates) {
        //TODO edge cases??
        currentMaxValue = Integer.MIN_VALUE;
        currentMaxSelected = new ArrayList<ScheduleRequest>(candidates.keySet().size());
        List<String> locations = new ArrayList<>(candidates.keySet().size());
        locations.addAll(candidates.keySet());
        helper(new ArrayList<ScheduleRequest>(candidates.keySet().size()), candidates, 0, locations);
        Map<String, ScheduleRequest> result = new HashMap<>();
        for (int i = 0; i < locations.size(); i++) {
            result.put(locations.get(i), currentMaxSelected.get(i));
        }
        return result;
    }
    
    private static int currentMaxValue = 0;
    private static List<ScheduleRequest> currentMaxSelected = null;
    
    /*
     * This function is for...
     * For example
     * 1 c1 c3
     * 2 c2 c4
     * c1
     * c1 c2
     * c1 c4
     * c3
     * c3 c2
     * c3 c4
     * 
     * List<ScheduleRequest> selected : dddddddd
     * ......
     * 
     * 
     */
    
    
    private static void helper(
        List<ScheduleRequest> selected, 
        Map<String, List<ScheduleRequest>> candidates, 
        int indexOfLevel, 
        List<String> locations) {
        
        if (selected.size() == locations.size()) {
            int currentValue = sumValue(selected);
            if (currentValue > currentMaxValue) {
                currentMaxSelected = new ArrayList<>(selected);
                currentMaxValue = currentValue;
            }
            return;
        }
        for (ScheduleRequest scheduleRequest : candidates.get(locations.get(indexOfLevel))) {
            if (selected.contains(scheduleRequest)) {
                continue;
            }
            selected.add(scheduleRequest);
            helper(selected, candidates, indexOfLevel++, locations);
            selected.remove(selected.size() - 1);
        }
    }
    
    private static int sumValue(List<ScheduleRequest> scheduleRequests) {
        // TODO
        return 0;
    }
    
    
}