"""
   ***************************************************
   *   Peer              			     *
   ***************************************************
   * reputation: float     			     *
   * upload: float         			     *
   * download: float	 			     *
   * name: string		 		     *
   * normalised_up: float	 		     *
   * properties: string	 			     *
   * coordinates: tuple 	 		     *
   ***************************************************
   * Peer(float rep,float up,float down, string name)*
   * setRep(float rep)        			     *
   * setUp(float up)        			     *
   * setDown(float down)    			     *
   * setNormUP(float norm_up)      		     *
   * setName(string name)			     *
   * setProperties()				     *
   * setCoordinates(tuple p)			     *
   * getRep(): float reputation			     *
   * getUp(): float Upload			     *
   * getDown():float Download			     *
   * getNormUP(): float normalised_up		     *
   * getName(): string name			     *
   * getCoordinates():tuple coordinates		     *
   * getProperties(): string properties		     *
   * visPeer()   				     *
   ***************************************************


   ***************************************************
   *   Swarm              		             *
   ***************************************************
   * group: array     				     *
   ***************************************************
   * Swarm()					     *
   * add(Peer peer)	        		     *
   * setPeerRep(int number, float rep)   	     *
   * setPeerDown(int number, float down)    	     *
   * setPeerUp(int number, float up)	    	     *
   * setPeerNormUP(int number, float norm_up)	     *
   * setPeerName(int number,string name)	     *
   * setProperties()				     *
   * setPeerCoordinates(number,tuple p)		     *
   * getRep(int number): float reputation	     *
   * getPeerUp(int number): float Upload	     *
   * getPeerDown(int number):float Download	     *
   * getPeerNormUP(int number): float normalised_up  *
   * getPeerName(int number): string name	     *
   * getPeerCoordinates(int number):tuple coordinates*
   * getPeerProperties(int number):string properties *
   * visSwarm()   				     *
   ***************************************************

"""





import wx
import math
import time
import threading
import thread
import sys
import string
import operator
from random import *

# initialise a peer defined by its reputation and bandwidth in upload and download
class Peer:
    def __init__(self, rep, up, down,name):
        self.reputation = rep
        self.upload = up
        self.download = down
        self.name=name
        self.normalised_up = 0
        self.properties = ''
        self.coordinates = (0,0)
    #sets the reputation and bandwidth of the peer
    def setRep(self, rep):
        self.reputation = rep
    def setUp(self, up):
        self.upload = up
    def setDown(self,down ):
        self.download = down
    def setNormUP(self,norm_up):
        self.normalised_up = norm_up
    def setName(self,name):
        self.name=name
    def setProperties(self):
        self.properties=self.getName() + '\nReputation: ' + repr(self.getRep())+ '\nBandwidth in Upload: ' +  repr(self.getUp()) + '\nBandwidth in Download: '+ repr(self.getDown())
    def setCoordinates(self,p):
        self.coordinates=p
    #sets the reputation and bandwidth of the peer
    def getRep(self):
        return self.reputation
    def getUp(self):
        return self.upload
    def getDown(self):
        return self.download
    def getNormUP(self):
        return self.normalised_up
    def getName(self):
        return self.name
    def getCoordinates(self):
        return self.coordinates
    def getProperties(self):
        return self.properties
    #print the reputations and bandwidth of the peer
    def visPeer(self):
        print self.properties

#initialise a swarm composed by a given number of peers
class Swarm:
    def __init__(self):
        self.group = []
    def add(self, peer):
        self.group.append(peer)
    def setPeerRep(self, number,rep):
        self.group[number].setRep(rep)
    def setPeerUp(self, number,up):
        self.group[number].setUp(up)
    def setPeerDown(self, number,down):
        self.group[number].setDown(down)
    def setPeerNormUP(self, number,norm_up):
        self.group[number].setNormUP(norm_up)
    def setPeerName(self, number,name):
        self.group[number].setName(name)
    def setPeerCoordinates(self, number,p):
        self.group[number].setCoordinates(p)
    def setProperties(self):
        for i in range (len(self.group)):
            self.group[i].setProperties()
    def getPeerRep(self, number):
        return self.group[number].getRep()
    def getPeerUp(self, number):
        return self.group[number].getUp()
    def getPeerDown(self, number):
        return self.group[number].getDown()
    def getPeerNormUP(self, number):
        return self.group[number].getNormUP()
    def getPeerName(self, number):
        return self.group[number].getName()
    def getPeerCoordinates(self, number):
        return self.group[number].getCoordinates()
    def getPeerProperties(self, number):
        return self.group[number].getProperties()
    def visSwarm(self):
        for i in range (len(self.group)):
            self.group[i].visPeer()



