package rmiserver;

import java.io.*;
import java.net.MulticastSocket;
import java.net.DatagramPacket;
import java.net.InetAddress;
import java.util.concurrent.CopyOnWriteArrayList;
import java.io.Serializable;

/*
class ShareMusic implements Serializable{
    String shareUsername;
    String shareSong;

    public ShareMusic(String shareUsername, String shareSong) {
        this.shareUsername = shareUsername;
        this.shareSong = shareSong;
    }
}
*/

class EditorAbum implements Serializable{
    String editorName;
    String albumCommented;

    public EditorAbum(String editorName, String albumCommented) {
        this.editorName = editorName;
        this.albumCommented = albumCommented;
    }
}

class OfflineUser implements Serializable{
    String offlineUsername;
    String offlineNotification;


    public OfflineUser(String offlineUsername, String offlineNotification) {
        this.offlineUsername = offlineUsername;
        this.offlineNotification = offlineNotification;
    }
}

class User implements Serializable  {
    String username;
    String password;
    String editorStatus;
    String onlineStatus;


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

class Album implements Serializable{
    String albumName;
    String albumArtist;
    String albumGender;
    String albumDate;
    String albumDescription;


    public Album(String albumName, String albumArtist, String albumGender, String albumDate, String albumDescription) {
        this.albumName = albumName;
        this.albumArtist = albumArtist;
        this.albumGender = albumGender;
        this.albumDate = albumDate;
        this.albumDescription = albumDescription;
    }
}

class Artist implements Serializable{
    String artistName;
    String artistGender;
    String artistBirthdate;
    String artistMusicGender;
    String artistDescription;


    public Artist(String artistName, String artistGender, String artistBirthdate, String artistMusicGender, String artistDescription) {
        this.artistName = artistName;
        this.artistGender = artistGender;
        this.artistBirthdate = artistBirthdate;
        this.artistMusicGender = artistMusicGender;
        this.artistDescription = artistDescription;
    }
}

class Song implements Serializable{
    String songName;
    String songArtist;
    String songGender;
    String songAlbum;
    String songDuration;

    public Song(String songName, String songArtist, String songGender, String songAlbum, String songDuration) {
        this.songName = songName;
        this.songArtist = songArtist;
        this.songGender = songGender;
        this.songAlbum = songAlbum;
        this.songDuration = songDuration;
    }
}

class Comments implements Serializable{
    String username;
    String albumName;
    double score;
    String comment;

    public Comments(String username, String albumName, double score, String comment) {
        this.username = username;
        this.albumName = albumName;
        this.score = score;
        this.comment = comment;
    }
}

public class MulticastServer extends Thread {
    private String MULTICAST_ADDRESS = "224.0.224.0";
    private int PORT = 4321;
    private long SLEEP_TIME = 5000;

    public static void main(String[] args) {
        MulticastServer server = new MulticastServer();
        server.start();
    }

    public MulticastServer() {
        super("Server " + (long) (Math.random() * 1000));
    }

