import sys

def is_diff(i_a, i_b):
    if sorted(i_a.keys()) != sorted(i_b.keys()):
        return False
    for k in sorted(i_a.keys()):
        if k in ['lr', 'vt', 'func']:
            continue
        if i_a[k] != i_b[k]:
            return True
    return False


def get_str(k, v):
    if k in ['buffer_entry_sizes', 'buffers']:
        return '[%s]' % ', '.join('0x%X' % x for x in v)
    elif k in ['inbytes', 'outbytes']:
        return '0x%X' % v
    else:
        return str(v)

def summary(cmd):
    s = ''
    for k in sorted(cmd.keys()):
        if k in ['lr', 'vt', 'func']:
            continue
        if s:
            s += ', '
        s += k
        s += ': '
        s += get_str(k, cmd[k])
    return s


def summary_diff(a, b):
    s = ''
    assert sorted(a.keys()) == sorted(b.keys())
    for k in sorted(a.keys()):
        if k in ['lr', 'vt', 'func']:
            continue
        if a[k] != b[k]:
            if s:
                s += ', '
            s += k
            s += ': '
            s += get_str(k, a[k]) + ' -> ' + get_str(k, b[k])
    s += ' (final state: %s)' % summary(b)
    return s


def diff_p(a, b):
    a_p = a.keys()
    b_p = b.keys()
    a_only = sorted([p for p in a_p if p not in b_p])
    b_only = sorted([p for p in b_p if p not in a_p])
    both_p = sorted([p for p in set(a_p + b_p) if p in a_p and p in b_p])
    for p in a_only:
        print 'Process Removed: %s' % p
    for p in b_only:
        print 'Process Added: %s' % p
    a_i = {}
    a_x = {}
    b_i = {}
    b_x = {}
    for p in a_p:
        p_i = a[p]
        for n in p_i.keys():
            target = a_i if not n.startswith('0x') else a_x
            #print n
            assert n not in target or sorted(target[n].keys()) == sorted(p_i[n].keys())
            target[n] = p_i[n]
    for p in b_p:
        p_i = b[p]
        for n in p_i.keys():
            target = b_i if not n.startswith('0x') else b_x
            assert n not in target or sorted(target[n].keys()) == sorted(p_i[n].keys())
            target[n] = p_i[n]
    a_only = sorted([p for p in a_i.keys() if p not in b_i.keys()])
    b_only = sorted([p for p in b_i.keys() if p not in a_i.keys()])
    both_p = sorted([p for p in set(a_i.keys() + b_i.keys()) if p in a_i.keys() and p in b_i.keys()])
    for p in a_only:
        print 'Interface Removed: %s' % p
    for p in b_only:
        print 'Interface Added: %s' % p
    for n in sorted(both_p):
        i_a = a_i[n]
        i_b = b_i[n]
        a_only = sorted([p for p in i_a.keys() if p not in i_b.keys()])
        b_only = sorted([p for p in i_b.keys() if p not in i_a.keys()])
        both_p = sorted([p for p in set(i_a.keys() + i_b.keys()) if p in i_a.keys() and p in i_b.keys()])
        changed = sorted([p for p in both_p if is_diff(i_a[p], i_b[p])])
        if len(a_only + b_only + changed) > 0:
            print 'Interface Changed: %s' % n
            for c in sorted(set(a_only + b_only + changed)):
                if c in a_only:
                    print '    Removed: %5d - %s' % (c, summary(i_a[c]))
                if c in b_only:
                    print '    Added:   %5d - %s' % (c, summary(i_b[c]))
                if c in changed:
                    print '    Changed: %5d - %s' % (c, summary_diff(i_a[c], i_b[c]))

def load_intf(fn):
    with open(fn, 'r') as f:
        return eval('{'+f.read()+'}')

def main(argc, argv):
    before = load_intf(argv[1])
    after = load_intf(argv[2])
    diff_p(before, after)
    return 0

if __name__ == '__main__':
    sys.exit(main(len(sys.argv), sys.argv))