# Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

"""Touch firmware test report in html format."""

import os
import urllib

import common_util
import firmware_log
import test_conf as conf

from firmware_utils import get_fw_and_date
from string import Template
from validators import get_base_name_and_segment


class TemplateHtml:
    """An html Template."""

    def __init__(self, image_width, image_height, score_colors):
        self.score_colors = score_colors

        # Define the template of the doc
        self.doc = Template('$head $test_version $logs $tail')
        self.table = Template('<table border="3" width="100%"> $gestures '
                              '</table>')
        self.gestures = []

        # Define a template to show a gesture information including
        # the gesture name, variation, prompt, image, and test results.
        self.gesture_template = Template('''
            <tr>
                <td><table>
                    <tr>
                        <h3> $gesture_name.$variation </h3>
                        <h5> $prompt </h5>
                    </tr>
                    <tr>
                        <img src="data:image/png;base64,\n$image"
                            alt="$filename" width="%d" height="%d" />
                    </tr>
                </table></td>
                <td><table>
                    $vlogs
                </table></td>
            </tr>
        ''' % (image_width, image_height))

        self.criteria_string = '  criteria: %s'
        self.validator_template =  Template('''
            <tr>
<pre><span style="color:$color"><b>$name</b></span>
$details
$criteria
</pre>
            </tr>
        ''')

        self.detail_template =  Template('<tr><h5> $detail </h5></tr>')
        self._fill_doc()

    def _html_head(self):
        """Fill the head of an html document."""
        head = '\n'.join(['<!DOCTYPE html>', '<html>', '<body>'])
        return head

    def _html_tail(self):
        """Fill the tail of an html document."""
        tail = '\n'.join(['</body>', '</html>'])
        return tail

    def _fill_doc(self):
        """Fill in fields into the doc."""
        self.doc = Template(self.doc.safe_substitute(head=self._html_head(),
                                                     tail=self._html_tail()))

    def get_score_color(self, score):
        """Present the score in different colors."""
        for s, c in self.score_colors:
            if score >= s:
                return c

    def _insert_details(self, details):
        details_content = []
        for detail in details:
            details_content.append(' ' * 2 + detail.strip())
        return '<br>'.join(details_content)

    def _insert_vlog(self, vlog):
        """Insert a single vlog."""
        base_name, _ = get_base_name_and_segment(vlog.name)
        criteria_string = self.criteria_string % vlog.criteria
        vlog_content = self.validator_template.safe_substitute(
                name=vlog.name,
                details=self._insert_details(vlog.details),
                criteria=criteria_string,
                color='blue',
                score=vlog.score)
        return vlog_content

    def _insert_vlogs(self, vlogs):
        """Insert multiple vlogs."""
        vlogs_content = []
        for vlog in vlogs:
            vlogs_content.append(self._insert_vlog(vlog))
        return '<hr>'.join(vlogs_content)

    def insert_gesture(self, glog, image, image_filename):
        """Insert glog, image, and vlogs."""
        vlogs_content = self._insert_vlogs(glog.vlogs)
        gesture = self.gesture_template.safe_substitute(
                gesture_name=glog.name,
                variation=glog.variation,
                prompt=glog.prompt,
                image=image,
                filename=image_filename,
                vlogs=vlogs_content)
        self.gestures.append(gesture)

    def get_doc(self, test_version):
        gestures = ''.join(self.gestures)
        new_table = self.table.safe_substitute(gestures=gestures)
        new_doc = self.doc.safe_substitute(test_version=test_version,
                                           logs=new_table)
        return new_doc


class ReportHtml:
    """Firmware Report in html format."""

    def __init__(self, filename, screen_size, touch_device_window_size,
                 score_colors, test_version):
        self.html_filename = filename
        self.screen_size = screen_size
        self.image_width = self.screen_size[0] * 0.5
        touch_width, touch_height = touch_device_window_size
        self.image_height = self.image_width / touch_width * touch_height
        self.doc = TemplateHtml(self.image_width, self.image_height,
                                score_colors)
        self._reset_content()
        self.test_version = test_version
        fw_and_date = get_fw_and_date(filename)
        self.rlog = firmware_log.RoundLog(test_version, *fw_and_date)

    def __del__(self):
        self.stop()

    def stop(self):
        """Close the file."""
        with open(self.html_filename, 'w') as report_file:
            report_file.write(self.doc.get_doc(self.test_version))
        # Make a copy to /tmp so that it could be viewed in Chrome.
        tmp_copy = os.path.join(conf.docroot,
                                os.path.basename(self.html_filename))
        copy_cmd = 'cp %s %s' % (self.html_filename, tmp_copy)
        common_util.simple_system(copy_cmd)

        # Dump the logs to a byte stream file
        log_file_root = os.path.splitext(self.html_filename)[0]
        log_filename = os.extsep.join([log_file_root, 'log'])
        self.rlog.dump(log_filename)

    def _reset_content(self):
        self.glog = firmware_log.GestureLog()
        self.encoded_image=''
        self.image_filename=''

    def _get_content(self):
        return [self.glog, self.encoded_image, self.image_filename]

    def _encode_base64(self, filename):
        """Encode a file in base 64 format."""
        if (filename is None) or (not os.path.isfile(filename)):
            return None
        encoded = urllib.quote(open(filename, "rb").read().encode("base64"))
        return encoded

    def flush(self):
        """Flush the current gesture including gesture log, image and
        validator logs.
        """
        content = self._get_content()
        # It is ok to flush the gesture log even when there are no mtplot images
        if self.glog:
            # Write the content to the html file.
            self.doc.insert_gesture(*content)
            # Write the logs to the round log.
            self.rlog.insert_glog(self.glog)
            self._reset_content()

    def insert_image(self, filename):
        """Insert an image into the document."""
        self.encoded_image = self._encode_base64(filename)
        self.image_filename = filename

    def insert_result(self, text):
        """Insert the text into the document."""
        self.result += text

    def insert_gesture_log(self, glog):
        """Update the gesture log."""
        self.glog = glog

    def insert_validator_logs(self, vlogs):
        """Update the validator logs."""
        self.glog.vlogs = vlogs