#  -*- coding: utf-8 -*-
# !/usr/bin/env python

import  SocketServer
 from  SocketServer  import  StreamRequestHandler as SRH
 from  time  import  ctime
 import  struct
 import  json
 import  urllib
 import  urllib2
 import  socket
 import  time
 import  traceback

 import  threading
 import  globalres

host  =   ''
port  =   5004
addr  =  (host,port)

url  =   ' http://yoururl '

'''
First, you must create a request handler class by subclassing the BaseRequestHandler class 
and overriding its handle() method; 
this method will process incoming requests.
 '''
class  TcpNetHandler(SRH):      
     def  handle(self):
         print   ' [server] got connection from  ' ,self.client_address
         # self.wfile.write('connection %s:%s at %s succeed!' % (host,port,ctime()))
        old_buf  =   ''
        new_buf  =   ''    
        all_buf  =   ''
         while  True:
             try :
                new_buf  =  self.request.recv( 1024 * 1024 )
                 if   not  new_buf: 
                     print   ' [server] lost connection from  ' ,self.client_address
                     break
                
                all_buf  =  old_buf  +  new_buf                
                 if  len(all_buf)  <   16  :
                     continue                 
                
                processedlen = self.processRecvdBuffer(all_buf)
                 if   - 1   ==  processedlen :
                     break                  
                remain_len  =  len(all_buf)
                 if  remain_len  >  processedlen :                 
                    old_buf  =  all_buf[processedlen:]      
                     print   " [server] process:%d ,remain:%d " % (processedlen,remain_len)
                 # print "[server] finish once"    
             except :
                 print   ' error in ThreadedTCPRequestHandler :%s '   %  (traceback.format_exc())
                 # return
                
     def  processRecvdBuffer(self,recvbuf):
        processedlen  =  0
        total_len =  len(recvbuf)
        remain_buf  =  recvbuf
         while  True :
            (retcode,size,cmd)   =  self.unpackFromBuffer(remain_buf)
             if   - 1   ==  retcode :
                 print   ' [server] unpackFromBuffer error:  ' ,retcode
                 return   - 1                     
             if   0  ==  retcode :
                 print   ' [server] next time again '   
                 break             
            netpacket  =  remain_buf[:size]
             if  cmd  ==  0:
                 print   " [server] client-keeplive,from: " ,self.client_address
                self.request.send(netpacket)
             elif  cmd  ==   102 :
                globalres.netpackqueue.put(netpacket)  
                 # print "102"
                 pass
             else  :
                 print   " other  " ,cmd     
            
            processedlen  =  processedlen + size
             if  processedlen  >= total_len :
                 break
            remain_buf = remain_buf[size:]
         pass
         return  processedlen            
                            
                           
     '''
    retcode : -1,failed;0,next time again;1,success,
     '''
     def  unpackFromBuffer(self,bytebuf1):
        packet_header  =  bytebuf1[: 16 ]
        (size,cmd,subcmd,magic,version) = struct.unpack( ' IHHII ' ,packet_header)
         if  cmd  ==  0  and  size == 16 :
             # print "[server] client-keeplive"
            self.request.send(packet_header)
             return  ( 1 , 16 ,0)        
         if  size  <   16   or  size  >   4096 :
             print   " [server] invalid size " ,size
             return  ( - 1 , - 1 ,cmd)    
         if  len(bytebuf1)   <   size:
             print   " [server]  buf not enough " ,len(bytebuf1),size
             return  (0,0,cmd)
         return  ( 1 ,size,cmd)                       
            


 class  HttpRequestThread(threading.Thread):   
     def   __init__ (self, queue,htint):
        threading.Thread. __init__ (self)
        self.queue  =  queue
        self.Ht = htint   # 线程ID
     def  run(self):
         while  True:    
             if  self.queue.empty() :
                time.sleep( 0.01 )
                 continue             
            netpacket  =  self.queue.get()
             # print "[Thread%d] get from qsize:%d "%(self.Ht,self.queue.qsize())
             try :
                self.processNetPacket(0,netpacket)                
             finally :  
               self.queue.task_done()
               
               
     def  processNetPacket(self,cmd,netpacket):    
        self.process_cmd102_post_pushmsg(netpacket)
         # print "[server] dispatchNetPacket",(cmd,netpacket,netpacksize)
         # if cmd==102 :
          #    self.process_cmd102_post_pushmsg(netpacket)
           #   pass       
         # else:
          #    print "[server] invalid cmd:",cmd
           #   pass                   
               
     def  process_cmd102_post_pushmsg(self,netpacket):        
        data  =   netpacket[ 16 :] 
        datasize  =  len(netpacket)  - 16
        msgsize  =   datasize  -   26
         # fmtstr  = "QQQH%ds"%(msgsize)
         print   " [Thread%d] fmtstr:%s " % (self.Ht,fmtstr)
        (groupid,memberid,senderid,devicetype,message) = struct.unpack(fmtstr,data)
         # print "[server] fmtstr unpack:", (groupid,memberid,senderid,devicetype,message)
        dict1 = dict()
        dict1[ " groupid " ] = groupid
        dict1[ " memberid " ] = memberid
        dict1[ " devicetype " ] = devicetype
        dict1[ " message " ] = message        
        content  =  urllib.urlencode(dict1)
         print   " [Thread%d] urlencode content:%s " % (self.Ht,content)
        urllib2.socket.setdefaulttimeout( 5 )
        request  =  urllib2.Request(url, content)
        response  =  urllib2.urlopen(request)  
        page  =  response.read()        
         print   " [Thread%d] response:%s " % ( self.Ht,page.decode( " utf-8 " ) )    
         pass                    
            

 def  prepareWorkThreadPoll():
     print   " [server] prepareWorkThreadPoll "     
     for  i  in  range( 4 ):
        t  =  HttpRequestThread(globalres.netpackqueue,i)
        t.setDaemon(True)
        t.start()
         print   " [server] startthread: " ,i           
        
 '''
Second, you must instantiate one of the server classes, passing it the server’s address
 and the request handler class. 
Finally, call the handle_request() or serve_forever() method of the server 
object to process one or many requests.
 '''         
 def  main():
    prepareWorkThreadPoll() 
    server  =  SocketServer.ThreadingTCPServer(addr,TcpNetHandler)
     print   ' server is running in port %d. ' % (port)
    server.serve_forever()      
     pass

    
main()      
 # test(buf)            



# data=buf
# print buf
# dict1 = json.loads(data)
# print "load dict:",type(dict1),dict1