package com.usthb.modeles;
 /*
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;*/
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.HashMap;

public class ServeurMiniFacebook {


        //TOUS LES ABONNES
        private static HashMap<String,Abonne> baseAbonnes= new HashMap<String,Abonne>(); //la cl� est le username de l'abonn�

        //TOUS LES GROUPES
        private static HashMap<String,Groupe> baseGroupes= new HashMap<String,Groupe>(); //la cl� est le nom du groupe

        //TOUS LES POSTS
        private static HashMap<Integer,Post> basePosts= new HashMap<Integer,Post>();//la clé est la le codePost

        //methode qui retourne l'abonné à partir d'un username
        public static Abonne getAbonne(String username) {
            return baseAbonnes.get(username);
        }

       //methode qui retourne le groupe à partir d'un groupName
        public static Groupe getGroupe(String groupName) {
            return baseGroupes.get(groupName);
        }

        //methode qui retourne le poste à partir du code post

        public static Post getPost(Integer codePost) {
            return basePosts.get(codePost);
        }


        //SOME TESTS
        public static boolean userExiste(String username) {
            return baseAbonnes.containsKey(username);

        }

        public static boolean groupeExiste(String groupName) {
            return baseGroupes.containsKey(groupName);
        }

        public static boolean postExiste(int codePost) {
            return baseGroupes.containsKey(codePost);
        }





        			/***************REQUETES*****************/



        		/************ABONNES***********/

        public static Abonne inscrireAbonne(Abonne abo){ //MAJ : ENVOYER PARAM ABONNE ET LE CREER ICI
            baseAbonnes.put(abo.getUsername(),abo);
            return abo;
        }



        public static void supprimerAbonne(String user) {//d�sactiver le compte

        // TROUVER SOLUTION
        //   supprimerTousLesAmis(abo);
            baseAbonnes.remove(user);
        }




       public static void monMur(String user) { //afficher le mur
    	   getAbonne(user).afficherMur("privé");
       }




       public static void mesNotifications(String user) {//afficher les notifications
    	   getAbonne(user).afficherNotifications();
       }



       public static void mesInvitations(String user) { //afficher les invitations
       		getAbonne(user).afficherInvitations();
       }

       public static void quitterGroupe(String user,String grp){
           Abonne abo=getAbonne(user);
           if(groupeExiste(grp)) {
        	getGroupe(grp).supprimerMembre(abo);
        	abo.quitterGroupe(grp);
        	}
        }

       public static void rejoindreGroupe(String user,String grp){
        Abonne abo=getAbonne(user);
           if(groupeExiste(grp)) {
        	getGroupe(grp).ajouterMembre(abo);
        	abo.ajouterGroupe(grp);
        	}
        }



       public static void ajouter(String user,String ami,String message) {//ajouter qlqn
          Abonne abo=getAbonne(ami);
           if(abo!=null){
           abo.ajouterInvitation(new Invitation(user,message) );
          }
        }

       public static void refuserInvitation(String user1,String user2){
           getAbonne(user1).refuserInvitation(user2);
       }


       public static void accepterInvitation(String user1,String user2){

          Abonne abo1=getAbonne(user1),
                 abo2=getAbonne(user2);
          abo1.accepterInvitation(user2);
          abo1.ajouterAmi(abo2);
          abo2.ajouterAmi(abo1);
           notifier(abo2,user1," votre invitation.","invitation");


       }
       /*
       public static void supprimerInvitation(String user,Invitation inv){
         Abonne abo=getAbonne(user);
         ArrayList invits;
         invits = inv.getRecepteur().getInvitations();
         invits.remove(inv);

       }
       */


       public static void supprimerAmi(String abo,String ami){//supprimer qlqn de sa liste d'ami
    	   getAbonne(abo).supprimerAmi(ami);
       }


       public static void supprimerTousLesAmis(String user){
           getAbonne(user).supprimerTousLesAmis();
       }



        		/************GROUPES************/

        public static Groupe creerGroupe(String createur,String groupName){
            Groupe grp=new Groupe(createur,groupName);
            baseGroupes.put(groupName, grp);
            return grp;
        }


        public static void supprimerGroupe(String grp) {
            baseGroupes.remove(grp);
        }




        public static void afficherGroupe(String user) {//affiche tous les groupes o� l'abonn� est membre
        	getAbonne(user).afficherGroupes();
        }




