'''This file summarizes the results from an extended noise test.
It uses the HTML report log generated at the end of the test as input.
It will output a summary in the same directory as the input report log,
as well as a graphic representation.

Usage: python noise_summary.py report.html
'''

from HTMLParser import HTMLParser
import matplotlib.pyplot as plt
import os.path
import re
import sys

# Constants
CORRECT_NUM_FINGERS = 1
CORRECT_MAX_DISTANCE = 1.0
FINGERS_INDEX = 0
DISTANCE_INDEX = 1


# A parser to consolidate the data in the html report
class ParseReport(HTMLParser):
    def __init__(self, num_iterations):
        HTMLParser.__init__(self)
        self.curr_freq = 0
        self.last_freq = self.curr_freq
        self.curr_dict_index = 0
        self.miscounted_fingers = 0
        self.over_distance = 0
        self.num_iterations = num_iterations
        self.data_dict_list = []

        for x in range(0, self.num_iterations):
            # Each dictionary in the list represents
            # one iteration of data
            self.data_dict_list.append({})

    # extracts the frequency from a line in the html report like this:
    #   noise_stationary_extended.
    #       ('0Hz', 'max_amplitude', 'square_wave', 'center')
    def _extract_frequency(self, data):
        return int(re.findall(r'\d+', data)[0])

    # extracts the tids from a line in the html report like this:
    #   count of trackid IDs: 1
    #   criteria: == 1
    def _extract_num_ids(self, data):
        return float(re.findall(r'\d+', data)[0])

    # extracts the distance from a line in the html report like this:
    #   Max distance slot0: 0.00 mm
    #   criteria: <= 1.0
    def _extract_distance(self, data):
        return float(re.findall(r'[-+]?\d*\.\d+|\d+', data)[0])

    # Add the value read to the dictionary.
    def _update_data_dict(self, value, val_index):
        curr_freq = self.curr_freq
        if curr_freq not in self.data_dict_list[self.curr_dict_index]:
            self.data_dict_list[self.curr_dict_index][curr_freq] = [None, None]

        self.data_dict_list[self.curr_dict_index][curr_freq][val_index] = value

    # Handler for HTMLParser for whenever it encounters text between tags
    def handle_data(self, data):
        # Get the current frequency
        if 'noise_stationary_extended' in data:
            self.curr_freq = self._extract_frequency(data)

            # Update the current iteration we're on.
            if self.curr_freq == self.last_freq:
                self.curr_dict_index = self.curr_dict_index + 1
            else:
                self.last_freq = self.curr_freq
                self.curr_dict_index = 0

        # Update number of fingers data
        if 'count of trackid IDs:' in data:
            num_ids = self._extract_num_ids(data)

            if num_ids != CORRECT_NUM_FINGERS:
                self.miscounted_fingers = self.miscounted_fingers + 1
                self._update_data_dict(num_ids, FINGERS_INDEX)
            else:
                self._update_data_dict(None, FINGERS_INDEX)

        # Update maximum distance data
        if 'Max distance' in data:
            distance = self._extract_distance(data)

            if distance > CORRECT_MAX_DISTANCE:
                self.over_distance = self.over_distance + 1
                self._update_data_dict(distance, DISTANCE_INDEX)
            else:
                self._update_data_dict(None, DISTANCE_INDEX)


# A parser to count the number of iterations
class CountIterations(ParseReport):
    def __init__(self):
        ParseReport.__init__(self, num_iterations=0)
        self.counting_iterations = True

    # Handler for HTMLParser for whenever it encounters text between tags
    def handle_data(self, data):
        # Get the current frequency
        if 'noise_stationary_extended' in data:
            self.curr_freq = self._extract_frequency(data)

            if self.counting_iterations:
                if self.curr_freq == self.last_freq:
                    self.num_iterations = self.num_iterations + 1
                else:
                    self.counting_iterations = False


