#!/usr/bin/python
# -*- coding: GBK -*-
#
##@package
#
# @todo: 
#
# @author: Alee
# @date 2018-7-18 ÉÏÎç11:22:43
# @version 1.0
#
# @note: 
#
#---------------------------------------------------------------------

import struct
import string
import datetime
import os
import binascii
import socket
import sys


#pythonµÄ¶ÁÈ¡/дÈë¿â
#Òª½øÐз´×ª¸ßµÍλµÄ»°£¬¿ÉʹÓÃ!·ûºÅ£¬Èçstruct.unpack_from('!B', buf, pos)

#------------------------¶ÁÈ¡ 
def ReadBYTE(buf, pos):
    curValue = struct.unpack_from('b', buf, pos)
    pos += 1
    return curValue[0], pos

def ReadWORD(buf, pos):
    curValue = struct.unpack_from('H', buf, pos)
    pos += 2  
    return curValue[0], pos

def ReadDWORD(buf, pos):
    curValue = struct.unpack_from('i', buf, pos)  
    pos += 4
    return curValue[0], pos

def ReadFloat(buf, pos):
    curValue = struct.unpack_from('f', buf, pos)  
    pos += 4
    return curValue[0], pos

def ReadDouble(buf, pos):
    curValue = struct.unpack_from('d', buf, pos)  
    pos += 8
    return curValue[0], pos

def ReadString(buf, pos, _len):
    curValue = struct.unpack_from('%ds'%_len, buf, pos)
    pos += _len  
    return curValue[0], pos


#----------------------дÈë
def WriteBYTE(buf, value):
    buf += struct.pack('b', value)
    return buf

def WriteWORD(buf, value):
    buf += struct.pack('H', value)
    return buf

def WriteDWORD(buf, value):
    buf += struct.pack('i', value)
    return buf

def WriteFloat(buf, value):
    buf += struct.pack('f', value)
    return buf

def WriteDouble(buf, value):
    buf += struct.pack('d', value)
    return buf

def WriteString(buf, len, value):
    buf += struct.pack('%ds'%len, value)
    return buf



#»ñµÃµ±Ç°ÏµÍ³Ê±¼ä
def GetCurrentDataTimeStr():
    curTime = datetime.datetime.today()
    curTimeStr = str(curTime)
    curTimeStr = curTimeStr.split(".")[0]
    return curTimeStr

#»ñµÃϵͳʱ¼ä(²ÎÊý -> ʱ¼äÁбí)
def GetDateTimeByStr(timeStr):
    timeStr = timeStr.split(".")[0]
    return  datetime.datetime.strptime(timeStr, "%Y-%m-%d %H:%M:%S")
    
    
    
#×Ö·û´®×ª»»ÎªÕûÐÍ, Èç¹û²»ÄÜת»», ·µ»ØĬÈÏÖµ
def ToIntDef(input, defValue = 0):
    try:
        result = int(input)
        return result
    except ValueError:
        return defValue
    
    
#×Ö·û´®×ª»»ÎªÕûÐÍ, Èç¹û²»ÄÜת»», ·µ»ØFalse,Ô­Öµ
def StrToInt(input):
    try:
        result = int(input)
        return True,result
    except ValueError:
        return False,input
    
    
#16½øÖÆÑÕɫת»»
#"#FFFFFF"--"255,255,255"
def HcToSc(h):
    h="0x"+h[1:7]
    red=string.atoi(h[:2]+h[2:4], base=16)
    green=string.atoi(h[:2]+h[4:6], base=16)
    blue=string.atoi(h[:2]+h[6:8], base=16)
    cStr=str(red)+","+str(green)+","+str(blue)
    return cStr

#"255,255,255"--"#FFFFFF"
def ScToHc(s):
    red=hex(string.atoi(s.split(",")[0]))[2:]
    green=hex(string.atoi(s.split(",")[1]))[2:]
    blue=hex(string.atoi(s.split(",")[2]))[2:]
    hStr="#"+str(red+green+blue)
    return hStr

#16½øÖÆת»»
#"0xFFFFFF"--"255,255,255"
def HdToSd(h):
    red=string.atoi(h[0:2]+h[2:4], base=16)
    green=string.atoi(h[0:2]+h[4:6], base=16)
    blue=string.atoi(h[0:2]+h[6:8], base=16)
    cStr=str(red)+","+str(green)+","+str(blue)
    return cStr

#"255,255,255"--"0xFFFFFF"
def SdToHd(s):
    red=hex(string.atoi(s.split(",")[0]))[2:]
    green=hex(string.atoi(s.split(",")[1]))[2:]
    blue=hex(string.atoi(s.split(",")[2]))[2:]
    hStr="0x"+str(red+green+blue)
    return hStr

def GetPercent(value1, value2):
    if value2 == 0:
        return 0
    return int(float(value1) / float(value2) * 100)



def OpenFileForWrite(fileName):
    dirName = os.path.dirname(fileName)
    if not os.path.isdir(dirName):
        os.makedirs(dirName)
    
    if os.path.isfile(fileName):
        return open(fileName, 'w')
    return  open(fileName, 'a')




