import popen2

def compressedSize(s):
    mi, mo = popen2.popen2("gzip | wc -c")
    mo.write(s)
    mo.close()
    return int(mi.read().strip())

def infoInChunks(chunkTexts, omitNum):
    s = ''
    for i in xrange(0, len(chunkTexts)):
        if i != omitNum:
            s += chunkTexts[i]
    return compressedSize(s)

class Chunk:
    def __init__(self, text, start, end, filename):
        self.text = text
        self.length = len(text)
        self.start = start
        self.end = end
        self.filename = filename

    def addInfo(self, index, info, total):
        self.index = index
        self.info = info
        self.total = total

    def __str__(self):
        return ("%3d: %5d %5d %6.2f%% %6.2f%%  %s(%d:%d)" %
                (self.index, self.length, self.info, self.getSignalStrength(),
                 100.0 * self.info / self.total, self.filename, self.start+1, self.end))
        
    def __repr__(self):
        return "Chunk(%d, %d, %d, %d)" % (self.index, self.length, self.info, self.total) ##fix

    def getText(self):
        return self.text

    def getRange(self):
        return (self.start, self.end, self.filename)

    def getSignalStrength(self):
        return 100.0 * self.info / self.length


def addInfoToChunks(chunks):
    texts = [c.getText() for c in chunks]
    total = infoInChunks(texts, -1)
    for i in range(0, len(chunks)):
        ci = infoInChunks(texts, i)
        chunks[i].addInfo(i, total - ci, total)
    return total

def compareSignalStrength(x, y):
    xs, ys = x.getSignalStrength(), y.getSignalStrength()
    if xs < ys:
        return -1
    if xs > ys:
        return 1
    return 0


class Report:
    def __init__(self, start=0, end=10, percent=0):
        self.start = start
        self.end = end
        self.percent = percent

    def reportFile(self, filename):
        self.reportChunks(self.parseFile(filename))

    def reportFiles(self, filenames):
        chunks = []
        for filename in filenames:
            chunks += self.parseFile(filename)
        self.reportChunks(chunks)

    def reportChunks(self, chunks):
        total = addInfoToChunks(chunks)
        print "\nTotal info: ", total
        print "  #    len  info  signal   share    location"
        chunks.sort(compareSignalStrength)
        if self.percent > 0:
            start = 0
            end = self.firstSignalStrengthAbove(chunks)
        else:
            start = self.start
            end = self.end
            if end == 0:
                end = len(chunks)
        for chunk in chunks[start:end]:
            print chunk

    def firstSignalStrengthAbove(self, chunks):
        for i in range(len(chunks)):
            if chunks[i].getSignalStrength() > self.percent:
                return i
        return len(chunks)

    def parseFile(self, filename):
        f = open(filename)
        s = f.read()
        f.close()
        return self.parseChunks(s, filename)

    def parseChunks(self, s, filename=None):
        lines = s.split("\n")
        if lines[-1] == '':
            del(lines[-1])
    
        ends = []
        for i in range(1,len(lines)):
            if (lines[i]).strip()[:3] == "def":
                ends.append(i)
        ends.append(len(lines))
    
        r = []
        start = 0
        for end in ends:
            r.append(Chunk("\n".join(lines[start:end]) + "\n", start, end, filename))
            start = end
        return r


class Interface:
    def main(self, argv):
        limit, percent, filenames = self.parseArgs(argv[1:])
        r = Report(0, limit, percent)
        r.reportFiles(filenames)

    def parseArgs(self, args):
        limit = 10
        percent = 0
        filenames = []
        for a in args:
            if a[0] != "-":
                filenames.append(a)
            else:
                if a[1] in "0123456789":
                    if a[-1] == "%":
                        percent = int(a[1:-1])
                        limit = 0
                    else:
                        limit = int(a[1:])
                        percent = 0
                else:
                    if a[1:] == "all":
                        limit = 0
                        percent = 0
        return limit, percent, filenames


if __name__ == '__main__':
    import sys
    interface = Interface()
    interface.main(sys.argv)