        public static void afficherMur(String user,Groupe grp) {

            if(grp.membreExiste(user))
        	grp.afficherMur("groupe");
            else
                grp.afficherMur("publique");
        }


                                                                            /*************POSTES*************/
        public static Post creerPost(String poster,String contenu, String visibilite){
            Post p=new Post(getAbonne(poster), contenu, visibilite);
            basePosts.put(p.getCodePost(), p);
            return p;
        }

        //connexion & déconnexion

        public static boolean checkPassword(String user,String password){
            return getAbonne(user).getPassword().equals(password);

        }

        public static void seConnecter(String user) {
                getAbonne(user).setOnline(true);
        }

        public static void seDeconnecter(String user) {
            getAbonne(user).setOnline(false);
        }

        public static void notifier(Abonne recepteur ,String emetteur,String information,String type){
            recepteur.ajouterNotification(new Notification(emetteur,new StringBuilder(information),type));
        }

        public static void alerterAmis(Abonne abo){
            HashMap<String,Abonne> listeAmis = abo.getListeAmis();
            for(Abonne receveur: listeAmis.values()) {
              notifier(receveur,abo.getUsername()," un nouveau statut.","publication");
            }
        }

        //PUBLIER SUR MUR

        public static void publier(String user,String contenu,String visibilite) {
            Abonne abo=getAbonne(user);
                Post p=creerPost(user,contenu,visibilite);
            abo.ajouterPost(p); //ajouter le post au mur de celui qui l'a post�
            if(!visibilite.toLowerCase().equals("privé")) {
                alerterAmis(abo); //alerter les amis d'abo de la publication d'un certain contenu
                abo.ajouterActuAmis(p);
            }
        }

        //PUBLIER DANS UN GROUPE

        public static void publier(String user,String contenu, String grp,String visibilite) {//publier dans groupe

            Groupe g=getGroupe(grp);
                if(g!=null && g.membreExiste(user))
          	{
                    Post p =creerPost(user,contenu,visibilite);
	            g.ajouterPost(p);

	            g.alerterMembres(getAbonne(user),contenu,"publication"); //alerter les membres du groupe
          	}
        }

        //METHODES EPINGLER (EN CHOISIR 2)


        public static void epingler(int codePost) {
        	getPost(codePost).setEpinglee(true);
        	//ça peut servir à l'afficher en premier
        }
        public static void desepingler(int codePost) {
        	getPost(codePost).setEpinglee(false);
        }

         public static void rechercher(String chercheur,String recherche) {
          Abonne abo1=getAbonne(chercheur),
                 abo2=getAbonne(recherche);
                String visibilite= "publique";
                if(abo1 != null) {
                    // POUR SAVOIR QUI RECHERCHE QUI POUR POUVOIR CONNAITRE LA VISIBILITE ACCORDEE
                    if(chercheur.equals(recherche)) visibilite= "privé";
                    else if(abo2.sontAmis(abo1)) visibilite= "amis";
                    else if(abo2.ontAmisCommuns(abo1)) visibilite= "listeamis";
                }
                abo2.afficherMur(visibilite);

        }

    public static void rechercherGroupe(String user,String recherche){
         Groupe grp = getGroupe(recherche);
            if(grp!=null){
                if(grp.membreExiste(user)){
                    //ICI ON DEVRAIT AFFICHER TOUTES LES PUBLICATIONS
                    afficherMur(user,grp);
                }
            }
        }

        public static void reagir(String user,String react,int codePost) {//abo => abonné ayant r�agi, poster=>abonné ayant posté le post p
            Post p = getPost(codePost);
            Abonne abo=getAbonne(user);
                p.ajouterReaction(abo.getUsername(),react); //ajouter la réaction à l'ensemble des réactions au post
        	if(!abo.getUsername().equals(p.getPoster().getUsername())) //if(abo==poster) il réagi à sa propre publication (habes)
                    notifier(p.getPoster(),abo.getUsername()," à votre publication.","reaction");//alerter le poster seulement de la réaction d'abo à son post

        }


        //METHODES COMMENTAIRES

    public static void commenter(String user,int codePost,String comment) { //abo => abonn� qui va commenter, poster=>abonn� qui a post� le post p
     	Abonne abo=getAbonne(user);
        Post p=getPost(codePost);
            if(p!=null){
                    p.ajouterCommentaire(new Commentaire(abo.getUsername(),new StringBuilder(comment)));

		//alerter le poster si ce n'est pas lui qui a commenté a publication
		if(!p.getPoster().getUsername().equals(abo.getUsername())) {
			notifier(p.getPoster(),abo.getUsername()," votre publication.","commentaire");
                    }
            }
        }