    public void run() {
        MulticastSocket socket = null;
        long counter = 0;
        System.out.println(this.getName() + " running...");
        String answer;
        String answer2;
        String [] message1;
        byte[] answerBytes;
        try{
            socket = new MulticastSocket(PORT);  // create socket without binding it (only for sending)
            InetAddress group = InetAddress.getByName(MULTICAST_ADDRESS);
            socket.joinGroup(group);
            Connecting con = new Connecting();

            while (true) {

                byte[] buffer = new byte[256];
                DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
                socket.receive(packet);
                String message = new String(packet.getData(), 0, packet.getLength());
                System.out.println(message);
                message1 = message.split("\\|");
                if (message1[0].equals("request")) {

                    if (message1[2].equals("register")) {
                        if (con.createUser(message1[4], message1[6], "no") == true) {
                            answer = message1[4] + "|answer|true";
                            System.out.println(answer);
                            answerBytes = answer.getBytes();
                            DatagramPacket answerPacket = new DatagramPacket(answerBytes, answerBytes.length, group, PORT);
                            System.out.println("Vai enviar");
                            socket.send(answerPacket);
                        } else {
                            answer = message1[4] + "|answer|false";
                            answerBytes = answer.getBytes();
                            DatagramPacket answerPacket = new DatagramPacket(answerBytes, answerBytes.length, group, PORT);
                            socket.send(answerPacket);
                        }


                    } else if (message1[2].equals("login")) {
                        if (con.login(message1[4], message1[6])) {
                            answer = message1[4] + "|answer|true";
                            answerBytes = answer.getBytes();
                            DatagramPacket answerPacket = new DatagramPacket(answerBytes, answerBytes.length, group, PORT);
                            socket.send(answerPacket);
                        } else {
                            answer = message1[4] + "|answer|false";
                            answerBytes = answer.getBytes();
                            DatagramPacket answerPacket = new DatagramPacket(answerBytes, answerBytes.length, group, PORT);
                            socket.send(answerPacket);
                        }
                    } else if (message1[4].equals("comment")) {
                        if (con.commentAlbum(message1[2],message1[6],message1[10],Float.parseFloat(message1[8])) == true) {
                            //double score = Float.parseFloat(message1[8]);
                            //addAlbumComment(message1[2], message1[6], score, message1[10]);
                            answer = message1[2] + "|answer|true";
                            answerBytes = answer.getBytes();
                            DatagramPacket answerPacket = new DatagramPacket(answerBytes, answerBytes.length, group, PORT);
                            socket.send(answerPacket);
                        } else {
                            answer = message1[2] + "|answer|false";
                            answerBytes = answer.getBytes();
                            DatagramPacket answerPacket = new DatagramPacket(answerBytes, answerBytes.length, group, PORT);
                            socket.send(answerPacket);
                        }
                    } else if (message1[2].equals("check_editor_status")) {
                        if (con.checkIfEditor(message1[4]) == true) {
                            answer = message1[4] + "|answer|true";
                            answerBytes = answer.getBytes();
                            DatagramPacket answerPacket = new DatagramPacket(answerBytes, answerBytes.length, group, PORT);
                            socket.send(answerPacket);
                        } else {
                            answer = message1[4] + "|answer|false";
                            answerBytes = answer.getBytes();
                            DatagramPacket answerPacket = new DatagramPacket(answerBytes, answerBytes.length, group, PORT);
                            socket.send(answerPacket);
                        }
                    } else if (message1[2].equals("check_username")) {
                        if (con.checkUsername(message1[4]) == true) {
                            answer = message1[4] + "|answer|true";
                            answerBytes = answer.getBytes();
                            DatagramPacket answerPacket = new DatagramPacket(answerBytes, answerBytes.length, group, PORT);
                            socket.send(answerPacket);

                        } else {
                            answer = message1[4] + "|answer|false";
                            answerBytes = answer.getBytes();
                            DatagramPacket answerPacket = new DatagramPacket(answerBytes, answerBytes.length, group, PORT);
                            socket.send(answerPacket);
                        }

                    } else if (message1[4].equals("check_notifications")) {
                        System.out.println("vai checkar notificacao");
                        answer = userHasNotifications(message1[2]);
                        System.out.println(answer);
                        answerBytes = answer.getBytes();
                        DatagramPacket answerPacket = new DatagramPacket(answerBytes, answerBytes.length, group, PORT);
                        socket.send(answerPacket);
                    }


                /*
                else if(message1[4].equals("delete")){
                    if(message1[6].equals("album")){
                        deleteAlbum(message1[8]);
                        answer = message1[2] +"|answer|true";
                        answerBytes= answer.getBytes();
                        DatagramPacket answerPacket = new DatagramPacket(answerBytes, answerBytes.length, group, PORT);
                        socket.send(answerPacket);
                    }
                    else if(message1[6].equals("music")){
                        deleteSong(message1[8]);
                        answer = message1[2] +"|answer|true";
                        answerBytes= answer.getBytes();
                        DatagramPacket answerPacket = new DatagramPacket(answerBytes, answerBytes.length, group, PORT);
                        socket.send(answerPacket);
                    }
                    else if(message1[6].equals("artist")){
                        deleteArtist(message1[8]);
                        answer = message1[2] +"|answer|true";
                        answerBytes= answer.getBytes();
                        DatagramPacket answerPacket = new DatagramPacket(answerBytes, answerBytes.length, group, PORT);
                        socket.send(answerPacket);
                    }
                }
                */

                    else if (message1[4].equals("search")) {
                        if (message1[5].equals("ArtistName")) {
                            answer = artistData(message1[2], message1[6]) + albumsFromArtist(message1[2], message1[6]);
                            answerBytes = answer.getBytes();
                            DatagramPacket answerPacket = new DatagramPacket(answerBytes, answerBytes.length, group, PORT);
                            socket.send(answerPacket);

                        } else if (message1[5].equals("AlbumName")) {
                            answer = albumData(message1[2], message1[6]) + commentsOfAlbum(message1[2], message1[6]) + getAlbumAverage(message1[2], message1[6]);
                            answerBytes = answer.getBytes();
                            DatagramPacket answerPacket = new DatagramPacket(answerBytes, answerBytes.length, group, PORT);
                            socket.send(answerPacket);
                        }
                    } else if (message1[4].equals("update") && checkEditorStatus(message1[2]) == true) {
                        if (message1[6].equals("album")) {
                            if (message1[9].equals("name")) {
                                changeAlbumName(message1[7], message1[11]);
                                answer = message1[2] + "|answer|true";
                                answerBytes = answer.getBytes();
                                DatagramPacket answerPacket = new DatagramPacket(answerBytes, answerBytes.length, group, PORT);
                                socket.send(answerPacket);
                            } else if (message1[9].equals("nomeArtista")) {
                                changeAlbumArtist(message1[7], message1[11]);
                                answer = message1[2] + "|answer|true";
                                answerBytes = answer.getBytes();
                                DatagramPacket answerPacket = new DatagramPacket(answerBytes, answerBytes.length, group, PORT);
                                socket.send(answerPacket);
                            } else if (message1[9].equals("genero")) {
                                changeAlbumGender(message1[7], message1[11]);
                                answer = message1[2] + "|answer|true";
                                answerBytes = answer.getBytes();
                                DatagramPacket answerPacket = new DatagramPacket(answerBytes, answerBytes.length, group, PORT);
                                socket.send(answerPacket);
                            } else if (message1[9].equals("data")) {
                                changeAlbumDate(message1[7], message1[12]);
                                answer = message1[2] + "|answer|true";
                                answerBytes = answer.getBytes();
                                DatagramPacket answerPacket = new DatagramPacket(answerBytes, answerBytes.length, group, PORT);
                                socket.send(answerPacket);
                            } else if (message1[9].equals("description")) {
                                changeAlbumDescription(message1[7], message1[11]);
                                answer2 = notifyAllEditors(message1[2], message1[10]);
                                answer = message1[2] + "|answer|true" + answer2;
                                answerBytes = answer.getBytes();
                                DatagramPacket answerPacket = new DatagramPacket(answerBytes, answerBytes.length, group, PORT);
                                socket.send(answerPacket);
                            }
                        }
                    } else if (message1[4].equals("all_data")) {
                        if (message1[5].equals("Album")) {
                            answer = message1[2] + "|answer|" + albumData(message1[2], message1[5]);
                            answerBytes = answer.getBytes();
                            DatagramPacket answerPacket = new DatagramPacket(answerBytes, answerBytes.length, group, PORT);
                            socket.send(answerPacket);
                        } else if (message1[5].equals("Artist")) {
                            answer = message1[2] + "|answer|" + artistData(message1[2], message1[5]);
                            answerBytes = answer.getBytes();
                            DatagramPacket answerPacket = new DatagramPacket(answerBytes, answerBytes.length, group, PORT);
                            socket.send(answerPacket);
                        }
                    } else if (message1[4].equals("make_editor")) {
                        if (con.makeEditor(message1[2],message1[4]) == true) {
                            //if(checkUsername(message1[2])==true){
                            //makeEditor(message1[5]);
                            System.out.println("vai adicionar notificacao");
                            addNotification(message1[5]);
                            answer = message1[2] + "|answer|true";
                            answerBytes = answer.getBytes();
                            DatagramPacket answerPacket = new DatagramPacket(answerBytes, answerBytes.length, group, PORT);
                            System.out.println("vai enviar");
                            socket.send(answerPacket);

                        } else {
                            answer = message1[2] + "|answer|false";
                            answerBytes = answer.getBytes();
                            DatagramPacket answerPacket = new DatagramPacket(answerBytes, answerBytes.length, group, PORT);
                            socket.send(answerPacket);
                        }
                    } else if (message1[4].equals("delete")) {

                /*
                } else if (message1[4].equals("musicstobeshared")) {
                    answer = songsUploaded(message1[2]);
                    answerBytes = answer.getBytes();
                    DatagramPacket answerPacket = new DatagramPacket(answerBytes, answerBytes.length, group, PORT);
                    socket.send(answerPacket);
                    */
                    } else if (message1[4].equals("share_music")) {

                    } else if (message1[5].equals("add")) {
                        if (con.checkIfEditor(message1[2]) == true) {
                            if (message1[6].equals("artist")) {
                                if (con.addArtist(message1[2], message1[8], message1[10], message1[12], message1[14],message1[16]," ") == true) {
                                    answer = message1[2] + "|answer|true";
                                    answerBytes = answer.getBytes();
                                    DatagramPacket answerPacket = new DatagramPacket(answerBytes, answerBytes.length, group, PORT);
                                    socket.send(answerPacket);
                                } else {
                                    answer = message1[4] + "|answer|false";
                                    answerBytes = answer.getBytes();
                                    DatagramPacket answerPacket = new DatagramPacket(answerBytes, answerBytes.length, group, PORT);
                                    socket.send(answerPacket);
                                }
                            } else if (message1[6].equals("music")) {
                                    if (con.addSong(message1[2], message1[8], message1[10], message1[12], message1[14],message1[16]," "," "," ",message1[18]) == true) {
                                        answer = message1[2] + "|answer|true";
                                        answerBytes = answer.getBytes();
                                        DatagramPacket answerPacket = new DatagramPacket(answerBytes, answerBytes.length, group, PORT);
                                        socket.send(answerPacket);
                                    } else {
                                        answer = message1[2] + "|answer|false";
                                        answerBytes = answer.getBytes();
                                        DatagramPacket answerPacket = new DatagramPacket(answerBytes, answerBytes.length, group, PORT);
                                        socket.send(answerPacket);
                                    }

                            } else if (message1[6].equals("album")) {
                                //if(checkArtistExists(message1[10]) == true){
                                if (con.addAlbum(message1[2], message1[8], message1[10], message1[12], message1[14],message1[16]," ", 0.0) == true) {
                                    answer = message1[2] + "|answer|true";
                                    answerBytes = answer.getBytes();
                                    DatagramPacket answerPacket = new DatagramPacket(answerBytes, answerBytes.length, group, PORT);
                                    socket.send(answerPacket);
                                } else {
                                    answer = message1[2] + "|answer|false";
                                    answerBytes = answer.getBytes();
                                    DatagramPacket answerPacket = new DatagramPacket(answerBytes, answerBytes.length, group, PORT);
                                    socket.send(answerPacket);
                                }
                                //}
                            /*
                            else{
                                answer = message1[2] +"|answer|false";
                                answerBytes= answer.getBytes();
                                DatagramPacket answerPacket = new DatagramPacket(answerBytes, answerBytes.length, group, PORT);
                                socket.send(answerPacket);
                            }
                            */
                            }
                        } else {
                            answer = message1[4] + "|answer|noteditor";
                            answerBytes = answer.getBytes();
                            DatagramPacket answerPacket = new DatagramPacket(answerBytes, answerBytes.length, group, PORT);
                            socket.send(answerPacket);
                        }
                    }

                }

                try {
                    sleep((long) (Math.random() * SLEEP_TIME));
                } catch (InterruptedException e) {
                }
            }


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

        } finally {
            socket.close();
        }
    }
    public  Object readFile(String path){
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(path))) {
            return ois.readObject();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }

