[НП] File System

import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;

/**
 * Partial exam II 2016/2017
 */
public class FileSystemTest {
    public static void main(String[] args) {
        FileSystem fileSystem = new FileSystem();
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        scanner.nextLine();
        for (int i = 0; i < n; i++) {
            String line = scanner.nextLine();
            String[] parts = line.split(":");
            fileSystem.addFile(parts[0].charAt(0), parts[1],
                    Integer.parseInt(parts[2]),
                    LocalDateTime.of(2016, 12, 29, 0, 0, 0).minusDays(Integer.parseInt(parts[3]))
            );
        }
        int action = scanner.nextInt();
        if (action == 0) {
            scanner.nextLine();
            int size = scanner.nextInt();
            System.out.println("== Find all hidden files with size less then " + size);
            List<File> files = fileSystem.findAllHiddenFilesWithSizeLessThen(size);
            files.forEach(System.out::println);
        } else if (action == 1) {
            scanner.nextLine();
            String[] parts = scanner.nextLine().split(":");
            System.out.println("== Total size of files from folders: " + Arrays.toString(parts));
            int totalSize = fileSystem.totalSizeOfFilesFromFolders(Arrays.stream(parts)
                    .map(s -> s.charAt(0))
                    .collect(Collectors.toList()));
            System.out.println(totalSize);
        } else if (action == 2) {
            System.out.println("== Files by year");
            Map<Integer, Set<File>> byYear = fileSystem.byYear();
            byYear.keySet().stream().sorted()
                    .forEach(key -> {
                        System.out.printf("Year: %d\n", key);
                        Set<File> files = byYear.get(key);
                        files
                                //.sorted()
                                .forEach(System.out::println);
                    });
        } else if (action == 3) {
            System.out.println("== Size by month and day");
            Map<String, Long> byMonthAndDay = fileSystem.sizeByMonthAndDay();
            byMonthAndDay.keySet().stream().sorted()
                    .forEach(key -> System.out.printf("%s -> %d\n", key, byMonthAndDay.get(key)));
        }
        scanner.close();
    }
}

class File {
    private String name;
    private Integer size;
    private LocalDateTime createdAt;

    public File(String name, Integer size, LocalDateTime createdAt) {
        this.name = name;
        this.size = size;
        this.createdAt = createdAt;
    }

    public String getName() {
        return name;
    }

    public Integer getSize() {
        return size;
    }

    public LocalDateTime getCreatedAt() {
        return createdAt;
    }

    @Override
    public String toString() {
        return String.format("%-10s %5dB %s", name, size, createdAt);
    }
}

class Folder {
    private Character name;
    private Set<File> files;

    public Folder(Character name) {
        this.name = name;
        this.files = new TreeSet<>(
                Comparator.comparing(File::getCreatedAt)
                        .thenComparing(File::getName)
                        .thenComparing(File::getSize)
        );
    }

    public void addFile(File newFile) {
        files.add(newFile);
    }

    public Character getName() {
        return name;
    }

    public Set<File> getFiles() {
        return files;
    }
}

class FileSystem {
    Map<Character, Folder> folders;

    public FileSystem() {
        this.folders = new HashMap<>();
    }

    public void addFile(char folder, String name, int size, LocalDateTime createdAt) {
        Folder currFolder = folders.computeIfAbsent(folder, (f) -> new Folder(folder));
        File newFile = new File(name, size, createdAt);
        currFolder.addFile(newFile);
    }

    public List<File> findAllHiddenFilesWithSizeLessThen(int size) {
        return folders.values().stream()
                .flatMap((folder) -> folder.getFiles().stream())
                .filter((f) -> f.getName().startsWith(".") && f.getSize() < size)
                .collect(Collectors.toList());
    }

    public int totalSizeOfFilesFromFolders(List<Character> folders) {
        return folders.stream()
                .mapToInt((folder) -> {
                    Folder inFolder = this.folders.get(folder);
                    return inFolder.getFiles().stream()
                            .mapToInt(File::getSize)
                            .sum();
                }).sum();
    }

    public Map<Integer, Set<File>> byYear() {
        HashMap<Integer, Set<File>> byYear = new HashMap<>();
        Comparator<File> comparatorByYear = Comparator.comparing(File::getCreatedAt)
                .thenComparing(File::getName)
                .thenComparing(File::getSize);

        folders.values().stream()
                .flatMap((folder) -> folder.getFiles().stream())
                .forEach((file) -> {
                    Set<File> fileSet = byYear.computeIfAbsent(file.getCreatedAt().getYear(), (f) -> new TreeSet<>(comparatorByYear));
                    fileSet.add(file);
                });

        return byYear;
    }

    public Map<String, Long> sizeByMonthAndDay() {
        Map<String, Long> byMonthAndDay = new HashMap<>();

        folders.values().stream()
                .flatMap((folder) -> folder.getFiles().stream())
                .forEach((file) -> {
                    String monthAndDay = file.getCreatedAt().getMonth().toString() + "-" + file.getCreatedAt().getDayOfMonth();
                    Long currValue = byMonthAndDay.computeIfAbsent(monthAndDay, (f) -> 0L);
                    currValue += file.getSize().longValue();
                    byMonthAndDay.put(monthAndDay, currValue);
                });

        return byMonthAndDay;
    }
}