import sys

import Tkinter as tk
import tkMessageBox

from twisted.internet import reactor
from twisted.internet.protocol import Protocol, ClientFactory, Factory
from twisted.protocols.basic import LineReceiver
from twisted.internet import tksupport

class ChatClientProtocol(LineReceiver):
    """
    Simple Echo Client Protocol

    registers at self.factory and echos all
    incoming data to factory to log (display in the textbox)
    """

    def connectionMade(self):
        """
        Called when connection is made and self.factory is set

        registers self at factory as the protocolobject
        """
        self.factory.protocolobj = self


    def lineReceived(self, line):
        """
        Called when one line (i.e. all data until self.delimiter) was received

        simply send it to self.factory.log
        """
        self.factory.log(line)

    def connectionLost(self, reason):
        """
        Called when the connection was lost

        stop the reactor and with it the mainloop and quit the program
        """
        reactor.stop()


class ChatClientFactory(ClientFactory):
    """
    Client Factory

    holds the main program (incl, GUI) starts a server or connects
    to a client and builds the local Protocol object for that connection.
    """
    protocol = ChatClientProtocol
    protocolobj = None

    def __init__(self):
        """
        Build up the GUI
        """
        self.root = tk.Tk()
        self.root.protocol("WM_DELETE_WINDOW", self.on_quit)
        self.root.title("chatwisted")
        self.bar = tk.Frame()
        self.bar.pack(fill=tk.X, side=tk.TOP)
        self.iplab = tk.Label(self.bar, text="IP:")
        self.iplab.pack(side="left")
        self.ipent = tk.Entry(self.bar, width=15)
        self.ipent.pack(side="left")
        self.ipent.insert(tk.END, "localhost")
        self.portlab = tk.Label(self.bar, text="Port:")
        self.portlab.pack(side="left")
        self.portent = tk.Entry(self.bar, width=10)
        self.portent.pack(side="left")
        self.portent.insert(tk.END, "5555")
        self.hostbut = tk.Button(self.bar, text="host", command=self.start_server)
        self.hostbut.pack(side="left")
        self.conbut = tk.Button(self.bar, text="connect", command=self.start_client)
        self.conbut.pack(side="left")
        self.about = tk.Button(self.bar, text="about", command=self.about)
        self.about.pack(side="right")
        self.bellvar = tk.IntVar()
        self.bellcheck = tk.Checkbutton(self.bar, text="bell", variable=self.bellvar)
        self.bellcheck.pack(side="right")
        self.scrollbar = tk.Scrollbar()
        self.scrollbar.pack(side="right", fill=tk.Y)
        self.textbox = tk.Text(yscrollcommand=self.scrollbar.set)
        self.textbox.pack(fill=tk.BOTH, expand=1)
        self.textbox.config(state=tk.DISABLED)
        self.scrollbar.config(command=self.textbox.yview)
        self.bottomframe = tk.Frame()
        self.bottomframe.pack(fill=tk.X, side="bottom")
        self.entry = tk.Entry(self.bottomframe)
        self.entry.pack(side="left", fill=tk.BOTH, expand=1)
        self.entry.bind("<KeyPress-Return>", self.sendMessage)
        self.b1 = tk.Button(self.bottomframe, text="Send", command=self.sendMessage)
        self.b1.pack(side="right")

    def on_quit(self):
        """
        Called when a user tries to close the window

        ask for confirmation
        """
        if tkMessageBox.askokcancel("Quit", "Do you really wish to quit?"):
            reactor.stop()

    def clientConnectionFailed(self, connector, reason):
        reactor.stop()

    def clientConnectionLost(self, connector, reason):
        reactor.stop()

    def sendMessage(self, button=None):
        """
        Send the text from the text entry to the server

        :param button:
          dummy parameter for bind-callback
        :type button:
          tk.Button or None
        """
        line = self.entry.get()
        if self.protocolobj and line:
            self.protocolobj.sendLine(line.encode('utf8'))
            self.entry.delete(0, "end")
            self.bell()

    def log(self, line):
        """
        Appends a line (without linebreak) to the textbox (and adds a lb)
        """
        self.textbox.config(state=tk.NORMAL)
        self.textbox.insert(tk.END, line+"\n")
        self.textbox.see(tk.END)
        self.textbox.config(state=tk.DISABLED)
        self.bell()

    def bell(self):
        """
        Ring the bell if wished

        just a joke ;)
        """
        if self.bellvar.get():
            self.root.bell()

    def about(self):
        """
        Pop up an info message
        """
        text = """
            Chatwisted
simple chat with Tkinter and Twisted

(cc) by Julian Habrock, 31.1.09
some rights reserved (cc by-nc-sa)
more infos on bytemuehle.de
"""
        tkMessageBox.showinfo("About", text)

    def start_client(self, ip=None, port=None):
        """
        Start a client and connect to a server
        :Parameters:
          ip : string or None
            ip to connect to. If None, the value of self.ipent is used
          port : int or None
            port to use. If None, the value of self.portent is used
        """
        port = port or self.portent.get()
        ip = ip or self.ipent.get()
        if ip and port:
            reactor.connectTCP(ip, port, self)

    def start_server(self, port=None):
        """
        Start a server and connect to it as client
        :Parameters:
          port : int or None
            port to use. If None, the value of self.portent is used
        """
        try:
            port = port or int(self.portent.get())
        except ValueError:
            tkMessageBox.showerror("Wrong Port", "Port must be a number")

        if port:
            reactor.listenTCP(port, ChatServerFactory())
            self.start_client("localhost", port)