    public int writeFile(Object obj, String path) {
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream(path));
        } catch (IOException e) {
            e.printStackTrace();
            return 1;
        }
        try {
            oos.writeObject(obj);
            return 0;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return 1;
    }

    @SuppressWarnings("unchecked")
    public boolean checkUsername(String username){
        int i;
        File f = new File("users");
        CopyOnWriteArrayList<User> users;
        if (f.exists() && !f.isDirectory()) {
            Object obj = readFile("users");
            users = (CopyOnWriteArrayList<User>) obj;
            for (i = 0; i < users.size(); i++) {
                if (username.equals(users.get(i).username)) {
                    return false;
                }
            }
            return true;
        }
        else{
            return true;
        }
    }
    @SuppressWarnings("unchecked")
    public boolean checkPassword(String username,String password){
        int i;
        File f = new File("users");
        CopyOnWriteArrayList<User> users;
        if (f.exists() && !f.isDirectory()) {
            Object obj = readFile("users");
            users = (CopyOnWriteArrayList<User>) obj;
            for (i = 0; i < users.size(); i++) {
                if (username.equals(users.get(i).username) && password.equals(users.get(i).password)) {
                    return true;
                }
            }
            return false;
        }
        else{
            return false;
        }
    }
    @SuppressWarnings("unchecked")
    private int addUser(String username, String password, String editorStatus) throws IOException{
        int i;
        File f = new File("users");
        CopyOnWriteArrayList<User> users = new CopyOnWriteArrayList<>();
        if (f.exists() && !f.isDirectory()) {
            Object obj = readFile("users");
            users = (CopyOnWriteArrayList<User>) obj;

            User newUser = new User(username, password, "no", "on");
            users.add(newUser);
            return writeFile(users, "users");
        }
        else{
            User user = new User(username, password, "yes", "on");
            users.add(user);
            f.createNewFile();
            return writeFile(users, "users");

        }
    }
    @SuppressWarnings("unchecked")
    public int addArtist(String artistName, String artistGender, String artistBirthdate, String artistMusicGender, String artistDescription) throws IOException{
        File f = new File("artists");
        CopyOnWriteArrayList<Artist> artists = new CopyOnWriteArrayList<Artist>();
        if (f.exists() && !f.isDirectory()) {
            Object obj = readFile("artists");
            artists = (CopyOnWriteArrayList<Artist>) obj;

            Artist newArtist = new Artist(artistName, artistGender,artistBirthdate, artistMusicGender, artistDescription);
            artists.add(newArtist);
            return writeFile(artists, "artists");
        }
        else{
            Artist artist = new Artist(artistName, artistGender,artistBirthdate, artistMusicGender, artistDescription);
            artists.add(artist);
            f.createNewFile();
            return writeFile(artists, "artists");

        }
    }

    /*
        public String songsUploaded(String username){
            int i;
            File f = new File("users_songs");
            CopyOnWriteArrayList<ShareMusic> users;
            CopyOnWriteArrayList<String> answer= new CopyOnWriteArrayList<String>();


            if (f.exists() && !f.isDirectory()) {
                Object obj = readFile("users_songs");
                users = (CopyOnWriteArrayList<ShareMusic>) obj;
                for (i = 0; i < users.size(); i++) {
                    if (username.equals(users.get(i).shareUsername) ) {
                        answer.add(users.get(i).shareSong);
                    }
                }
            }
            return username+ "|answer|number" + answer.size() + "|albums|" + answer ;

        }
     */
    /*
    public void deleteAlbum(String albumName){

    }
    public void deleteSong(String songName){

    }
    public void deleteArtist(String artistName){

    }
    */
    //old= nome do album
    public void changeAlbumName( String old,String newItem){
        int i;
        File f = new File("albums");

        if (f.exists() && !f.isDirectory()) {
            Object obj = readFile("albums");
            CopyOnWriteArrayList<Album> albums = (CopyOnWriteArrayList<Album>) obj;
            for (i = 0; i < albums.size(); i++) {
                if (old.equals(albums.get(i).albumName)){
                    albums.get(i).albumName = newItem;
                    writeFile(albums, "albums");
                }
            }
        }
    }
    @SuppressWarnings("unchecked")

    public void changeAlbumArtist( String old,String newItem){
        int i;
        File f = new File("albums");

        if (f.exists() && !f.isDirectory()) {
            Object obj = readFile("albums");
            CopyOnWriteArrayList<Album> albums = (CopyOnWriteArrayList<Album>) obj;
            for (i = 0; i < albums.size(); i++) {
                if (old.equals(albums.get(i).albumName)){
                    albums.get(i).albumArtist = newItem;
                    writeFile(albums, "albums");
                }
            }
        }
    }
    @SuppressWarnings("unchecked")

    public void changeAlbumGender( String old,String newItem){
        int i;
        File f = new File("albums");

        if (f.exists() && !f.isDirectory()) {
            Object obj = readFile("albums");
            CopyOnWriteArrayList<Album> albums = (CopyOnWriteArrayList<Album>) obj;
            for (i = 0; i < albums.size(); i++) {
                if (old.equals(albums.get(i).albumName)){
                    albums.get(i).albumGender = newItem;
                    writeFile(albums, "albums");
                }
            }
        }
    }
    @SuppressWarnings("unchecked")

    public void changeAlbumDate( String old,String newItem){
        int i;
        File f = new File("albums");

        if (f.exists() && !f.isDirectory()) {
            Object obj = readFile("albums");
            CopyOnWriteArrayList<Album> albums = (CopyOnWriteArrayList<Album>) obj;
            for (i = 0; i < albums.size(); i++) {
                if (old.equals(albums.get(i).albumName)){
                    albums.get(i).albumDate = newItem;
                    writeFile(albums, "albums");
                }
            }
        }
    }
    @SuppressWarnings("unchecked")

    public void changeAlbumDescription( String old,String newItem){
        int i;
        File f = new File("albums");

        if (f.exists() && !f.isDirectory()) {
            Object obj = readFile("albums");
            CopyOnWriteArrayList<Album> albums = (CopyOnWriteArrayList<Album>) obj;
            for (i = 0; i < albums.size(); i++) {
                if (old.equals(albums.get(i).albumName)){
                    albums.get(i).albumDescription = newItem;
                    writeFile(albums, "albums");
                }
            }
        }
    }



    @SuppressWarnings("unchecked")
    public int addSong(String songName, String songArtist, String songGender, String songAlbum, String songDuration,int order) throws IOException{
        File f = new File("songs");
        CopyOnWriteArrayList<Song> songs = new CopyOnWriteArrayList<Song>();
        if (f.exists() && !f.isDirectory()) {
            Object obj = readFile("songs");
            songs = (CopyOnWriteArrayList<Song>) obj;

            Song newSong = new Song(songName, songArtist, songGender, songAlbum,songDuration);
            songs.add(newSong);
            return writeFile(songs, "songs");
        }
        else{
            Song song = new Song(songName, songArtist, songGender, songAlbum,songDuration);
            songs.add(song);
            f.createNewFile();
            return writeFile(songs, "songs");

        }
    }
    @SuppressWarnings("unchecked")
    public int addAlbum(String albumName, String albumArtist, String albumGender, String albumDate, String albumDescription) throws IOException{
        File f = new File("albums");
        CopyOnWriteArrayList<Album> albums = new CopyOnWriteArrayList<Album>();
        if (f.exists() && !f.isDirectory()) {
            Object obj = readFile("albums");
            albums = (CopyOnWriteArrayList<Album>) obj;

            Album newAlbum = new Album(albumName, albumArtist,albumGender, albumDate, albumDescription);
            albums.add(newAlbum);
            return writeFile(albums, "albums");
        }
        else{
            Album album = new Album(albumName, albumArtist,albumGender, albumDate, albumDescription);
            albums.add(album);
            f.createNewFile();
            return writeFile(albums, "albums");

        }
    }
    @SuppressWarnings("unchecked")
    public void makeEditor(String username){
        int i;
        File f = new File("users");
        CopyOnWriteArrayList<User> users;
        if (f.exists() && !f.isDirectory()) {
            Object obj = readFile("users");
            users = (CopyOnWriteArrayList<User>) obj;
            for (i = 0; i < users.size(); i++) {
                if (username.equals(users.get(i).username)) {
                    users.get(i).editorStatus="yes";
                    writeFile(users, "users");

                }

            }
            return;
        }

    }
    @SuppressWarnings("unchecked")
    public boolean checkEditorStatus(String username){
        int i;
        File f = new File("users");
        CopyOnWriteArrayList<User> users;
        String editorTrue ="yes";
        if (f.exists() && !f.isDirectory()) {
            Object obj = readFile("users");
            users = (CopyOnWriteArrayList<User>) obj;
            for (i = 0; i < users.size(); i++) {
                if(username.equals(users.get(i).username)) {
                    if (editorTrue.equals(users.get(i).editorStatus)) {
                        return true;
                    }
                    else{
                        return false;
                    }
                }
            }
            return false;
        }
        else{
            return false;
        }
    }
    @SuppressWarnings("unchecked")
    public boolean checkAlbumExists(String albumName){
        int i;
        File f = new File("albums");
        CopyOnWriteArrayList<Album> users;
        if (f.exists() && !f.isDirectory()) {
            Object obj = readFile("albums");
            users = (CopyOnWriteArrayList<Album>) obj;
            for (i = 0; i < users.size(); i++) {
                if (albumName.equals(users.get(i).albumName)) {
                    return true;
                }
            }
            return false;
        }
        else{
            return false;
        }
    }
    @SuppressWarnings("unchecked")
    public boolean checkArtistExists(String artistName){
        int i;
        File f = new File("artists");
        CopyOnWriteArrayList<Artist> artists;
        if (f.exists() && !f.isDirectory()) {
            Object obj = readFile("artists");
            artists = (CopyOnWriteArrayList<Artist>) obj;
            for (i = 0; i < artists.size(); i++) {
                if (artistName.equals(artists.get(i).artistName)) {
                    return true;
                }
            }
            return false;
        }
        else{
            return false;
        }
    }
    @SuppressWarnings("unchecked")
    public String albumsFromArtist(String username, String artistName){
        int i;
        File f = new File("albums");
        CopyOnWriteArrayList<Album> albums;
        CopyOnWriteArrayList<String> answer = new CopyOnWriteArrayList<String>();

        if (f.exists() && !f.isDirectory()) {
            Object obj = readFile("albums");
            albums = (CopyOnWriteArrayList<Album>) obj;
            for (i = 0; i < albums.size(); i++) {
                if (artistName.equals(albums.get(i).albumArtist)) {
                    answer.add(albums.get(i).albumName);
                }
            }
        }
        System.out.println(artistData(username,artistName));
        return "|" + username+ "|answer|number|" + answer.size() + "|albums|" + answer +"|";

    }
    @SuppressWarnings("unchecked")
    public void addAlbumComment(String username, String albumName, double score, String comment) throws IOException{
        int i;
        File f = new File("albums_comments");
        CopyOnWriteArrayList<Comments> comments = new CopyOnWriteArrayList<Comments>();
        if (f.exists() && !f.isDirectory()) {
            Object obj = readFile("albums_comments");
            comments = (CopyOnWriteArrayList<Comments>) obj;
            Comments newComment = new Comments(username, albumName, score, comment);;
            comments.add(newComment);
            writeFile(comments, "albums_comments");
        }
        else{
            Comments firstComment = new Comments(username, albumName, score, comment);
            comments.add(firstComment);
            f.createNewFile();
            writeFile(comments, "albums_comments");

        }

    }

    public  String commentsOfAlbum(String username, String albumName){
        int i;
        File f = new File("albums_comments");
        CopyOnWriteArrayList<Comments> comments = new CopyOnWriteArrayList<Comments>();

        CopyOnWriteArrayList<String> answer = new CopyOnWriteArrayList<String>();


        if (f.exists() && !f.isDirectory()) {
            Object obj = readFile("albums_comments");

            comments = (CopyOnWriteArrayList<Comments>) obj;

            for (i = 0; i < comments.size(); i++) {
                if (albumName.equals(comments.get(i).albumName)) {
                    answer.add(comments.get(i).comment);
                }
            }
        }

        return "|" + username+ "|answer|number|" + answer.size() + "|comments|" + answer +"|";
    }

    public String getAlbumAverage(String username, String albumName){
        int i;
        File f = new File("albums_comments");
        CopyOnWriteArrayList<Comments> comments = new CopyOnWriteArrayList<Comments>();
        double answer=0;
        double count=0.0;
        double average=0.0;
        if (f.exists() && !f.isDirectory()) {
            Object obj = readFile("albums_comments");

            comments = (CopyOnWriteArrayList<Comments>) obj;

            for (i = 0; i < comments.size(); i++) {
                if (albumName.equals(comments.get(i).albumName)) {
                    answer+=comments.get(i).score;
                    count+=1;
                }
            }
        }
        average=answer/count;
        return "|" + username+ "|answer|" +String.valueOf(average);
    }

    @SuppressWarnings("unchecked")
    public String albumData(String username, String albumName) {
        int i;
        String answer="";
        File f = new File("albums");
        CopyOnWriteArrayList<Album> albums = new CopyOnWriteArrayList<Album>();
        if (f.exists() && !f.isDirectory()) {
            Object obj = readFile("albums");
            albums = (CopyOnWriteArrayList<Album>) obj;
            for (i = 0; i < albums.size(); i++) {
                if (albumName.equals(albums.get(i).albumName)) {
                    answer = username + "|answer|5|albumName|" + albums.get(i).albumName + "|albumArtist|" + albums.get(i).albumArtist + "|albumGender|" + albums.get(i).albumGender + "|albumDate|" + albums.get(i).albumDate + "|albumDescription|" + albums.get(i).albumDescription;
                    return answer;
                }
            }
            answer = "answer|false";
            return answer;
        }
        return answer;
    }
    @SuppressWarnings("unchecked")
    public String artistData(String username, String artistName) {
        int i;
        String answer="";
        File f = new File("artists");
        CopyOnWriteArrayList<Artist> artists = new CopyOnWriteArrayList<Artist>();
        if (f.exists() && !f.isDirectory()) {
            Object obj = readFile("artists");
            artists = (CopyOnWriteArrayList<Artist>) obj;
            for (i = 0; i < artists.size(); i++) {
                if (artistName.equals(artists.get(i).artistName)) {
                    answer = username + "|answer|5|artistName|" + artists.get(i).artistName + "|artistGender|" + artists.get(i).artistGender + "|artistBirthdate|" + artists.get(i).artistBirthdate + "|artistMusicGender|" + artists.get(i).artistMusicGender + "|artistDescription|" + artists.get(i).artistDescription +"";
                    return answer;
                }
            }
            answer = "answer|false";
            return answer;
        }
        return answer;
    }

    @SuppressWarnings("unchecked")
    //Quando existe um novo editor
    public String notifyAllUsers(String username, String editorPromoted) {
        //See users online
        int i;
        File f = new File("users");
        CopyOnWriteArrayList<User> users;
        CopyOnWriteArrayList<String> answer = new CopyOnWriteArrayList<String>();
        String isOn = "on";
        String isOff = "off";

        if (f.exists() && !f.isDirectory()) {
            Object obj = readFile("users");
            users = (CopyOnWriteArrayList<User>) obj;
            for (i = 0; i < users.size(); i++) {
                //se utilizador estiver online vai na resposta
                if (isOn.equals(users.get(i).onlineStatus)) {
                    answer.add(users.get(i).username);
                }
                //se utilizador estiver offline
                else if (isOff.equals(users.get(i).onlineStatus)) {
                    File f2 = new File("offlineusers_notifications");
                    CopyOnWriteArrayList<OfflineUser> usersOffline = new CopyOnWriteArrayList<OfflineUser>();
                    if (f2.exists() && !f2.isDirectory()) {
                        Object obj2 = readFile("offlineusers_notifications");
                        usersOffline = (CopyOnWriteArrayList<OfflineUser>) obj;
                        String notification = editorPromoted + "is now editor";
                        OfflineUser newOfflineUser = new OfflineUser(username, notification);
                        usersOffline.add(newOfflineUser);
                        writeFile(usersOffline, "offlineusers_notifications");
                    }
                }
            }
        }
        return username+ "|answer|number" + answer.size() + "|usersOnline|" + answer ;
    }

    public void addNotification(String editorPromoted) throws IOException {
        File f = new File("offlineusers_notifications");
        System.out.println("Estou antes do if");
        if (f.exists() && !f.isDirectory()) {
            f = new File("offlineusers_notifications");
            System.out.println("Acabei de criar o ficheiro");
            CopyOnWriteArrayList<OfflineUser> usersOffline = new CopyOnWriteArrayList<OfflineUser>();

            Object obj = readFile("offlineusers_notifications");
            usersOffline = (CopyOnWriteArrayList<OfflineUser>) obj;
            String notification = editorPromoted + "is now editor";
            OfflineUser newOfflineUser = new OfflineUser(editorPromoted, notification);
            usersOffline.add(newOfflineUser);
            writeFile(usersOffline, "offlineusers_notifications");
        }
        else{
            String notification = editorPromoted + "is now editor";
            OfflineUser newOfflineUser = new OfflineUser(editorPromoted, notification);
            CopyOnWriteArrayList<OfflineUser> usersOffline =  new CopyOnWriteArrayList<OfflineUser>();
            usersOffline.add(newOfflineUser);
            f.createNewFile();
            writeFile(usersOffline, "offlineusers_notifications");

        }

    }
    @SuppressWarnings("unchecked")
    //Quando alguem altera a descriçao de um album
    public String notifyAllEditors(String username, String albumName) {
        //See users online
        int i;
        File f = new File("users");
        CopyOnWriteArrayList<User> users;
        CopyOnWriteArrayList<String> answer = new CopyOnWriteArrayList<String>();
        String isOn = "on";
        String isOff = "off";
        String editorstatus = "yes";
        if (f.exists() && !f.isDirectory()) {
            Object obj = readFile("users");
            users = (CopyOnWriteArrayList<User>) obj;
            for (i = 0; i < users.size(); i++) {
                //se utilizador estiver online vai na resposta e se for editor
                if (isOn.equals(users.get(i).onlineStatus) && editorstatus.equals(users.get(i).editorStatus)) {
                    answer.add(users.get(i).username);
                }
                //se estiver offline adiciona logo ao ficheiro e se for editor
                else if (isOff.equals(users.get(i).onlineStatus) && editorstatus.equals(users.get(i).editorStatus)) {
                    File f2 = new File("offlineusers_notifications");
                    CopyOnWriteArrayList<OfflineUser> usersOffline = new CopyOnWriteArrayList<OfflineUser>();
                    if (f2.exists() && !f2.isDirectory()) {
                        Object obj2 = readFile("offlineusers_notifications");
                        usersOffline = (CopyOnWriteArrayList<OfflineUser>) obj;
                        String notification = albumName + "had its description edited";
                        OfflineUser newOfflineUser = new OfflineUser(username, notification);
                        usersOffline.add(newOfflineUser);
                        writeFile(usersOffline, "offlineusers_notifications");
                    }
                }
            }

        }
        return "|number" + answer.size() + "|editorsOnline|" + answer;
    }

    @SuppressWarnings("unchecked")
    public String userHasNotifications(String username){
        int i;
        File f = new File("offlineusers_notifications");
        CopyOnWriteArrayList<OfflineUser> users;
        CopyOnWriteArrayList<String> answer = new CopyOnWriteArrayList<String>();

        if (f.exists() && !f.isDirectory()) {
            Object obj = readFile("offlineusers_notifications");
            users = (CopyOnWriteArrayList<OfflineUser>) obj;
            for (i = 0; i < users.size(); i++) {
                if (username.equals(users.get(i).offlineUsername)) {
                    answer.add(users.get(i).offlineNotification);
                }
            }
            return username+ "|answer|number" + answer.size() + "|notifications|" + answer ;
        }
        return username+ "|answer|false" ;

    }

}