#º¯Êýµ÷ÓÃ
def ParseNameGetObj(curCallObj, callName):
    callList = callName.split(".")
    if len(callList) <= 1:
        return None
    
    for curCallName in callList:
        if hasattr(curCallObj, curCallName) != True:
            #ÎÞ´ËÊôÐÔ
            return None
        curCallObj = getattr(curCallObj, curCallName)
    return curCallObj

#»ñµÃÖ´Ðк¯Êý
def GetExecFunc(curCallObj, callName):
    curCallObj = ParseNameGetObj(curCallObj, callName)
    if curCallObj == None:
        return None
        
    if callable(curCallObj) != True:
        #²»¿Éµ÷ÓÃ
        return None
    
    return curCallObj

#×Ö·û´®Òì»ò´¦Àí
def str_xor(astring, xornum=150):
    a=[]
    for x in astring:
        a.append(chr(ord(x)^xornum))
    return ''.join(a)

#½âÎö·â°ü
def ParseBuff(buff):
    result=''
    for i in  range(len(buff)):
        if i%2==0 and i!=0:
            result=result + ' ' + buff[i]
        else:    
            result = result + buff[i]        
    return result

def b2a_hex(data):
    return ParseBuff(binascii.b2a_hex(data))

def GetHostName():
    return socket.gethostname()

def GetHostIP():
    return socket.gethostbyname(GetHostName()) 


def compact_traceback():
    t, v, tb = sys.exc_info()
    tbinfo = []
    if not tb: # Must have a traceback
        raise AssertionError("traceback does not exist")
    while tb:
        tbinfo.append((
            tb.tb_frame.f_code.co_filename,
            tb.tb_frame.f_code.co_name,
            str(tb.tb_lineno)
            ))
        tb = tb.tb_next

    # just to be safe
    del tb

    info = ' '.join(['[%s|%s|%s]' % x for x in tbinfo])
    return t, v, info

import base64
import urllib
import urllib2

#---------------------------------------------------------------------
## ¼ÓÃÜËã·¨ÐèÒªµÄ¶¨Òå
Def_NumEncodeCnt = 3  # ¼ÓÃܵĴÎÊý
Def_NumXorKey = 151  # Òì»òµÄkey

## ¹«Ë¾ÄÚ²¿½âÃÜËã·¨
def GetDecodePwd(strPwd):
    strResult = strPwd
    for index in xrange(Def_NumEncodeCnt):
        strResult = base64.b64decode(strResult)

    tempResult = ""
    for index in xrange(len(strResult)):
        tempResult += chr(ord(strResult[index])^Def_NumXorKey)

    return tempResult


## ¹«Ë¾ÄÚ²¿¼ÓÃÜËã·¨
def GetEncodePwd(strPwd):
    strResult = ""
    for index in xrange(len(strPwd)):
        strResult += chr(ord(strPwd[index])^Def_NumXorKey)

    for index in xrange(Def_NumEncodeCnt):
        strResult = base64.b64encode(strResult)

    return strResult



#---------------------------------------------------------------------
## UTF-8 <==> GBK
def gbk2utf8(content):
    if type( content ) is not str:
        content = str(content)

    try:
        return content.decode('gbk').encode('utf-8')
    except:
        return content


def utf82gbk(content):
    if type( content ) is not str:
        content = str(content)

    try:
        return content.decode('utf-8').encode('gbk')
    except:
        return content


## GETÇëÇó
def DoGet(url, data=None, headers={}): 
    if data:   
        request = urllib2.Request(url + "?" + urllib.urlencode(data), None, headers)
    else:
        request = urllib2.Request(url, None, headers)
    response = urllib2.urlopen(request, timeout=5)
    content = response.read()
    response.close()
    return content


## POSTÇëÇó
def DoPost(url, data, headers={}):
    try:
        data = urllib.urlencode(data)
    except:
        pass
    
    request = urllib2.Request(url, data, headers)
    try:
        response = urllib2.urlopen(request, timeout=30)
        content = response.read()
        response.close()
    except:
        content = "error timeout"
    return content


FileTypeDict = {
'.txt':'text/html',
'.html':'text/html',
'.htm':'text/html',
'.bmp':'application/x-bmp',
'.ico':'image/x-icon',
'.jpe':'image/jpeg',
'.jpeg':'image/jpeg',
'.jpg':'application/x-jpg',
'.png':'application/x-png',
'.gif':'image/gif',
'.bin':'application/octet-stream',
'.*':'application/octet-stream'
}

def GetHttpContentType(strType):
    return FileTypeDict[strType]



## ±àÂë
#  @param srcEncoding ±àÂë¸ñʽ
#  @param input ×Ö·û´®
#  @return None
def EncodingToUnicode(srcEncoding, msg):
    try:
        result = unicode(msg, srcEncoding)    #translate to utf-8
    except:
        return "EncodingToUnicode error"
    return result


## ±àÂë
#  @param srcEncoding ±àÂë¸ñʽ
#  @param input ×Ö·û´®
#  @return None
def UnicodeToEncoding(dstEncoding, msg):
    try:
        result = msg.encode(dstEncoding)
    except:
        return "UnicodeToEncoding error"
    return result