class ChatServerProtocol(LineReceiver):
    """
    Server Protocol

    Represents a client on the server, holds its data (name) and gives the
    user interface (ie. encodes the commands)
    """
    prompt = "Whats your name?"
    welcome = "<Use /command to execute commands and /help to get a list of all commands.>"
    helptext = """
<Currently, the following commands are supported:                        >
</list           - get a list of all connected people                    >
</rename newName - rename yourself                                       >
</me action      - do sth. (this will produce a "<username action>" line >
</help           - print this help message                               >
"""
    whatdoyoumean = "<Hu? What do you mean? Try /help>"

    def connectionMade(self):
        """
        Called when connected

        ask the new client for his name by sending the prompt
        """
        self.name = None
        self.sendLine(self.prompt)

    def connectionLost(self, reason):
        """
        Called when disconnected

        logout at factory
        """
        self.factory.logout(self, reason)

    def lineReceived(self, line):
        """
        Called when one line (i.e. all data until self.delimiter) was received

        if line is the first line, register at factory with line as name.
        if not, parse line for commands and interpret it (or simply broadcast it)
        """
        line = line.rstrip()
        if not self.name:
            self.name = self.factory.register(self, line)
            self.sendLine(self.welcome)
        elif line.startswith("/"):
            if " " in line:
                cmd, arg = line[1:].split(" ", 1)
            else:
                cmd, arg = line[1:], None
            if cmd in ("nick", "rename"):
              if not arg:
                  self.sendLine("<Your nick is %s, to change pass a new name!>" % self.name)
              elif arg == self.name:
                  self.sendLine("<Your nick is allready %s!>" % self.name)
              else:
                  self.name = self.factory.rename(self, arg)
            elif cmd in ("list", "clients", "all"):
              self.factory.get_list(self)
            elif cmd == "me" and arg:
              self.factory.do(self, arg)
            elif cmd == "help":
              self.sendLine(self.helptext)
            else:
              self.sendLine(self.whatdoyoumean)
        else:
          self.factory.say(self, line)



class ChatServerFactory(Factory):
    """
    Server Factory

    Creates a new Protocol object for every connecting client and
    manages all clients and their interaction
    """
    protocol = ChatServerProtocol
    clients = {}
    client_no = 0

    def register(self, client, name):
        """
        Called from a client (ChatServerProtocol) to register itself as new client

        searches for a valid name and add `client` to the client dict

        :Parameters:
          client : ChatServerProtocol
            reference to the client that wants to register
          name : string
            preferred name of the new client
        :return:
            name of the client (may be different to `name` when there is
            allready a client with that name
        :rtype: string
        """
        if name in self.clients:
            i = 2
            while name+str(i) in self.clients:
              i+= 1
            name += str(i)
        self.clients[name] = client
        self.client_no += 1
        client.sendLine("{registered as %s}" % name)
        self.broadcast("<All welcome %s, client no. %i!>" % (name, self.client_no))
        return name

    def logout(self, client, reason):
        """
        Called from a client (ChatServerProtocol) to log out

        removes `client` from the client dict

        :Parameters:
          client : ChatServerProtocol
            reference to the client that wants to log out
          reason : string
            currently not used
        """
        del self.clients[client.name]
        self.broadcast("<%s has gone away>" % client.name)

    def rename(self, client, new_name):
        """
        Called from a client (ChatServerProtocol) to rename itself

        validates `new_name` and returns the new name

        :Parameters:
          client : ChatServerProtocol
            reference to the client that wants to get a new name
          new_name : string
            preferred new name
        :return:
            name of the client (may be different to `name` when there is
            allready a client with that name
        :rtype: string
        """
        if new_name in self.clients:
            i = 2
            while new_name+str(i) in self.clients:
              i+= 1
            new_name += str(i)
        self.clients[new_name] = client
        del self.clients[client.name]
        self.broadcast("<%s renamed to %s>" % (client.name, new_name))
        return new_name

    def get_list(self, client):
        """
        sends a priv message to `client` with a list of all connected clients
        """
        clients = " ".join(filter(lambda n: n != client.name, self.clients.keys()))
        if len(self.clients) == 1:
            client.sendLine("<You are alone on this server. Totally lost. Be nice!>")
        else: client.sendLine("<%i people are currently connected: %s and you>" %
                                                      (len(self.clients), clients))


    def say(self, speaker, line):
        """
        broadcasts a message to all clients that `speaker` says `line`
        """
        line = "<%s>: %s" % (speaker.name, line)
        self.broadcast(line)

    def do(self, actor, action):
        """
        broadcasts a message to all clients that `speaker` does `line`
        """
        line = "<%s %s>" % (actor.name, action)
        self.broadcast(line)

    def broadcast(self, line):
        """
        sends `line` to all clients
        """
        for client in self.clients.itervalues():
            client.sendLine(line)



if __name__ == "__main__":
    factory = ChatClientFactory()
    tksupport.install(factory.root)
    reactor.run()