BOTAAAAAAA

import javax.xml.crypto.Data;
        import java.awt.*;
        import java.io.Serializable;
        import java.net.*;
        import java.io.IOException;
import java.sql.Array;
import java.sql.SQLOutput;
        import java.util.ArrayList;
        import java.util.Scanner;
        import java.io.*;
        import static java.lang.Thread.sleep;

class User implements Serializable {
    private String username, password, user_type;

    public User(String username, String password, String user_type) {
        this.username = username;
        this.password = password;
        this.user_type = user_type;
    }

    public String getUsername() {
        return username;
    }

    public String getPassword() {
        return password;
    }

    public String getUser_type() { return user_type; }

    public void setUser_type(String user_type) {
        this.user_type = user_type;
    }
}

class Music implements Serializable {
    private String artist, genre, album, name;
    private int duration;

    public Music(String artist, String genre, String album, String name, int duration) {
        this.artist = artist;
        this.genre = genre;
        this.album = album;
        this.name = name;
        this.duration = duration;
    }

    public String getArtist() {
        return artist;
    }

    public String getGenre() {
        return genre;
    }

    public String getAlbum_title() {
        return album;
    }

    public String getName() {
        return name;
    }

    public int getDuration() {
        return duration;
    }
}

class Album implements Serializable {
    private String album_name, description;
    private int rating; //rating médio
    ArrayList <Music> music_list = new ArrayList<>(); //TALVEZ PÔR PRIVATE
    ArrayList <Review> review_list = new ArrayList<>(); //TALVEZ PÔR PRIVATE

    public Album(String album_name, String description, int rating, ArrayList<Music> music_list, ArrayList<Review> review_list) {
        this.album_name = album_name;
        this.description = description;
        this.rating = rating;
        this.music_list = music_list;
        this.review_list = review_list;
    }

    public String getAlbum_name() {
        return album_name;
    }

    public String getDescription() {
        return description;
    }

    public int getRating() {
        return rating;
    }

    public ArrayList<Music> getMusic_list() {
        return music_list;
    }

    public ArrayList<Review> getReview_list() {
        return review_list;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public void setRating(int rating) {
        this.rating = rating;
    }

    public double average_rating (ArrayList <Review> review_list){
        int soma = 0;
        int size = review_list.size();
        double average_rating;

        for (Review r: review_list){
            rating += r.getRating();
        }

        average_rating = (double) rating / size;

        return average_rating;
    }


}

class Review implements Serializable { //AINDA TENHO QUE VER PRECISA DE SERIALIZABLE OU NÃO
    private String text;
    private int rating;
    private String user;

    public Review(String text, int rating, String user) {
        this.text = text;
        this.rating = rating;
        this.user = user;
    }

    public String getText() {
        return text;
    }

    public int getRating() {
        return rating;
    }

    public String getUser() {
        return user;
    }
}

class Artist implements  Serializable{

    String nome, grupo;
    int data_nasc; //TALVIZ CRIAR UMA CLASSE DATA
    ArrayList <Music> music_list;

    public ArrayList<Music> getMusic_list() {
        return music_list;
    }

    public Artist(String nome, String grupo, int data_nasc, ArrayList <Music> music_list) {
        this.nome = nome;
        this.grupo = grupo;
        this.data_nasc = data_nasc;
        this.music_list = music_list;
    }


}


class DatabaseConnection {
    //Ver como ir buscar a música a uma diretoria e colocar música nessa diretoria

    public DatabaseConnection() {
    }