#generates a swarm composed by a given number of peers and sets random reputation and bandwidth for each peer
def generateSwarm(number):
    peers = Swarm()
    chars = string.letters + string.digits
    name_length=8
    for i in range (number):
        x = Peer(uniform(1,3),randint(1,200),randint(1,600),''.join([choice(chars) for i in range(name_length)]))
        peers.add(x)
    return peers



#sort the swarnm according to its bandwidth in upload
def SortSwarm(swarm):

    swarm.group.sort(key=operator.attrgetter('upload'))
    return swarm

def UploadBandwidth(swarm):
    resolution_1=wx.DisplaySize()
    x_1=resolution_1[0]/2
    y_2=resolution_1[1]/2
    maximum = y_2-10
    for i in range(len(swarm.group)):
        """if swarm.getPeerUp(i)==0:
           swarm.setPeerNormUP(i,maximum)
        elif swarm.getPeerUp(i)>0 and swarm.getPeerUp(i)<=10:
           swarm.setPeerNormUP(i,maximum-step)
        elif swarm.getPeerUp(i)>10 and swarm.getPeerUp(i)<=20:
           swarm.setPeerNormUP(i,maximum-2*step)
        elif swarm.getPeerUp(i)>20 and swarm.getPeerUp(i)<=30:
           swarm.setPeerNormUP(i,maximum-3*step)
        elif swarm.getPeerUp(i)>30 and swarm.getPeerUp(i)<=40:
           swarm.setPeerNormUP(i,maximum-4*step)
        elif swarm.getPeerUp(i)>50 and swarm.getPeerUp(i)<=60:
           swarm.setPeerNormUP(i,maximum-5*step)
        else:
            swarm.setPeerNormUP(i,maximum-6*step)"""
        swarm.setPeerNormUP(i,maximum-swarm.getPeerUp(i))
    return

test_sorted = Swarm()


class TransientPopup(wx.PopupTransientWindow):
    def __init__(self, parent, style,prop):
        wx.PopupTransientWindow.__init__(self, parent, style)
        self.SetBackgroundColour("#c0c0c0")
        st = wx.StaticText(self, -1,prop,pos=(10,10))
        sz = st.GetBestSize()
        self.SetSize((sz.width+20, sz.height+20))

class DrawPanel(wx.Panel):
    def __init__(self, parent):
        wx.Panel.__init__(self, parent, -1)
        wx.EVT_PAINT(self, self.onPaint)
        self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)


    def OnLeftDown(self, event):
        global test_sorted
        point = event.GetPosition()
        for i in range(len(test_sorted.group)):
            if (pow(point[0]-test_sorted.getPeerCoordinates(i)[0],2)+pow(point[1]-test_sorted.getPeerCoordinates(i)[1],2)<pow(test_sorted.getPeerRep(i)*3,2)):
               win = TransientPopup(self,wx.SIMPLE_BORDER,test_sorted.getPeerProperties(i))
               win.Position(point,(10,10))
               win.Popup()

    def onPaint(self, event=None):
        global test_sorted
        test = generateSwarm(50)
        test_sorted = SortSwarm(test)
        UploadBandwidth(test_sorted)
        test_sorted.setProperties()
        #test_sorted.visSwarm()
        start=time.time()
        dc = wx.PaintDC(self)
        rect = self.GetClientRect()
        dc.SetBrush(wx.Brush("#708090"))
        dc.DrawRectangle(0, 1, rect.width - 0.5, rect.height - 0.5)
        dc.SetPen(wx.Pen('#ff0000'))
        dc.SetBrush(wx.Brush("#ff0000"))
        t= 0;
        resolution=wx.DisplaySize()
        x=resolution[0]/2
        y=resolution[1]/2
        dc.DrawCircle(x,y,20)
        dc.SetPen(wx.Pen('#000080'))
        dc.SetBrush(wx.Brush("#000080"))
        for i in range (len(test_sorted.group)):
            n = x+test_sorted.getPeerNormUP(i)*math.cos(t)
            m = y+test_sorted.getPeerNormUP(i)*math.sin(t)
            dc.DrawCircle(n,m,test_sorted.getPeerRep(i)*3)
            t=t+math.pi/25;
            p=wx.Point(n,m)
            test_sorted.setPeerCoordinates(i,p)
        stop=time.time()
        elapsed= stop-start
        #print elapsed
        t = threading.Timer(6.0,self.Refresh)
        t.start()

app = wx.App()
frame = wx.Frame(None, -1, "Prototype Swarm Visualization", size=wx.DisplaySize())
dp = DrawPanel(frame)
frame.ShowFullScreen(True)
app.MainLoop()