# -*-coding:Latin-1 -*
"""client chat (TCP)"""
import socket
import threading
import time
import os

#modules persos
import lancer

#### initialisation des variables ####
port = 6660

#### fils secondaires ####

class ThreadReception(threading.Thread):
    """fil de reception"""
    def __init__(self, cnn):
        """initialisation du fil"""
        threading.Thread.__init__(self)
        self.cnn = cnn
        self.connecte = True
        
    def run(self):
        """reception et d'affichage des messages"""
        while self.connecte:
           try:
               message_recu = self.cnn.recv(1024)
               print(message_recu)
           except:
              self.stop()

    def stop(self):
        """fin de la reception"""
        print("Reception interrompue.")
        self.connecte = False
        self.cnn.close()        
            
class ThreadEmission(threading.Thread):
    """fil d'emission"""
    def __init__(self, cnn):
        """initialisation du fil"""
        threading.Thread.__init__(self)
        self.cnn = cnn
        self.connecte = True
        self.aEnvoyer = ""
        
    def run(self):
       """traitement et emission des messages""" 
       while self.connecte:
           if len(self.aEnvoyer):
               try:
                   self.cnn.sendall(self.aEnvoyer)
                   self.aEnvoyer = ""
               except:
                   self.stop()
                   
    def envoi(self, paquet):
        """envoie le message entre en parametre,
           le decoupe en paquets si necessaire"""
        if len(paquet) <= 1024:
             self.aEnvoyer = paquet
             retour = "envoye"
        else:
             retour = "message trop volumineux"        
        return retour

    def stop(self):
        """fin de l'emission"""
        print("Emission interrompue.")
        self.connecte = False
        self.cnn.close()  


class Client(threading.Thread):
    """client pour chat tcp"""
    def __init__(self):
        """initialisation du client"""
        threading.Thread.__init__(self)
        self.connecte = False
        self.pseudo = ""
        self.hote = ""

    def creer(self, pseudo, hote):
        """cree le client"""
        self.pseudo = pseudo
        if not len(self.pseudo) > 0:
            self.pseudo = "client"
        self.hote = hote
        if not len(self.hote) > 0:
            self.hote = "localhost"
        print("En attente du serveur...")

        while self.connecte==False:
        #en attente de la connexion    
            try:
               self.cnn = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
               self.cnn.connect((self.hote, port))
               self.connecte = True
               print("Connexion etablie avec le serveur sur le port {}".format(port))
               msg = "{} s'est connecte".format(self.pseudo)
               self.cnn.send(msg)
            except KeyboardInterrupt:
               break
            except:
               pass

        if self.connecte:    
            self.E = ThreadEmission(self.cnn)
            self.R = ThreadReception(self.cnn)
            self.E.start()
            self.R.start()
            self.start()
            
    def run(self):
        """boucle de fonctionnement"""
        saisie = ""
        while self.connecte:
            saisie = raw_input("")
            if saisie == "quit":
                break
            else:
                self.E.envoi("{}: {}".format(self.pseudo, saisie))

        self.stop()
        
    def stop(self):
        """fermeture du client"""
        self.connecte = False
        self.E.stop()
        self.R.stop()        
        self.cnn.close()
        print("Client ferme")


#### fil principal ####  
if __name__ == "__main__":
    # si lancement direct:
    pseudo = raw_input("Pseudo > ")
    hote = raw_input("Ip > ")
    c = Client().creer(pseudo, hote)


   
