[NP] Streaming Platform

import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.*;
import java.util.stream.Collectors;
import java.util.List;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

class TVShow extends Show{

    List<List<Integer>> episodes;
    List<Double> episode_ratings;

    public TVShow(String name, List<String> genres,List<List<Integer>> episodes) {
        super(name, genres);
        this.episodes= episodes;
        this.episode_ratings= new ArrayList<>();
        calculateRating(episodes);
    }

    public void calculateRating(List<List<Integer>> episodes) {
        for(List<Integer> episode : episodes){
            episode_ratings.add(((double)episode.stream().mapToInt(i->i).sum()/episode.stream().count())
                    *Math.min(episode.size()/20.0,1.00));

        }

    }

    @Override
    public double averageRating() {
        return (episode_ratings.stream().sorted(Comparator.reverseOrder()).limit(3).mapToDouble(i->i).sum())/3.00;
    }


    @Override
    public ShowType getShowType() {
        return ShowType.TV_Show;
    }

    @Override
    public String getNumberOfEpisodes() {
        return String.format("(%d episodes)",this.episodes.size());
    }


    @Override
    public int compareTo(Show other) {
        return Double.compare(this.averageRating(),other.averageRating());
    }
}

enum ShowType {
    Movie,
    TV_Show
}

abstract class Show implements Comparable<Show> {
    private String name;
    private List<String> genres;

    public Show(String name,List<String> genres) {
        this.name = name;
        this.genres= genres;
    }

        public List<String> getGenres() {
        return genres;
    }

    public abstract double averageRating();

    public abstract ShowType getShowType();

    public abstract String getNumberOfEpisodes();


    @Override
    public String toString() {


        return String.format("%s %s %.4f %s",getShowType().name().replace("_"," "),name,averageRating(),getNumberOfEpisodes());

    }
}


class StreamingPlatform {
    private List<Show> shows;

    public StreamingPlatform() {
        this.shows = new ArrayList<>();
    }

    public void addItem(String data) {
    String[] parts = data.split(";");
    String name= parts[0];
    List<String> genres = Arrays.stream(parts[1].split(",")).collect(Collectors.toList());
    List<Integer> ratings = new ArrayList<>();
    List<List<Integer>> episodes = new ArrayList<>();
        if(parts.length<4){
            ratings = Arrays.stream(parts[2].split("\\s+"))
                    .map(i-> Integer.parseInt(i)).collect(Collectors.toList());
            this.shows.add(new Movie(name,genres,ratings));
        }

        else{
            for(int i=2;i<parts.length;i++){
                ratings = Arrays.stream(parts[i].split("\\s+")).skip(1)
                        .map(rating-> Integer.parseInt(rating)).collect(Collectors.toList());
                episodes.add(ratings);
            }
            this.shows.add(new TVShow(name,genres,episodes));
    }


    }

    public void listAllItems(PrintStream out) {
        PrintWriter printWriter = new PrintWriter(out);

        shows.stream().sorted(Comparator.reverseOrder()).forEach(i->printWriter.println(i));

        printWriter.flush();
    }

    public void listFromGenre(String genre, PrintStream out) {

        PrintWriter printWriter = new PrintWriter(out);

        shows.stream().filter(i-> i.getGenres().contains(genre))
                .sorted(Comparator.reverseOrder())
                .forEach(i->printWriter.println(i));

        printWriter.flush();
    }
}

class Movie extends Show{

    private List<Integer> ratings;
    private ShowType showType;
    public Movie(String name, List<String> genres, List<Integer> ratings) {
        super(name, genres);
        this.ratings= ratings;
        this.showType= ShowType.Movie;
    }


    @Override
    public double averageRating() {
        return ((double)ratings.stream().mapToInt(i->i).sum()/ratings.stream().count())*Math.min(ratings.size()/20.0,1.00) ;

    }

    @Override
    public ShowType getShowType() {
        return ShowType.Movie;
    }

    @Override
    public String getNumberOfEpisodes() {
        return "";
    }

    @Override
    public int compareTo(Show other) {
        return Double.compare(this.averageRating(),other.averageRating());
    }

}


public class StreamingPlatformTest {
    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(" ");
            String method = parts[0];
            String data = Arrays.stream(parts).skip(1).collect(Collectors.joining(" "));
            if (method.equals("addItem")){
                sp.addItem(data);
            }
            else if (method.equals("listAllItems")){
                sp.listAllItems(System.out);
            } else if (method.equals("listFromGenre")){
                System.out.println(data);
                sp.listFromGenre(data, System.out);
            }
        }

    }
}