import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.stream.Collectors;
import java.util.stream.Stream;


public class MapToMapOperation {

    private Map<String, Map<String, Integer>> mapToMap = new HashMap<>();

    MapToMapOperation() {
        Map<String, Integer> dogMap = new HashMap<>();
        dogMap.put("A", 50);
        dogMap.put("B", 35);
        dogMap.put("D", 40);
        dogMap.put("C", 35);
        mapToMap.put("dog", dogMap);

        Map<String, Integer> catMap = new HashMap<>();
        catMap.put("C", 35);
        catMap.put("D", 40);
        catMap.put("M", 40);
        catMap.put("E", 70);
        catMap.put("H", 35);
        mapToMap.put("cat", catMap);

        Map<String, Integer> donkeyMap = new HashMap<>();
        donkeyMap.put("A", 52);
        donkeyMap.put("E", 70);
        donkeyMap.put("F", 80);
        donkeyMap.put("S", 40);
        donkeyMap.put("G", 90);
        mapToMap.put("donkey", donkeyMap);
    }

    public Map<String, Integer> get(String type) {
        return mapToMap.get(type);
    }

    public List<String> get(Map<String, Integer> map, Integer value) {
        if (!map.containsValue(value)) {
            return Collections.emptyList();
        }
        return keys(map, value).collect(Collectors.toList());
    }

    public Map<String, List<String>> getFullMapBasedOnValue(Integer value) {
        Map<String, List<String>> resultMap = new HashMap<String, List<String>>();
        java.util.Iterator<Entry<String, Map<String, Integer>>> iterator =
                mapToMap.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, Map<String, Integer>> entry = iterator.next();
            Map<String, Integer> subMap = entry.getValue();
            if (subMap.containsValue(value)) {
                List<String> list = keys(subMap, value).collect(Collectors.toList());
                resultMap.put(entry.getKey(), list);
            }
        }
        return resultMap;
    }

    public <K, V> Stream<K> keys(Map<K, V> map, V value) {
        return map.entrySet().stream().filter(entry -> value.equals(entry.getValue())).map(Map.Entry::getKey);
    }

    public static void main(String[] args) {
        MapToMapOperation mapOp = new MapToMapOperation();
        mapOp.get("dog").forEach((s, k) -> System.out.println(s + " " + k));

        System.out.println(mapOp.get(mapOp.get("cat"), 35));

        System.out.println(mapOp.getFullMapBasedOnValue(40));
    }

}