#!/usr/bin/env python

from getopt import getopt, GetoptError
import re
import sys, os
import subprocess

def usage():
    USAGE = """\
Usage: %(progName)s <before> <after>

Options:
  -h, --help                Show this message
"""
    print(USAGE % {'progName': sys.argv[0]})
    sys.exit(1)

def get_results(filename, all_result_types):
    file = open(filename, "r")
    lines = file.read().split('\n')

    results = {}

    for line in lines:
        m = re.match('SHADER-DB: (\S+): (\S+) prog (\S+): (\d+) (.+)', line)
        if m == None:
            continue

        groups = m.groups()

        progname = groups[0]
        shadertype = groups[1]
        shadernumber = groups[2]
        result_type = groups[4]
        progtuple = (progname, shadertype, shadernumber, result_type)
        results[progtuple] = int(groups[3])

        all_result_types.add(result_type)

    return results

def get_delta(b, a):
    if b != 0 and a != 0:
        frac = float(a) / float(b) - 1.0
        return ' ({:.2f}%)'.format(frac * 100.0)
    else:
        return ''

def change(b, a):
    return str(b) + " -> " + str(a) + get_delta(b, a)

def get_result_string(p, b, a):
    p = p + ": "
    while len(p) < 50:
        p = p + ' '
    return p + change(b, a)

def main():
    try:
        option_list = [
            "help",
            ]
        options, args = getopt(sys.argv[1:], "h", option_list)
    except GetoptError:
        usage()

    for name, value in options:
        if name in ('-h', '--help'):
            usage()

    if len(args) != 2:
        usage()

    all_result_types = set()

    before = get_results(args[0], all_result_types)
    after = get_results(args[1], all_result_types)

    total_before = {}
    total_after = {}
    affected_before = {}
    affected_after = {}

    for t in all_result_types:
        total_before[t] = 0
        total_after[t] = 0
        affected_before[t] = 0
        affected_after[t] = 0

    helped = []
    hurt = []
    lost = []
    gained = []
    for p in before:
        (progname, shadertype, shadernumber, result_type) = p
        namestr = '{} {} {} {}'.format(progname, shadertype, shadernumber, result_type)
        before_count = before[p]

        if after.get(p) != None:
            after_count = after[p]

            total_before[result_type] += before_count
            total_after[result_type] += after_count

            if before_count != after_count:
                affected_before[result_type] += before_count
                affected_after[result_type] += after_count

                result = get_result_string(namestr, before_count, after_count)
                if after_count > before_count:
                    hurt.append(p)
                else:
                    helped.append(result)
        else:
            lost.append(namestr)

    for p in after:
        if (before.get(p) == None):
            gained.append(p[0] + " " + p[1])

    helped.sort()
    for r in helped:
        print("helped: " + r)
    if len(helped) > 0:
        print("")

    hurt.sort(key=lambda k: float(after[k] - before[k]) / max(before[k], 1))
    for p in hurt:
        (progname, shadertype, shadernumber, result_type) = p
        namestr = '{} {} {} {}'.format(progname, shadertype, shadernumber, result_type)
        print("HURT:   " + get_result_string(namestr, before[p], after[p]))
    if len(hurt) > 0:
        print("")

    lost.sort()
    for p in lost:
        print("LOST:   " + p)
    if len(lost) > 0:
        print("")

    gained.sort()
    for p in gained:
        print("GAINED: " + p)
    if len(gained) > 0:
        print("")

    for t in all_result_types:
        print("total {} in shared programs: {}".format(t, change(total_before[t], total_after[t])))
        print("{} in affected programs:     {}".format(t, change(affected_before[t], affected_after[t])))
    print("GAINED:                                {0}".format(len(gained)))
    print("LOST:                                  {0}".format(len(lost)))
if __name__ == "__main__":
	main()