[NP] Letterboxd

import java.util.*;
import java.util.stream.Collectors;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
class Rating {

    Movie movie;
    int rating;

    public Rating( Movie movie, int rating) {

        this.movie = movie;
        this.rating = rating;
    }

    public Movie getMovie() {
        return movie;
    }

    public int getRating() {
        return rating;
    }

    @Override
    public String toString() {
        return String.format("%s",movie.toString());
    }
}

class User {
    String id;
    String username;


    public User(String id, String username) {
        this.id = id;
        this.username = username;

    }

    @Override
    public String toString() {
        return String.format("User ID: %s Name: %s",id,username);
    }
}



class Movie implements Comparable<Movie> {
    String id;
    String name;
    List<Integer> ratings;

    public Movie(String id, String name) {
        this.id = id;
        this.name = name;
        this.ratings = new ArrayList<>();
    }

    public double getAverageRating() {
        return ratings.stream().mapToInt(i->i).average().orElse(0.0);
    }

    @Override
    public String toString() {
        return String.format("Movie ID: %s Title: %s Rating: %.2f",id,name,getAverageRating());
    }

    @Override
    public int compareTo(Movie o) {
        return Comparator.comparing(Movie::getAverageRating).reversed().compare(this,o);
    }
}
class CosineSimilarityCalculator {

    public static double cosineSimilarity(Map<String, Integer> c1, Map<String, Integer> c2) {
        return cosineSimilarity(c1.values(), c2.values());
    }

    public static double cosineSimilarity(Collection<Integer> c1, Collection<Integer> c2) {
        int[] array1;
        int[] array2;
        array1 = c1.stream().mapToInt(i -> i).toArray();
        array2 = c2.stream().mapToInt(i -> i).toArray();
        double up = 0.0;
        double down1 = 0, down2 = 0;

        for (int i = 0; i < c1.size(); i++) {
            up += (array1[i] * array2[i]);
        }

        for (int i = 0; i < c1.size(); i++) {
            down1 += (array1[i] * array1[i]);
        }

        for (int i = 0; i < c1.size(); i++) {
            down2 += (array2[i] * array2[i]);
        }

        return up / (Math.sqrt(down1) * Math.sqrt(down2));
    }
}

class StreamingPlatform {

    Map<String, Movie> movies;
    Map<String, User> users;
    Map<String, List<Rating>> ratingsByUser;

    public StreamingPlatform() {
        this.movies = new HashMap<>();
        this.users = new HashMap<>();
        this.ratingsByUser = new HashMap<>();
    }

    public void addMovie(String id, String name) {
        movies.putIfAbsent(id, new Movie(id, name));
    }

    public void addUser(String id, String name) {
        users.putIfAbsent(id, new User(id, name));
    }

    public void addRating(String userId, String movieId, int rating) {
        movies.get(movieId).ratings.add(rating);
        ratingsByUser.putIfAbsent(userId, new ArrayList<>());
        ratingsByUser.get(userId).add(new Rating(movies.get(movieId), rating));
    }

    public void topNMovies(int n) {
        movies.values().stream().sorted().limit(n).forEach(i -> System.out.println(i));
    }

    public void favouriteMoviesForUsers(List<String> users) {
        for (String userId : users) {
            int maxRating = ratingsByUser.get(userId).stream().map(i -> i.getRating()).max(Comparator.naturalOrder()).orElse(0);
            System.out.println(this.users.get(userId));
            ratingsByUser.get(userId).stream().filter(i -> i.getRating() == maxRating)
                    .map(i -> i.getMovie())
                    .sorted()
                    .forEach(i -> System.out.println(i));
            System.out.println();
        }

    }

    public void similarUsers(String userId) {
    Map<User,Double> cosineSimularityByUser = new HashMap<>();
        for (User u : users.values().stream().filter(i -> !i.id.equals(userId)).collect(Collectors.toList())) {
            Map<String, Integer> mapOfRatings = new LinkedHashMap<>();
            Map<String, Integer> ratingsByAnotherUser = new LinkedHashMap<>();
            movies.values().stream().forEach(i -> mapOfRatings.putIfAbsent(i.id, 0));
            ratingsByUser.get(userId).stream().forEach(i -> mapOfRatings.computeIfPresent(i.movie.id, (k, v) -> i.getRating()));
            movies.values().stream().forEach(i -> ratingsByAnotherUser.putIfAbsent(i.id, 0));
            ratingsByUser.get(u.id).stream()
                    .forEach(i -> ratingsByAnotherUser.computeIfPresent(i.movie.id, (k, v) -> i.getRating()));

            cosineSimularityByUser.putIfAbsent(u,CosineSimilarityCalculator.cosineSimilarity(mapOfRatings, ratingsByAnotherUser));
//            System.out.println(String.format("User ID: %s Name: %s %f",
//                    u.id, u.username, CosineSimilarityCalculator.cosineSimilarity(mapOfRatings, ratingsByAnotherUser)));
        }
        cosineSimularityByUser.entrySet().stream().sorted(Map.Entry.<User, Double> comparingByValue(Comparator.reverseOrder()))
                .forEach(i -> System.out.println(String.format("User ID: %s Name: %s %f",
                        i.getKey().id,i.getKey().username,i.getValue())));

    }
}
public class StreamingPlatform2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        StreamingPlatform sp = new StreamingPlatform();

        while (sc.hasNextLine()){
            String line = sc.nextLine();
            String [] parts = line.split("\\s+");

            if (parts[0].equals("addMovie")) {
                String id = parts[1];
                String name = Arrays.stream(parts).skip(2).collect(Collectors.joining(" "));
                sp.addMovie(id ,name);
            } else if (parts[0].equals("addUser")){
                String id = parts[1];
                String name = parts[2];
                sp.addUser(id ,name);
            } else if (parts[0].equals("addRating")){
                //String userId, String movieId, int rating
                String userId = parts[1];
                String movieId = parts[2];
                int rating = Integer.parseInt(parts[3]);
                sp.addRating(userId, movieId, rating);
            } else if (parts[0].equals("topNMovies")){
                int n = Integer.parseInt(parts[1]);
                System.out.println("TOP " + n + " MOVIES:");
                sp.topNMovies(n);
            } else if (parts[0].equals("favouriteMoviesForUsers")) {
                List<String> users = Arrays.stream(parts).skip(1).collect(Collectors.toList());
                System.out.println("FAVOURITE MOVIES FOR USERS WITH IDS: " + users.stream().collect(Collectors.joining(", ")));
                sp.favouriteMoviesForUsers(users);
            } else if (parts[0].equals("similarUsers")) {
                String userId = parts[1];
                System.out.println("SIMILAR USERS TO USER WITH ID: " + userId);
                sp.similarUsers(userId);
            }
        }
    }
}