    //supprimer un commentaire

    public static void supprimerCommentaire(String user,int codePost,Commentaire comment) { //commentaire de user
       Post p = getPost(codePost);
        if(user.equals(p.getPoster().getUsername()) || comment.getUser().equals(user))
            p.supprimerCommentaire(comment.getCode());

        }

    //partager dans un groupe

    public static void partager(String user,int codePost,String grp,String visibilite) {
        Post p=getPost(codePost);
        Groupe g = getGroupe(grp);
        	if(g!=null && g.membreExiste(user))       	//abo doit etre membre du groupe
                    publier(user,"a partagé la publication de "
                        +p.getPoster().getUsername()+"\n"+p.getContenu(),grp,visibilite);
           }
    //partager un post


    public static void partager(String user,int codePost, String visibilite) {
        Post p = getPost(codePost);
        	publier(user,"a partagé la publication de "
                        +p.getPoster().getUsername()+"\n"+p.getContenu(),visibilite);
        }

    public static void lireNotification(String user,int indice){
        ArrayList<Notification> notifs= getAbonne(user).getNotifications();
        System.out.println("l'indice est"+ indice);
        notifs.get(indice).setEtat(true);
        System.out.println(notifs.get(indice).getEtat());
    }


    //////////////////////////////////LE MAIN//////////////////////////////////////////////


    public static void main(String args[]) throws IOException, ClassNotFoundException{
        Abonne sfn= new Abonne("Zeghoud","Sofiane","20/05/1998","homme","sofman","imene","","","");
        Abonne imn= new Abonne("Kerboua","Imene","30/05/1999","femme","minette","sofiane","","","");
        inscrireAbonne(sfn);
        inscrireAbonne(imn);
        ajouter("sofman","minette","cc cv");
        accepterInvitation("minette","sofman");
        publier("minette","Ceci est pour le publique","publique");
        publier("minette","Ceci est pour les amis de mes amis","listeamis");
        publier("minette","Ceci est pour mes amis","amis");
        publier("minette","Ceci est pour moi-même","privé");
        reagir("sofman","jaime",2);
        reagir("sofman","jadore",1);













        ServerSocket socket=null;
        Socket serveur=null;
        ObjectInputStream in=null;
        ObjectOutputStream out=null;

        String username,password,ami,message;
        int indice;
        boolean check;

        while(true){
            try{
                socket=new ServerSocket(2018);
                serveur = socket.accept();
                out=new ObjectOutputStream(serveur.getOutputStream());
                in=new ObjectInputStream(serveur.getInputStream());

                byte choix;

                    choix = in.readByte();
                    switch(choix){

                    case 1 :     //LA CONNEXION
                        username=(String)in.readObject();

                        check=userExiste(username);
                        out.writeBoolean(check);
                        out.flush();
                        if(!check) break;


                        password=(String) in.readObject();

                        check=checkPassword(username,password);
                        out.writeBoolean(check);
                        out.flush();
                        if(!check) break;

                        seConnecter(username);
                    break;

                    case 2:     //L'INSCRIPTION
                        username=(String) in.readObject();

                        check = !userExiste(username);
                        out.writeBoolean(check);
                        out.flush();
                        if(!check) break;

                        inscrireAbonne((Abonne) in.readObject());
                    break;

                    case 3:  //LA DECONNEXION
                        username=(String) in.readObject();
                        seDeconnecter(username);
                        break;

                    case 4:  //ENVOYER LA LISTE DE NOTIFICATIONS
                        username=(String) in.readObject();
                        out.writeObject(getAbonne(username).getNotifications());
                        out.flush();
                        break;

                    case 5:  //ENVOYER LA LISTE D'INVITATIONS
                        username=(String) in.readObject();
                        out.writeObject(getAbonne(username).getInvitations());
                        out.flush();
                        break;

                    case 6:  //AJOUTER
                        username=(String) in.readObject();
                        ami=(String) in.readObject();
                        message=(String) in.readObject();
                        ajouter(username,ami,message);
                        break;









                }








            }catch(IOException e){
                System.out.println(e+" Impossible de se connecter");
            }finally{
                in.close();
                out.close();
                socket.close();
                serveur.close();

            }



    }

    }

}