    boolean username_match (String username){

        ArrayList <User> users = new ArrayList<>();

        //Abrir para a leitura do ficheiro de objetos
        try (ObjectInputStream oin = new ObjectInputStream (new FileInputStream("Users_obj.txt"))) {
            users = (ArrayList) oin.readObject();
        } catch (IOException e){
            System.out.println(e.getMessage());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        for (User u: users){
            if (u.getUsername().equals(username)) {
                return true;
            }
        }

        return false;
    }

    boolean password_match (String username, String password){
        //Tenho que procurar por username e depois por password
        //Porque se procuro apenas pela password, pode encontrar a password certa, mas ser de outro utilizador

        ArrayList <User> users = new ArrayList<>();

        try (ObjectInputStream oin = new ObjectInputStream (new FileInputStream("Users_obj.txt"))) {
            users = (ArrayList) oin.readObject();
        } catch (IOException e){
            System.out.println(e.getMessage());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        for (User u: users) {
            if (u.getUsername().equals(username)) {
                if (u.getPassword().equals(password)) {
                    return true;
                }
            }

        }
        return false;
    }

    void write_user_file(String text, ArrayList <User> users) { //Para escrever no ficheiro de utilizadores
        try {
            ObjectOutputStream oS = new ObjectOutputStream(new FileOutputStream(text));
            oS.writeObject(users);
            oS.close();

        } catch (IOException e) {
            System.out.print("ERRO");
            System.out.printf("Ocorreu a exceçao %s ao escrever no ficheiro\n", e);
        }
    }

    ArrayList <Album> get_AlbumList (){
        ArrayList <Album> album_list = new ArrayList<>();

        try (ObjectInputStream oin = new ObjectInputStream (new FileInputStream("AlbumList_obj.txt"))) {
            album_list = (ArrayList) oin.readObject();
        } catch (IOException e){
            System.out.println(e.getMessage());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        return album_list;
    }

    void write_albumlist_file (String text, ArrayList <Album> album_list) { //Para escrever no ficheiro de álbuns
        try {
            ObjectOutputStream oS = new ObjectOutputStream(new FileOutputStream(text));
            oS.writeObject(album_list);
            oS.close();

        } catch (IOException e) {
            System.out.print("ERRO");
            System.out.printf("Ocorreu a exceçao %s ao escrever no ficheiro\n", e);
        }
    }

    ArrayList <Music> get_MusicList (){
        ArrayList <Music> music_list = new ArrayList<>();

        try (ObjectInputStream oin = new ObjectInputStream (new FileInputStream("MusicList_obj.txt"))) {
            music_list = (ArrayList) oin.readObject();
        } catch (IOException e){
            System.out.println(e.getMessage());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        return music_list;
    }

    ArrayList <Artist> get_ArtistList (){
        ArrayList <Artist> artist_list = new ArrayList<>();

        try (ObjectInputStream oin = new ObjectInputStream (new FileInputStream("ArtistList_obj.txt"))) {
            artist_list = (ArrayList) oin.readObject();
        } catch (IOException e){
            System.out.println(e.getMessage());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        return artist_list;
    }

    ArrayList <User> get_UserList (){
        ArrayList <User> user_list = new ArrayList<>();

        try (ObjectInputStream oin = new ObjectInputStream (new FileInputStream("Users_obj.txt"))) {
            user_list = (ArrayList) oin.readObject();
        } catch (IOException e){
            System.out.println(e.getMessage());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        return user_list;
    }

}


class MessageParsing {

    public String [] MessageParsing (String message){

        //Separar por ";" e saber o número de pares
        String [] pares  = message.split(";");
        String  [] campos = new String[pares.length] ;

        if (pares.length >= 3){ //NAO SEI SE PRECISO DESTA CONDICAO OU NAO, TENHO QUE TER ATENCAO POR CAUSA DA EXCEPTION
            for (int i = 0; i < pares.length; i++){
                String [] aux = pares[i].split("\\|");
                campos[i] = aux[1];
            }
        }

        //É melhor imprimir num ciclo que vai ate ao total de elementos do array, caso contrario opde criar exception
        //System.out.println ("Tipo da mensagem: " + campos[0] + " campo2: " + campos[1] + " campo3: " + campos[2]);

        return campos;
    }

}


class UDPMulticastProtocol implements Serializable {

    private String MULTICAST_ADDRESS = "224.3.2.1";
    private int PORT = 4444; //Porto de envio
    DatabaseConnection data = new DatabaseConnection();

    public UDPMulticastProtocol() {
    }

    void login (String username, String password, MulticastSocket socket, int server_id){
        System.out.println("O cliente deseja fazer login");
        System.out.println("Username inserido: " + username);
        System.out.println("Password inserida: " + password);
        //Temos que ir à base de dados checkar se o username existe e qual a password associada e se é igual à inserida ou não


        if (data.username_match(username)){
            if (data.password_match(username, password)){ //SUCESSO
                //System.out.println("GREAT SUCCESS");
                String rsp = "server_id|" + server_id + "; type|status" + "; logged|on; " + "msg|Welcome to DropMusic";

                try{
                    byte[] buffer = rsp.getBytes();
                    InetAddress group = InetAddress.getByName(MULTICAST_ADDRESS);
                    DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(MULTICAST_ADDRESS), PORT); //mudei aqui
                    socket.send(packet);

                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
            else { //PASSWORD ERRADA
                //System.out.println("PASSWORD ERRADA");
                String rsp = "server_id|" + server_id + "; type|status" + "; logged|failed; " + "msg|Password incorreta";

                try{
                    byte[] buffer = rsp.getBytes();
                    InetAddress group = InetAddress.getByName(MULTICAST_ADDRESS);
                    DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(MULTICAST_ADDRESS), PORT); //mudei aqui
                    socket.send(packet);

                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        else{ //UTILIZADOR NAO EXISTE
            //System.out.println("Utilizador nao existe");
            String rsp = "server_id|" + server_id + "; type|status" + "; logged|failed; " + "msg|Utilizador nao existe";

            try{
                byte[] buffer = rsp.getBytes();
                InetAddress group = InetAddress.getByName(MULTICAST_ADDRESS);
                DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(MULTICAST_ADDRESS), PORT); //mudei aqui
                socket.send(packet);

            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }

    void register (String username, String password, MulticastSocket socket, int server_id) throws IOException {

        ArrayList <User> users = new ArrayList<>(); //ArrayList que contém todos os utilizadores
        //Abrir para a leitura do ficheiro de objetos
        try (ObjectInputStream oin = new ObjectInputStream (new FileInputStream("Users_obj.txt"))) {
            users = (ArrayList) oin.readObject();
        } catch (IOException e){
            System.out.println(e.getMessage());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        System.out.println("O cliente deseja registar-se");
        System.out.println("Username inserido: " + username);
        System.out.println("Password inserida: " + password);

        //Temos que ver se existe o username ou não
        if (!data.username_match(username)) {

            //Abrir para escrita no ficheiro de objetos
            if (users.isEmpty()){ //Se der mal, vou ver se o tamanho e zero
                User u = new User(username, password, "admin");
                users.add(u);
            }
            else{
                User u = new User(username, password, "normal");
                users.add(u);
            }

            try {
                ObjectOutputStream oS = new ObjectOutputStream(new FileOutputStream("Users_obj.txt"));
                oS.writeObject(users);
                oS.close();

            } catch (IOException e) {
                System.out.print("ERRO");
                System.out.printf("Ocorreu a exceçao %s ao escrever no ficheiro\n", e);
            }

            String rsp = "server_id|" + server_id + "; type|status;" + "; register|successful; " + "msg|Welcome to DropMusic";
            try{

                byte[] buffer = rsp.getBytes();

                InetAddress group = InetAddress.getByName(MULTICAST_ADDRESS);
                DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(MULTICAST_ADDRESS), PORT); //mudei aqui
                socket.send(packet);

            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        else {
            String rsp = "server_id|" + server_id + "; type|status;" + "; register|unsuccessful; " + "msg|Esse username ja existe";

            try{
                byte[] buffer = rsp.getBytes();

                InetAddress group = InetAddress.getByName(MULTICAST_ADDRESS);
                DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(MULTICAST_ADDRESS), PORT); //mudei aqui
                socket.send(packet);

            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        //SÓ PARA VER QUEM TENHO REGISTADO
        for (User uss: users){
            System.out.println(uss.getUsername() + " " + uss.getPassword() + " -> " + uss.getUser_type());
        }


    }

    void search_music (String choice, String name, MulticastSocket socket, int server_id){ //EM FALTA, COMPLETAR E TESTAR
        System.out.println("O cliente deseja procurar musica");

        switch (choice){
            case "all": //Vai procurar por tudo o que os outros "cases" vao procurar //ACHO QUE VOU RETIRAR ISTO

                break;

            case "album": //Vai ao ficheiro de albuns e apresenta a lista de musicas desse album
                ArrayList <Album> album_list = data.get_AlbumList(); //Vai buscar o ficheiro de albuns e põe nesta arraylist
                //ArrayList <Music> aux = new ArrayList<>(); //ArrayList auxiliar para pôr todos os albuns com o nome "name"
                String x = "";
                int item_count = 0;

                for (Album a: album_list){
                    if (a.getAlbum_name().equals(name)){
                        item_count = a.music_list.size();
                        for (int k = 0; k < item_count; k++)

                        x += "item_"+k+"_name| " + a.music_list.get(k).getName();

                    }
                }

                //1. ENVIAR RESPOSTA PARA O CLIENTE COM A LISTA DE MÚSICAS
                String rsp = "server_id|" + server_id + "; type|status;" + "; music_search|successful; " + "msg|This is the music list from the searched album" +
                        "item_count| " + item_count + x; //Ver se o item_count é bem apresentado

                try{
                    byte[] buffer = rsp.getBytes();
                    DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(MULTICAST_ADDRESS), PORT); //mudei aqui
                    socket.send(packet);
                } catch (IOException e) {
                    e.printStackTrace();
                }


                break;

            case "music":  //Vai ao ficheiro de musicas e apresenta uma lista de musicas que contenham esse nome
                ArrayList <Music> music_list = data.get_MusicList();
                //ArrayList <Music> auxappend = new ArrayList<>();

                String s = "";
                int item_size = 0;

                for (Music m: music_list){
                    if (m.getName().equals(name)){
                        s += "item_"+item_size+"_name| " + m.getName();
                        item_size++;

                    }
                }
                //2. ENVIAR RESPOSTA PARA O CLIENTE COM A LISTA DE MÚSICAS
                String ans = "server_id|" + server_id + "; type|status;" + "; music_search|successful; " + "msg|This is the music list you requested" +
                        "item_count| " + item_size + s; //Ver se o item_size é bem apresentado

                break;

            case "artist": //Vai ao ficheiro de artistas e apresenta as musicas desse artista

                //NOTAAAA: DECIDIR SE CRIO UM FICHEIRO DE ARTISTAS OU SE NÃO É NECESSÁRIO
                ArrayList <Artist> artist_list = data.get_ArtistList();

                String z = "";
                int tam = 0;

                for (Artist a: artist_list){
                    if (a.nome.equals(name)){
                        for (int j = 0; j < a.getMusic_list().size(); j++){
                            tam = a.getMusic_list().size();
                            z += "item_"+ j +"_name| " + a.getMusic_list().get(j).getName();
                        }
                    }
                }

                //2. ENVIAR RESPOSTA PARA O CLIENTE COM A LISTA DE MÚSICAS
                String resp = "server_id|" + server_id + "; type|status;" + "; music_search|successful; " + "msg|This is the music list you requested" +
                        "item_count| " + tam + z; //Ver se o item_size é bem apresentado

                break;

            case "genre": //Vai ao ficheiro de musicas e procura no arraylist de musicas pelo parâmetro "genre"
                ArrayList <Music> music_list1 = data.get_MusicList(); //Vai buscar o ficheiro de albuns e põe nesta arraylist

                String aux = "";
                int conta = 0;

                for (Music m: music_list1){
                    if (m.getGenre().equals(name)){
                        aux += "item_"+conta +"_name| " + m.getName();
                        conta++;
                    }
                }
                //2. ENVIAR RESPOSTA PARA O CLIENTE COM A LISTA DE MÚSICAS
                String envia = "server_id|" + server_id + "; type|status;" + "; music_search|successful; " + "msg|This is the music list you requested" +
                        "item_count| " + conta + aux; //Ver se o conta é bem apresentado

                break;

        }

    }

    void make_editor (String username, String novo_editor, MulticastSocket socket, int server_id){ //TESTAR
        System.out.println("O cliente deseja tornar o utilizador " + novo_editor + " editor");

        ArrayList <User> users = new ArrayList<>();

        try (ObjectInputStream oin = new ObjectInputStream (new FileInputStream("Users_obj.txt"))) {
            users = (ArrayList) oin.readObject();
        } catch (IOException e){
            System.out.println(e.getMessage());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        //Verificar se o utilizador que está a querer tornar o outro num editor é também um editor
        if (data.username_match(username)) { //SUCESSO
            for (User u : users) {
                if (u.getUsername().equals(username)) {
                    if ((u.getUser_type().equals("editor")) || (u.getUser_type().equals("admin"))) {
                        System.out.println("Tem permissao para tornar o utilizador " + novo_editor + " editor");
                        for (User us : users) {
                            if (us.getUsername().equals(novo_editor)) {
                                us.setUser_type("editor");
                                data.write_user_file("Users_obj.txt", users);
                                //ENVIAR RESPOSTA PARA O RMI SERVER
                                //String rsp = "server_id|" + server_id + "; type|status;" + "; logged|on; " + "msg|Welcome to DropMusic";
                                String rsp = "server_id|" + server_id + "; type|status" + "; make editor|successful; " + "msg|You can edit now";
                                try {
                                    byte[] buffer = rsp.getBytes();
                                    InetAddress group = InetAddress.getByName(MULTICAST_ADDRESS);
                                    DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(MULTICAST_ADDRESS), PORT); //mudei aqui
                                    socket.send(packet);

                                } catch (IOException e) {
                                    e.printStackTrace();
                                }
                            /*} else { //FALTA PÔR ESTE CHECK A FUNCIONAR
                                System.out.println("Utilizador nao existe");
                                //ENVIAR RESPOSTA PARA O RMI SERVER
                            }*/
                            }
                        }
                    }
                }
            }

        } else { //ESSE MANO NAO CONSTA DA BASE DE DADOS
            String rsp = "server_id|" + server_id + "; type|status" + "; make editor|unsuccessful; " + "msg|The user you entered is not in our database";
            try {
                byte[] buffer = rsp.getBytes();
                InetAddress group = InetAddress.getByName(MULTICAST_ADDRESS);
                DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(MULTICAST_ADDRESS), PORT); //mudei aqui
                socket.send(packet);

            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }

    void manage_data (String username, String choice, String op_type, String name) { //EM FALTA
        System.out.println("O cliente pretende gerir artistas, álbuns e músicas");

        //1. Primeiro tenho que ver se o utilizador que quer editar a info é editor
        ArrayList<User> users = data.get_UserList();

        if (data.username_match(username)) { //SUCESSO
            for (User u : users) {
                if (u.getUsername().equals(username)) {
                    if (u.getUser_type().equals("editor")) {
                        System.out.println("Tem permissao para editar");

                        switch (choice) {
                            case "artist": /*-------------------------ARTIST--------------------------*/
                                String artist_name = name;
                                switch (op_type){
                                    case "insert":

                                        break;
                                    case "change":

                                        break;
                                    case "remove":

                                        break;
                                }

                                break;

                            case "album": /*-------------------------ALBUM--------------------------*/
                                String album_title = name;
                                switch (op_type){
                                    case "insert":

                                        break;
                                    case "change":

                                        break;
                                    case "remove":

                                        break;
                                }
                                break;

                            case "music": /*-------------------------MUSIC--------------------------*/
                                String music_name = name;
                                switch (op_type){
                                    case "insert":

                                        break;
                                    case "change":

                                        break;
                                    case "remove":

                                        break;
                                }
                                break;

                        }
                        //3. De seguida, abro esse álbum para escrita e vou editar a info que lá está


                        //4. Por fim envio a resposta ao utilizador

                    }
                }
            }
        }
    }

    void search_info (String choice){ //EM FALTA
        System.out.println("O cliente pretende consultar detalhes sobre álbum e sobre artista");

        //1. Ver se a choice é album ou artista //E TALVEZ TAMBÉM MÚSICA
        switch (choice){
            case "album": //Ir ao ficheiro de albuns e mostrar toda a informacao sobre o album e mandar ao cliente

                break;

            case "artist": //Ir ao ficheiro de artistas e mostrar toda a informacao sobre o artista e mandar ao cliente

                break;

            case "music":

                break;
        }
    }

    void album_review (String user, String album_title, String rating, String text, MulticastSocket socket, int server_id){ //TESTAR
        System.out.println("O cliente " + user + " pretende escrever uma crítica a um álbum");
        //FALTA VERIFICAR SE A REVIEW TEM MENOS DE 300 CARACTERES-----------------------------------------

        //1. TENHO QUE ABRIR O FICHEIRO E PÔR LÁ A INFORMACAO
        ArrayList <Album> album_list = data.get_AlbumList();
        Review r = new Review(text, Integer.parseInt(rating), user);

        for (Album a: album_list){
            if (a.getAlbum_name().equals(album_title)){
                a.review_list.add(r); //Adicionar a review à lista de reviews
                data.write_albumlist_file("AlbumList_obj.txt", album_list);

                //1. NÃO SEI SE NAO PRECISO DE ADICIONAR ALGO AO MÉTODO DO RATING PARA CALCULAR O RATING MÉDIO
                String rsp = "server_id|" + server_id + "; type|status" + "; review|successful; " + "msg|Your review was submitted";
                try {
                    byte[] buffer = rsp.getBytes();
                    DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(MULTICAST_ADDRESS), PORT);
                    socket.send(packet);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            else { //ÁLBUM NÃO CONSTA DA BASE DE DADOS
                String rsp = "server_id|" + server_id + "; type|status" + "; review|unsuccessful; " + "msg|The selected album is not in our database";
                try {
                    byte[] buffer = rsp.getBytes();
                    DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(MULTICAST_ADDRESS), PORT); //mudei aqui
                    socket.send(packet);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }

    void download (){ //EM FALTA
        System.out.println("O cliente quer fazer download de uma música");
    }

    void upload (){ //EM FALTA
        System.out.println("O cliente quer fazer upload de uma música");
    }

    void share_music (){ //EM FALTA
        System.out.println("O cliente pretende partilhar música com outros utilizadores");
    }

}


class AnswerRequests extends Thread {

    //private String MULTICAST_ADDRESS = "224.3.2.1";
    //private int PORT = 4444; //Porto de envio
    private String message;
    private String ip;
    private int porto;
    private MulticastSocket socket;
    private int server_id;

    MessageParsing parsing = new MessageParsing();

    public AnswerRequests(String message, String ip, int porto, MulticastSocket socket, int server_id) {
        this.message = message;
        this.ip = ip;
        this.porto = porto;
        this.socket = socket;
        this.server_id = server_id;
    }

    public void run(){

        UDPMulticastProtocol prot = new UDPMulticastProtocol(); //Ver se é aqui que devo chamar o construtor ou não
        System.out.println("Mensagem do cliente (IP: " + ip + ";Porto: " + porto + ")" + ": " + message);

        //Enviar resposta para o cliente
        //MulticastSocket socket = null;

        //Parsing da mensagem
        String [] pares = parsing.MessageParsing(message);
        String type = pares[1];

        // De acordo com o tipo de argumento no campo "type" vamos definir a operacao pretendida e vai ser invocado o respetivo método
        //Trata do pedido para depois enviar a resposta para o cliente
        switch (type) {
            case "login":
                prot.login(pares[2], pares[3], socket, server_id);
                break;

            case "search music":
                prot.search_music(pares[2], pares[3], socket, server_id);
                break;

            case "make editor": //RESOLVER O PROBLEMA: COMO É QUE HEI DE SABER QUEM É QUE ESTÁ A QUERER TORNAR ALGUÉM EDITOR, PARA SABER SE TAMBÉM É EDITOR
                String username = pares[2];
                String new_editor = pares[3];
                prot.make_editor(username, new_editor, socket, server_id); //EDITOR
                break;

            case "register":
                try {
                    prot.register(pares[2], pares[3], socket, server_id);
                } catch (IOException e) {
                    e.printStackTrace();
                }
                break;

            case "edit info":
                String user = pares[2];
                String search = pares[3];
                String op_type = pares[4];
                String msg = pares[5];
                prot.manage_data(user, search,op_type, msg); //EDITOR
                break;

            case "search info":
                prot.search_info(pares[2]);
                break;

            case "review":
                String userr = pares[2];
                String album_name = pares[3];
                String rating = pares[4];
                String review_text = pares[5];
                prot.album_review(userr, album_name, rating, review_text, socket, server_id); //ANY USER
                break;

            case "share music": //DEPOIS
                prot.share_music();
                break;

            case "download": //DEPOIS
                prot.download();
                break;

            case "upload":  //DEPOIS
                prot.upload();
                break;
        }

    }

}

public class MulticastServer extends Thread {

    private String MULTICAST_ADDRESS = "224.3.2.1";
    private int PORT = 4321; //Porto de recepção
    private int BUFFER_SIZE = 4096;
    private static int SERVER_ID;

    MessageParsing parsemsg = new MessageParsing();

    public static void main(String[] args) {
        SERVER_ID = Integer.parseInt(args[0]); //ID DO SERVIDOR
        MulticastServer server = new MulticastServer();
        server.start(); //Ao invocar o start da thread, estamos a chamar o metodo run()
    }

    public MulticastServer() {
        //super ("Server Multicast #" + (long) (Math.random() * 100));
        super ("Server Multicast #" + SERVER_ID);
    }

    public void run(){
        MulticastSocket socket = null;
        System.out.println(this.getName() + " running..."); //Vai buscar o que está dentro do método do construtor

        try {
            socket = new MulticastSocket(PORT); //cria socket e dá bind
            InetAddress group = InetAddress.getByName(MULTICAST_ADDRESS);
            socket.joinGroup(group); //dá join ao grupo multicast


            while (true) {
                //Recepcao
                byte[] inBuffer = new byte[BUFFER_SIZE];
                DatagramPacket msgIn = new DatagramPacket(inBuffer, inBuffer.length);
                socket.receive(msgIn); //Recebe o datagrama UDP

                String clientIP = msgIn.getAddress().getHostAddress(); //Endereço IP do cliente que enviou a mensagem
                int clientport = msgIn.getPort(); //Porto do cliente

                String message = new String(msgIn.getData(), 0, msgIn.getLength());
                String [] fields = parsemsg.MessageParsing(message);

                if (Integer.parseInt(fields[0]) == SERVER_ID){
                    System.out.println("SO VOU RESPONDER EU -> SERVER " + SERVER_ID);

                    //Vai buscar a informação da mensagem e lança a thread para tratar do pedido
                    AnswerRequests work = new AnswerRequests(message, clientIP , clientport, socket, SERVER_ID); //Também vou passar a socket por parâmetro
                    work.start();
                }
                else{
                    //Se for um registo, mudança de informação de álbuns ou cenas que têm que ser replicadas
                    //Ou seja, tem que ir para as 3 bases de dados e vai ser este "else" que vai tratar disso
                    System.out.println("VOU ESTAR QUIETO -> SERVER " + SERVER_ID);

                }

            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            socket.close(); //Fechar a socket
        }
    }

}

/*
try{
            socket = new MulticastSocket(); //Não é necessário dar bind porque está apenas a enviar
            socket.setTimeToLive(1);

            Scanner keyboardScaner = new Scanner(System.in);
            while (true){
                String keyboard = keyboardScaner.nextLine();
                byte[] buffer = keyboard.getBytes();

                InetAddress group = InetAddress.getByName(MULTICAST_ADDRESS);
                DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(MULTICAST_ADDRESS), PORT); //mudei aqui
                socket.send(packet);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            socket.close();
        }
 */