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(user);
           if(userExiste(ami)){
           ArrayList invits = getAbonne(ami).getInvitations();
	   invits.add(new Invitation(abo,getAbonne(ami),message) );
          }
        }

       public static void refuserInvitation(Invitation inv){
           inv.setEtat(InvitationEtat.valueOf("refusée"));
       }
       public static void accepterInvitation(Invitation inv){
            inv.setEtat(InvitationEtat.valueOf("acceptée"));
            HashMap<Integer,Abonne> amis = inv.getEmetteur().getListeAmis();
            amis.put(inv.getRecepteur().getCode(),inv.getRecepteur());

            amis = inv.getRecepteur().getListeAmis();
            amis.put(inv.getEmetteur().getCode(),inv.getEmetteur());

            notifier(inv.getEmetteur(),inv.getRecepteur().getUsername()," votre invitation.","invitation");
        }

       public static void accepterInvitation(String ab,String user){
          Abonne abo=getAbonne(ab);
            HashMap<Integer,Abonne> amis;
            amis = abo.getListeAmis();

            Abonne ami=getAbonne(user);
            amis.put(ami.getCode(), ami);

            amis = ami.getListeAmis();
            amis.put(abo.getCode(), abo);

            notifier(getAbonne(user),abo.getUsername()," 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 ab,String ami){//supprimer qlqn de sa liste d'ami


           Abonne user=getAbonne(ami),
                  abo=getAbonne(ab);
           HashMap amis;
           amis= abo.getListeAmis();
           amis.remove(user.getCode());

           amis=user.getListeAmis();
           amis.remove(abo.getCode());

       }


       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 Abonne seConnecter(String user) {
                Abonne abo= getAbonne(user);
                abo.setOnline(true);
                return abo;
        }

        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));
        }

        //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é")) {
                abo.alerterAmis(" un nouveau statut.","publication"); //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);
        }


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


    public static void main(String args[]) throws IOException, ClassNotFoundException{
        Abonne sfn= new Abonne("Sofiane","Zeghoud","20/05/1998","homme","sofman","imene","","","");
        inscrireAbonne(sfn);
        ServerSocket socket=null;
        Socket serveur=null;
        ObjectInputStream in=null;
        ObjectOutputStream out=null;

        String username,password;
        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;

                    out.writeObject(seConnecter(username));
                    out.flush();


                    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;







                }








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

            }



    }

    }

}