# A weighting function to determine how badly
# a frequency failed. It outputs the total number
# of errors, where each misread or additionally read
# finger counts as one error, and each 0.2mm over the
# maximum distance counts as one error.
def weighting_function(data):
    num_fingers = data[FINGERS_INDEX]
    max_dist = data[DISTANCE_INDEX]

    if num_fingers is None:
        num_fingers = CORRECT_NUM_FINGERS
    if max_dist is None:
        max_dist = 0

    finger_val = abs(num_fingers - CORRECT_NUM_FINGERS)
    dist_val = 5 * (max_dist - CORRECT_MAX_DISTANCE)
    dist_val = 0 if dist_val < 0 else dist_val

    return finger_val + dist_val


# Returns a list of frequencies in order of how
# 'badly' they failed
def value_sorted_freq(data_dict):
    list_of_tuples = sorted(data_dict.iteritems(), reverse=True,
                            key=lambda (k, v): weighting_function(v))
    return [i[0] for i in list_of_tuples]


# Print out the summary of results for a single iteration,
# ordered by how badly each frequency failed.
def print_iteration_summary(data_dict, iteration, outfile):
    outfile.write('\n')
    outfile.write("Iteration %d\n" % iteration)
    outfile.write('-------------\n')

    for freq in value_sorted_freq(data_dict):
        num_fingers = data_dict[freq][FINGERS_INDEX]
        max_dist = data_dict[freq][DISTANCE_INDEX]

        # Don't output anything if there was no error
        if num_fingers is None and max_dist is None:
            continue
        else:
            num_fingers = '' if num_fingers is None else '%s tids' % num_fingers
            max_dist = '' if max_dist is None else '%s mm' % max_dist

        outfile.write('{:,}Hz \t %s \t %s \n'.format(freq) %
                     (num_fingers, max_dist))


# Print out a summary of errors for each iteration
def print_summary(parse_report, output_file):
    outfile = open(output_file, 'w')
    outfile.write('Summary: \n')
    outfile.write('    %d issues with finger tracking over all iterations. \n' %
                  parse_report.miscounted_fingers)
    outfile.write('    %d issues with distance over all iterations. \n' %
                  parse_report.over_distance)
    outfile.write('\n\n')

    outfile.write('Worst frequencies:\n')

    for iteration, data_dict in enumerate(parse_report.data_dict_list):
        print_iteration_summary(data_dict, iteration, outfile)

    outfile.close()


# For each iteration, generate a subplot
def show_graph(parse_report):
    for iteration, data_dict in enumerate(parse_report.data_dict_list):
        sorted_by_freq = sorted(parse_report.data_dict_list[iteration].items())
        frequencies = [i[0] for i in sorted_by_freq]
        values = [weighting_function(i[1]) for i in sorted_by_freq]

        plt.subplot(parse_report.num_iterations, 1, iteration)
        plt.plot(frequencies, values)

        plt.xlabel('Frequency (Hz)')
        plt.ylabel('Number of problems')
        plt.legend(("Iteration %d" % iteration,))

    plt.title('Graphic Summary of Extended Noise Test')
    plt.show()


def main():
    # Error checking
    if len(sys.argv) != 2:
        print 'Usage: python noise_summary.py report.html'
        return

    input_file = sys.argv[1]
    if '.html' not in input_file:
        print 'File must be an html firmware report.'
        print 'An example report name is:'
        print 'touch_firmware_report-swanky-fw_2.0-noise-20140826_173022.html'
        return

    # Create filepaths
    directory = os.path.dirname(input_file)
    output_file = '%s_summary.txt' % \
                  os.path.splitext(os.path.basename(input_file))[0]
    output_path = os.path.join(directory, output_file)

    try:
        html_file = open(input_file)
    except:
        print '%s could not be found.' % input_file
        return

    # Parse the report
    html = html_file.read()
    c = CountIterations()
    c.feed(html)
    p = ParseReport(c.num_iterations)
    p.feed(html)
    html_file.close()
    p.close()

    # Display the result
    print_summary(p, output_path)
    print 'The summary has been saved to %s' % output_path
    show_graph(p)


if __name__ == '__main__':
    main()