# Copyright (c) 2023 Cisco and/or its affiliates.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at:
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""Algorithms to generate plots.
"""


import re
import logging

from collections import OrderedDict
from datetime import datetime
from copy import deepcopy
from math import log

import hdrh.histogram
import hdrh.codec
import pandas as pd
import plotly.offline as ploff
import plotly.graph_objs as plgo
import plotly.exceptions as plerr

from plotly.exceptions import PlotlyError

from pal_utils import mean, stdev


COLORS = (
    u"#1A1110",
    u"#DA2647",
    u"#214FC6",
    u"#01786F",
    u"#BD8260",
    u"#FFD12A",
    u"#A6E7FF",
    u"#738276",
    u"#C95A49",
    u"#FC5A8D",
    u"#CEC8EF",
    u"#391285",
    u"#6F2DA8",
    u"#FF878D",
    u"#45A27D",
    u"#FFD0B9",
    u"#FD5240",
    u"#DB91EF",
    u"#44D7A8",
    u"#4F86F7",
    u"#84DE02",
    u"#FFCFF1",
    u"#614051"
)

REGEX_NIC = re.compile(r'(\d*ge\dp\d\D*\d*[a-z]*)-')

# This value depends on latency stream rate (9001 pps) and duration (5s).
# Keep it slightly higher to ensure rounding errors to not remove tick mark.
PERCENTILE_MAX = 99.999501


def generate_plots(spec, data):
    """Generate all plots specified in the specification file.

    :param spec: Specification read from the specification file.
    :param data: Data to process.
    :type spec: Specification
    :type data: InputData
    """

    generator = {
        u"plot_nf_reconf_box_name": plot_nf_reconf_box_name,
        u"plot_perf_box_name": plot_perf_box_name,
        u"plot_tsa_name": plot_tsa_name,
        u"plot_http_server_perf_box": plot_http_server_perf_box,
        u"plot_nf_heatmap": plot_nf_heatmap,
        u"plot_hdrh_lat_by_percentile": plot_hdrh_lat_by_percentile,
        u"plot_hdrh_lat_by_percentile_x_log": plot_hdrh_lat_by_percentile_x_log,
        u"plot_mrr_box_name": plot_mrr_box_name,
        u"plot_ndrpdr_box_name": plot_ndrpdr_box_name,
        u"plot_statistics": plot_statistics
    }

    logging.info(u"Generating the plots ...")
    for index, plot in enumerate(spec.plots):
        try:
            logging.info(f"  Plot nr {index + 1}: {plot.get(u'title', u'')}")
            plot[u"limits"] = spec.environment[u"limits"]
            generator[plot[u"algorithm"]](plot, data)
            logging.info(u"  Done.")
        except NameError as err:
            logging.error(
                f"Probably algorithm {plot[u'algorithm']} is not defined: "
                f"{repr(err)}"
            )
    logging.info(u"Done.")


def plot_statistics(plot, input_data):
    """Generate the plot(s) with algorithm: plot_statistics
    specified in the specification file.

    :param plot: Plot to generate.
    :param input_data: Data to process.
    :type plot: pandas.Series
    :type input_data: InputData
    """

    data_x = list()
    data_y_pass = list()
    data_y_fail = list()
    data_y_duration = list()
    hover_text = list()
    hover_str = (
        u"date: {date}<br>"
        u"passed: {passed}<br>"
        u"failed: {failed}<br>"
        u"duration: {duration}<br>"
        u"{sut}-ref: {build}<br>"
        u"csit-ref: {test}-{period}-build-{build_nr}<br>"
        u"testbed: {testbed}"
    )
    for job, builds in plot[u"data"].items():
        for build_nr in builds:
            try:
                meta = input_data.metadata(job, str(build_nr))
                generated = meta[u"generated"]
                date = datetime(
                    int(generated[0:4]),
                    int(generated[4:6]),
                    int(generated[6:8]),
                    int(generated[9:11]),
                    int(generated[12:])
                )
                d_y_pass = meta[u"tests_passed"]
                d_y_fail = meta[u"tests_failed"]
                minutes = meta[u"elapsedtime"] // 60000
                duration = f"{(minutes // 60):02d}:{(minutes % 60):02d}"
                version = meta.get(u"version", u"")
            except (KeyError, IndexError, ValueError, AttributeError):
                continue
            data_x.append(date)
            data_y_pass.append(d_y_pass)
            data_y_fail.append(d_y_fail)
            data_y_duration.append(minutes)
            if u"vpp" in job:
                sut = u"vpp"
            elif u"dpdk" in job:
                sut = u"dpdk"
            elif u"trex" in job:
                sut = u"trex"
            else:
                sut = u""
            hover_text.append(hover_str.format(
                date=date,
                passed=d_y_pass,
                failed=d_y_fail,
                duration=duration,
                sut=sut,
                build=version,
                test=u"mrr" if u"mrr" in job else u"ndrpdr",
                period=u"daily" if u"daily" in job else u"weekly",
                build_nr=build_nr,
                testbed=meta.get(u"testbed", u"")
            ))

    traces = [
        plgo.Bar(
            x=data_x,
            y=data_y_pass,
            name=u"Passed",
            text=hover_text,
            hoverinfo=u"text"
        ),
        plgo.Bar(
            x=data_x,
            y=data_y_fail,
            name=u"Failed",
            text=hover_text,
            hoverinfo=u"text"),
        plgo.Scatter(
            x=data_x,
            y=data_y_duration,
            name=u"Duration",
            yaxis=u"y2",
            text=hover_text,
            hoverinfo=u"text"
        )
    ]

    name_file = f"{plot[u'output-file']}.html"

    logging.info(f"    Writing the file {name_file}")
    plpl = plgo.Figure(data=traces, layout=plot[u"layout"])
    tickvals = [0, (max(data_y_duration) // 60) * 60]
    step = tickvals[1] / 5
    for i in range(5):
        tickvals.append(int(tickvals[0] + step * (i + 1)))
    plpl.update_layout(
        yaxis2=dict(
            title=u"Duration [hh:mm]",
            anchor=u"x",
            overlaying=u"y",
            side=u"right",
            rangemode="tozero",
            tickmode=u"array",
            tickvals=tickvals,
            ticktext=[f"{(val // 60):02d}:{(val % 60):02d}" for val in tickvals]
        )
    )
    plpl.update_layout(barmode=u"stack")
    try:
        ploff.plot(
            plpl,
            show_link=False,
            auto_open=False,
            filename=name_file
        )
    except plerr.PlotlyEmptyDataError:
        logging.warning(u"No data for the plot. Skipped.")


def plot_hdrh_lat_by_percentile(plot, input_data):
    """Generate the plot(s) with algorithm: plot_hdrh_lat_by_percentile
    specified in the specification file.

    :param plot: Plot to generate.
    :param input_data: Data to process.
    :type plot: pandas.Series
    :type input_data: InputData
    """

    # Transform the data
    logging.info(
        f"    Creating the data set for the {plot.get(u'type', u'')} "
        f"{plot.get(u'title', u'')}."
    )
    if plot.get(u"include", None):
        data = input_data.filter_tests_by_name(
            plot,
            params=[u"name", u"latency", u"parent", u"tags", u"type"]
        )[0][0]
    elif plot.get(u"filter", None):
        data = input_data.filter_data(
            plot,
            params=[u"name", u"latency", u"parent", u"tags", u"type"],
            continue_on_error=True
        )[0][0]
    else:
        job = list(plot[u"data"].keys())[0]
        build = str(plot[u"data"][job][0])
        data = input_data.tests(job, build)

    if data is None or len(data) == 0:
        logging.error(u"No data.")
        return

    desc = {
        u"LAT0": u"No-load.",
        u"PDR10": u"Low-load, 10% PDR.",
        u"PDR50": u"Mid-load, 50% PDR.",
        u"PDR90": u"High-load, 90% PDR.",
        u"PDR": u"Full-load, 100% PDR.",
        u"NDR10": u"Low-load, 10% NDR.",
        u"NDR50": u"Mid-load, 50% NDR.",
        u"NDR90": u"High-load, 90% NDR.",
        u"NDR": u"Full-load, 100% NDR."
    }

    graphs = [
        u"LAT0",
        u"PDR10",
        u"PDR50",
        u"PDR90"
    ]

    file_links = plot.get(u"output-file-links", None)
    target_links = plot.get(u"target-links", None)

    for test in data:
        try:
            if test[u"type"] not in (u"NDRPDR",):
                logging.warning(f"Invalid test type: {test[u'type']}")
                continue
            name = re.sub(REGEX_NIC, u"", test[u"parent"].
                          replace(u'-ndrpdr', u'').replace(u'2n1l-', u''))
            try:
                nic = re.search(REGEX_NIC, test[u"parent"]).group(1)
            except (IndexError, AttributeError, KeyError, ValueError):
                nic = u""
            name_link = f"{nic}-{test[u'name']}".replace(u'-ndrpdr', u'')

            logging.info(f"    Generating the graph: {name_link}")

            fig = plgo.Figure()
            layout = deepcopy(plot[u"layout"])

            for color, graph in enumerate(graphs):
                for idx, direction in enumerate((u"direction1", u"direction2")):
                    previous_x = 0.0
                    xaxis = list()
                    yaxis = list()
                    hovertext = list()
                    try:
                        decoded = hdrh.histogram.HdrHistogram.decode(
                            test[u"latency"][graph][direction][u"hdrh"]
                        )
                    except hdrh.codec.HdrLengthException:
                        logging.warning(
                            f"No data for direction {(u'W-E', u'E-W')[idx % 2]}"
                        )
                        continue

                    for item in decoded.get_recorded_iterator():
                        percentile = item.percentile_level_iterated_to
                        xaxis.append(previous_x)
                        yaxis.append(item.value_iterated_to)
                        hovertext.append(
                            f"<b>{desc[graph]}</b><br>"
                            f"Direction: {(u'W-E', u'E-W')[idx % 2]}<br>"
                            f"Percentile: "
                            f"{previous_x:.5f}-{percentile:.5f}%<br>"
                            f"Latency: {item.value_iterated_to}uSec"
                        )
                        xaxis.append(percentile)
                        yaxis.append(item.value_iterated_to)
                        hovertext.append(
                            f"<b>{desc[graph]}</b><br>"
                            f"Direction: {(u'W-E', u'E-W')[idx % 2]}<br>"
                            f"Percentile: "
                            f"{previous_x:.5f}-{percentile:.5f}%<br>"
                            f"Latency: {item.value_iterated_to}uSec"
                        )
                        previous_x = percentile
                    fig.add_trace(
                        plgo.Scatter(
                            x=xaxis,
                            y=yaxis,
                            name=desc[graph],
                            mode=u"lines",
                            legendgroup=desc[graph],
                            showlegend=bool(idx),
                            line=dict(
                                color=COLORS[color],
                                dash=u"solid",
                                width=1 if idx % 2 else 2
                            ),
                            hovertext=hovertext,
                            hoverinfo=u"text"
                        )
                    )

            layout[u"title"][u"text"] = f"<b>Latency:</b> {name}"
            fig.update_layout(layout)

            # Create plot
            file_name = f"{plot[u'output-file']}-{name_link}.html"
            logging.info(f"    Writing file {file_name}")

            try:
                # Export Plot
                ploff.plot(fig, show_link=False, auto_open=False,
                           filename=file_name)
                # Add link to the file:
                if file_links and target_links:
                    with open(file_links, u"a") as file_handler:
                        file_handler.write(
                            f"- `{name_link} "
                            f"<{target_links}/{file_name.split(u'/')[-1]}>`_\n"
                        )
            except FileNotFoundError as err:
                logging.error(
                    f"Not possible to write the link to the file "
                    f"{file_links}\n{err}"
                )
            except PlotlyError as err:
                logging.error(f"   Finished with error: {repr(err)}")

        except hdrh.codec.HdrLengthException as err:
            logging.warning(repr(err))
            continue

        except (ValueError, KeyError) as err:
            logging.warning(repr(err))
            continue


def plot_hdrh_lat_by_percentile_x_log(plot, input_data):
    """Generate the plot(s) with algorithm: plot_hdrh_lat_by_percentile_x_log
    specified in the specification file.

    :param plot: Plot to generate.
    :param input_data: Data to process.
    :type plot: pandas.Series
    :type input_data: InputData
    """

    # Transform the data
    logging.info(
        f"    Creating the data set for the {plot.get(u'type', u'')} "
        f"{plot.get(u'title', u'')}."
    )
    if plot.get(u"include", None):
        data = input_data.filter_tests_by_name(
            plot,
            params=[u"name", u"latency", u"parent", u"tags", u"type"]
        )[0][0]
    elif plot.get(u"filter", None):
        data = input_data.filter_data(
            plot,
            params=[u"name", u"latency", u"parent", u"tags", u"type"],
            continue_on_error=True
        )[0][0]
    else:
        job = list(plot[u"data"].keys())[0]
        build = str(plot[u"data"][job][0])
        data = input_data.tests(job, build)

    if data is None or len(data) == 0:
        logging.error(u"No data.")
        return

    desc = {
        u"LAT0": u"No-load.",
        u"PDR10": u"Low-load, 10% PDR.",
        u"PDR50": u"Mid-load, 50% PDR.",
        u"PDR90": u"High-load, 90% PDR.",
        u"PDR": u"Full-load, 100% PDR.",
        u"NDR10": u"Low-load, 10% NDR.",
        u"NDR50": u"Mid-load, 50% NDR.",
        u"NDR90": u"High-load, 90% NDR.",
        u"NDR": u"Full-load, 100% NDR."
    }

    graphs = [
        u"LAT0",
        u"PDR10",
        u"PDR50",
        u"PDR90"
    ]

    file_links = plot.get(u"output-file-links", None)
    target_links = plot.get(u"target-links", None)

    for test in data:
        try:
            if test[u"type"] not in (u"NDRPDR",):
                logging.warning(f"Invalid test type: {test[u'type']}")
                continue
            name = re.sub(REGEX_NIC, u"", test[u"parent"].
                          replace(u'-ndrpdr', u'').replace(u'2n1l-', u''))
            try:
                nic = re.search(REGEX_NIC, test[u"parent"]).group(1)
            except (IndexError, AttributeError, KeyError, ValueError):
                nic = u""
            name_link = f"{nic}-{test[u'name']}".replace(u'-ndrpdr', u'')

            logging.info(f"    Generating the graph: {name_link}")

            fig = plgo.Figure()
            layout = deepcopy(plot[u"layout"])

            for color, graph in enumerate(graphs):
                for idx, direction in enumerate((u"direction1", u"direction2")):
                    previous_x = 0.0
                    prev_perc = 0.0
                    xaxis = list()
                    yaxis = list()
                    hovertext = list()
                    try:
                        decoded = hdrh.histogram.HdrHistogram.decode(
                            test[u"latency"][graph][direction][u"hdrh"]
                        )
                    except (hdrh.codec.HdrLengthException, TypeError):
                        logging.warning(
                            f"No data for direction {(u'W-E', u'E-W')[idx % 2]}"
                        )
                        continue

                    for item in decoded.get_recorded_iterator():
                        # The real value is "percentile".
                        # For 100%, we cut that down to "x_perc" to avoid
                        # infinity.
                        percentile = item.percentile_level_iterated_to
                        x_perc = min(percentile, PERCENTILE_MAX)
                        xaxis.append(previous_x)
                        yaxis.append(item.value_iterated_to)
                        hovertext.append(
                            f"<b>{desc[graph]}</b><br>"
                            f"Direction: {(u'W-E', u'E-W')[idx % 2]}<br>"
                            f"Percentile: {prev_perc:.5f}-{percentile:.5f}%<br>"
                            f"Latency: {item.value_iterated_to}uSec"
                        )
                        next_x = 100.0 / (100.0 - x_perc)
                        xaxis.append(next_x)
                        yaxis.append(item.value_iterated_to)
                        hovertext.append(
                            f"<b>{desc[graph]}</b><br>"
                            f"Direction: {(u'W-E', u'E-W')[idx % 2]}<br>"
                            f"Percentile: {prev_perc:.5f}-{percentile:.5f}%<br>"
                            f"Latency: {item.value_iterated_to}uSec"
                        )
                        previous_x = next_x
                        prev_perc = percentile
                    fig.add_trace(
                        plgo.Scatter(
                            x=xaxis,
                            y=yaxis,
                            name=desc[graph],
                            mode=u"lines",
                            legendgroup=desc[graph],
                            showlegend=not(bool(idx)),
                            line=dict(
                                color=COLORS[color],
                                dash=u"solid",
                                width=1 if idx % 2 else 2
                            ),
                            hovertext=hovertext,
                            hoverinfo=u"text"
                        )
                    )

            layout[u"title"][u"text"] = f"<b>Latency:</b> {name}"
            x_max = log(100.0 / (100.0 - PERCENTILE_MAX), 10)
            layout[u"xaxis"][u"range"] = [0, x_max]
            fig.update_layout(layout)

            # Create plot
            file_name = f"{plot[u'output-file']}-{name_link}.html"
            logging.info(f"    Writing file {file_name}")

            try:
                # Export Plot
                ploff.plot(fig, show_link=False, auto_open=False,
                           filename=file_name)
                # Add link to the file:
                if file_links and target_links:
                    with open(file_links, u"a") as file_handler:
                        file_handler.write(
                            f"- `{name_link} "
                            f"<{target_links}/{file_name.split(u'/')[-1]}>`_\n"
                        )
            except FileNotFoundError as err:
                logging.error(
                    f"Not possible to write the link to the file "
                    f"{file_links}\n{err}"
                )
            except PlotlyError as err:
                logging.error(f"   Finished with error: {repr(err)}")

        except hdrh.codec.HdrLengthException as err:
            logging.warning(repr(err))
            continue

        except (ValueError, KeyError) as err:
            logging.warning(repr(err))
            continue


def plot_nf_reconf_box_name(plot, input_data):
    """Generate the plot(s) with algorithm: plot_nf_reconf_box_name
    specified in the specification file.

    :param plot: Plot to generate.
    :param input_data: Data to process.
    :type plot: pandas.Series
    :type input_data: InputData
    """

    # Transform the data
    logging.info(
        f"    Creating the data set for the {plot.get(u'type', u'')} "
        f"{plot.get(u'title', u'')}."
    )
    data = input_data.filter_tests_by_name(
        plot, params=[u"result", u"parent", u"tags", u"type"]
    )
    if data is None:
        logging.error(u"No data.")
        return

    for core in plot.get(u"core", tuple()):
        # Prepare the data for the plot
        y_vals = OrderedDict()
        loss = dict()
        for item in plot.get(u"include", tuple()):
            reg_ex = re.compile(str(item.format(core=core)).lower())
            for job in data:
                for build in job:
                    for test_id, test in build.iteritems():
                        if not re.match(reg_ex, str(test_id).lower()):
                            continue
                        if y_vals.get(test[u"parent"], None) is None:
                            y_vals[test[u"parent"]] = list()
                            loss[test[u"parent"]] = list()
                        try:
                            y_vals[test[u"parent"]].append(
                                test[u"result"][u"time"]
                            )
                            loss[test[u"parent"]].append(
                                test[u"result"][u"loss"]
                            )
                        except (KeyError, TypeError):
                            y_vals[test[u"parent"]].append(None)

        # Add None to the lists with missing data
        max_len = 0
        nr_of_samples = list()
        for val in y_vals.values():
            if len(val) > max_len:
                max_len = len(val)
            nr_of_samples.append(len(val))
        for val in y_vals.values():
            if len(val) < max_len:
                val.extend([None for _ in range(max_len - len(val))])

        # Add plot traces
        traces = list()
        df_y = pd.DataFrame(y_vals)
        df_y.head()
        for i, col in enumerate(df_y.columns):
            tst_name = re.sub(
                REGEX_NIC, u"",
                col.lower().replace(u'-reconf', u'').replace(u'2n1l-', u'').
                replace(u'2n-', u'').replace(u'-testpmd', u'')
            )
            traces.append(plgo.Box(
                x=[str(i + 1) + u'.'] * len(df_y[col]),
                y=df_y[col],
                name=(
                    f"{i + 1}. "
                    f"({nr_of_samples[i]:02d} "
                    f"run{u's' if nr_of_samples[i] > 1 else u''}, "
                    f"packets lost average: {mean(loss[col]):.1f}) "
                    f"{u'-'.join(tst_name.split(u'-')[2:])}"
                ),
                hoverinfo=u"y+name"
            ))
        try:
            # Create plot
            layout = deepcopy(plot[u"layout"])
            layout[u"title"] = f"<b>Time Lost:</b> {layout[u'title']}"
            layout[u"yaxis"][u"title"] = u"<b>Effective Blocked Time [s]</b>"
            layout[u"legend"][u"font"][u"size"] = 14
            layout[u"yaxis"].pop(u"range")
            plpl = plgo.Figure(data=traces, layout=layout)

            # Export Plot
            file_name = f"{plot[u'output-file'].format(core=core)}.html"
            logging.info(f"    Writing file {file_name}")
            ploff.plot(
                plpl,
                show_link=False,
                auto_open=False,
                filename=file_name
            )
        except PlotlyError as err:
            logging.error(
                f"   Finished with error: {repr(err)}".replace(u"\n", u" ")
            )


def plot_perf_box_name(plot, input_data):
    """Generate the plot(s) with algorithm: plot_perf_box_name
    specified in the specification file.

    Use only for soak and hoststack tests.

    :param plot: Plot to generate.
    :param input_data: Data to process.
    :type plot: pandas.Series
    :type input_data: InputData
    """

    # Transform the data
    logging.info(
        f"    Creating data set for the {plot.get(u'type', u'')} "
        f"{plot.get(u'title', u'')}."
    )
    data = input_data.filter_tests_by_name(
        plot,
        params=[u"throughput", u"gbps", u"result", u"parent", u"tags", u"type"])
    if data is None:
        logging.error(u"No data.")
        return

    # Prepare the data for the plot
    y_vals = OrderedDict()
    test_type = u""

    for item in plot.get(u"include", tuple()):
        reg_ex = re.compile(str(item).lower())
        for job in data:
            for build in job:
                for test_id, test in build.iteritems():
                    if not re.match(reg_ex, str(test_id).lower()):
                        continue
                    if y_vals.get(test[u"parent"], None) is None:
                        y_vals[test[u"parent"]] = list()
                    try:
                        if test[u"type"] in (u"SOAK",):
                            y_vals[test[u"parent"]]. \
                                append(test[u"throughput"][u"LOWER"])
                            test_type = u"SOAK"

                        elif test[u"type"] in (u"HOSTSTACK",):
                            if u"LDPRELOAD" in test[u"tags"]:
                                y_vals[test[u"parent"]].append(
                                    float(
                                        test[u"result"][u"bits_per_second"]
                                    ) / 1e3
                                )
                            elif u"VPPECHO" in test[u"tags"]:
                                y_vals[test[u"parent"]].append(
                                    (float(
                                        test[u"result"][u"client"][u"tx_data"]
                                    ) * 8 / 1e3) /
                                    ((float(
                                        test[u"result"][u"client"][u"time"]
                                    ) +
                                      float(
                                          test[u"result"][u"server"][u"time"])
                                      ) / 2)
                                )
                            test_type = u"HOSTSTACK"

                        elif test[u"type"] in (u"LDP_NGINX",):
                            if u"TCP_CPS" in test[u"tags"]:
                                test_type = u"VSAP_CPS"
                                y_vals[test[u"parent"]].append(
                                    test[u"result"][u"cps"]
                                )
                            elif u"TCP_RPS" in test[u"tags"]:
                                test_type = u"VSAP_RPS"
                                y_vals[test[u"parent"]].append(
                                    test[u"result"][u"rps"]
                                )
                            else:
                                continue
                        else:
                            continue

                    except (KeyError, TypeError):
                        y_vals[test[u"parent"]].append(None)

    # Add None to the lists with missing data
    max_len = 0
    nr_of_samples = list()
    for val in y_vals.values():
        if len(val) > max_len:
            max_len = len(val)
        nr_of_samples.append(len(val))
    for val in y_vals.values():
        if len(val) < max_len:
            val.extend([None for _ in range(max_len - len(val))])

    # Add plot traces
    traces = list()
    df_y = pd.DataFrame(y_vals)
    df_y.head()
    y_max = list()
    for i, col in enumerate(df_y.columns):
        tst_name = re.sub(REGEX_NIC, u"",
                          col.lower().replace(u'-ndrpdr', u'').
                          replace(u'2n1l-', u''))
        if test_type in (u"VSAP_CPS", u"VSAP_RPS"):
            data_y = [y if y else None for y in df_y[col]]
        else:
            data_y = [y / 1e6 if y else None for y in df_y[col]]
        kwargs = dict(
            y=data_y,
            name=(
                f"{i + 1}. "
                f"({nr_of_samples[i]:02d} "
                f"run{u's' if nr_of_samples[i] > 1 else u''}) "
                f"{tst_name}"
            ),
            hoverinfo=u"y+name"
        )
        if test_type in (u"SOAK", ):
            kwargs[u"boxpoints"] = u"all"
            kwargs[u"jitter"] = 0.3

        traces.append(plgo.Box(**kwargs))

        try:
            val_max = max(df_y[col])
            if val_max:
                y_max.append(int(val_max / 1e6))
        except (ValueError, TypeError) as err:
            logging.error(repr(err))
            continue

    try:
        # Create plot
        layout = deepcopy(plot[u"layout"])
        layout[u"xaxis"][u"tickvals"] = [i for i in range(len(y_vals))]
        layout[u"xaxis"][u"ticktext"] = [str(i + 1) for i in range(len(y_vals))]
        if layout.get(u"title", None):
            if test_type in (u"HOSTSTACK", ):
                layout[u"title"] = f"<b>Bandwidth:</b> {layout[u'title']}"
            elif test_type == u"VSAP_CPS":
                layout[u"title"] = f"<b>CPS:</b> {layout[u'title']}"
                layout[u"yaxis"][u"title"] = u"<b>Connection Rate [cps]</b>"
            elif test_type == u"VSAP_RPS":
                layout[u"title"] = f"<b>RPS:</b> {layout[u'title']}"
                layout[u"yaxis"][u"title"] = u"<b>Connection Rate [rps]</b>"
            else:
                layout[u"title"] = f"<b>Tput:</b> {layout[u'title']}"
        if y_max and max(y_max) > 1:
            layout[u"yaxis"][u"range"] = [0, max(y_max) + 2]
        plpl = plgo.Figure(data=traces, layout=layout)

        # Export Plot
        logging.info(f"    Writing file {plot[u'output-file']}.html.")
        ploff.plot(
            plpl,
            show_link=False,
            auto_open=False,
            filename=f"{plot[u'output-file']}.html"
        )
    except PlotlyError as err:
        logging.error(
            f"   Finished with error: {repr(err)}".replace(u"\n", u" ")
        )
        return


def plot_ndrpdr_box_name(plot, input_data):
    """Generate the plot(s) with algorithm: plot_ndrpdr_box_name
    specified in the specification file.

    :param plot: Plot to generate.
    :param input_data: Data to process.
    :type plot: pandas.Series
    :type input_data: InputData
    """

    # Transform the data
    logging.info(
        f"    Creating data set for the {plot.get(u'type', u'')} "
        f"{plot.get(u'title', u'')}."
    )
    data = input_data.filter_tests_by_name(
        plot,
        params=[u"throughput", u"gbps", u"parent", u"tags", u"type"]
    )
    if data is None:
        logging.error(u"No data.")
        return

    if u"-gbps" in plot.get(u"title", u"").lower():
        value = u"gbps"
        multiplier = 1e6
    else:
        value = u"throughput"
        multiplier = 1.0

    test_type = u""

    for ttype in plot.get(u"test-type", (u"ndr", u"pdr")):
        for core in plot.get(u"core", tuple()):
            # Prepare the data for the plot
            data_x = list()
            data_y = OrderedDict()
            data_y_max = list()
            idx = 1
            for item in plot.get(u"include", tuple()):
                reg_ex = re.compile(str(item.format(core=core)).lower())
                for job in data:
                    for build in job:
                        for test_id, test in build.iteritems():
                            if not re.match(reg_ex, str(test_id).lower()):
                                continue
                            if data_y.get(test[u"parent"], None) is None:
                                data_y[test[u"parent"]] = list()
                                test_type = test[u"type"]
                                data_x.append(idx)
                                idx += 1
                            try:
                                data_y[test[u"parent"]].append(
                                    test[value][ttype.upper()][u"LOWER"] *
                                    multiplier
                                )
                            except (KeyError, TypeError):
                                pass

            # Add plot traces
            traces = list()
            for idx, (key, vals) in enumerate(data_y.items()):
                name = re.sub(
                    REGEX_NIC, u'', key.lower().replace(u'-ndrpdr', u'').
                    replace(u'2n1l-', u'')
                )
                kwargs = dict(
                    y=[y / 1e6 if y else None for y in vals],
                    name=(
                        f"{idx + 1}."
                        f"({len(vals):02d} "
                        f"run"
                        f"{u's' if len(vals) > 1 else u''}) "
                        f"{name}"
                    ),
                    hoverinfo=u"y+name"
                )
                box_points = plot.get(u"boxpoints", u"all")
                if box_points in \
                        (u"all", u"outliers", u"suspectedoutliers", False):
                    kwargs[u"boxpoints"] = box_points
                    kwargs[u"jitter"] = 0.3
                traces.append(plgo.Box(**kwargs))
                try:
                    data_y_max.append(max(vals))
                except ValueError as err:
                    logging.warning(f"No values to use.\n{err!r}")
            try:
                # Create plot
                layout = deepcopy(plot[u"layout"])
                layout[u"xaxis"][u"tickvals"] = [i for i in range(len(data_y))]
                layout[u"xaxis"][u"ticktext"] = \
                    [str(i + 1) for i in range(len(data_y))]
                if layout.get(u"title", None):
                    layout[u"title"] = \
                        layout[u'title'].format(core=core, test_type=ttype)
                    if test_type in (u"CPS", ):
                        layout[u"title"] = f"<b>CPS:</b> {layout[u'title']}"
                    else:
                        layout[u"title"] = \
                            f"<b>Tput:</b> {layout[u'title']}"
                if data_y_max:
                    layout[u"yaxis"][u"range"] = [0, max(data_y_max) / 1e6 + 1]
                plpl = plgo.Figure(data=traces, layout=layout)

                # Export Plot
                file_name = (
                    f"{plot[u'output-file'].format(core=core, test_type=ttype)}"
                    f".html"
                )
                logging.info(f"    Writing file {file_name}")
                ploff.plot(
                    plpl,
                    show_link=False,
                    auto_open=False,
                    filename=file_name
                )
            except PlotlyError as err:
                logging.error(
                    f"   Finished with error: {repr(err)}".replace(u"\n", u" ")
                )


def plot_mrr_box_name(plot, input_data):
    """Generate the plot(s) with algorithm: plot_mrr_box_name
    specified in the specification file.

    :param plot: Plot to generate.
    :param input_data: Data to process.
    :type plot: pandas.Series
    :type input_data: InputData
    """

    # Transform the data
    logging.info(
        f"    Creating data set for the {plot.get(u'type', u'')} "
        f"{plot.get(u'title', u'')}."
    )
    data = input_data.filter_tests_by_name(
        plot,
        params=[u"result", u"parent", u"tags", u"type"]
    )
    if data is None:
        logging.error(u"No data.")
        return

    for core in plot.get(u"core", tuple()):
        # Prepare the data for the plot
        data_x = list()
        data_names = list()
        data_y = list()
        data_y_max = list()
        idx = 1
        for item in plot.get(u"include", tuple()):
            reg_ex = re.compile(str(item.format(core=core)).lower())
            for job in data:
                for build in job:
                    for test_id, test in build.iteritems():
                        if not re.match(reg_ex, str(test_id).lower()):
                            continue
                        try:
                            data_x.append(idx)
                            name = re.sub(
                                REGEX_NIC, u'', test[u'parent'].lower().
                                replace(u'-mrr', u'').replace(u'2n1l-', u'')
                            )
                            data_y.append(test[u"result"][u"samples"])
                            data_names.append(
                                f"{idx}."
                                f"({len(data_y[-1]):02d} "
                                f"run{u's' if len(data_y[-1]) > 1 else u''}) "
                                f"{name}"
                            )
                            data_y_max.append(max(data_y[-1]))
                            idx += 1
                        except (KeyError, TypeError):
                            pass

        # Add plot traces
        traces = list()
        for idx, x_item in enumerate(data_x):
            kwargs = dict(
                y=data_y[idx],
                name=data_names[idx],
                hoverinfo=u"y+name"
            )
            box_points = plot.get(u"boxpoints", u"all")
            if box_points in (u"all", u"outliers", u"suspectedoutliers", False):
                kwargs[u"boxpoints"] = box_points
                kwargs["jitter"] = 0.3
            traces.append(plgo.Box(**kwargs))

        try:
            # Create plot
            layout = deepcopy(plot[u"layout"])
            layout[u"xaxis"][u"tickvals"] = [i for i in range(len(data_y))]
            layout[u"xaxis"][u"ticktext"] = \
                [str(i + 1) for i in range(len(data_y))]
            if layout.get(u"title", None):
                layout[u"title"] = (
                    f"<b>Tput:</b> {layout[u'title'].format(core=core)}"
                )
            if data_y_max:
                layout[u"yaxis"][u"range"] = [0, max(data_y_max) + 1]
            plpl = plgo.Figure(data=traces, layout=layout)

            # Export Plot
            file_name = f"{plot[u'output-file'].format(core=core)}.html"
            logging.info(f"    Writing file {file_name}")
            ploff.plot(
                plpl,
                show_link=False,
                auto_open=False,
                filename=file_name
            )
        except PlotlyError as err:
            logging.error(
                f"   Finished with error: {repr(err)}".replace(u"\n", u" ")
            )


def plot_tsa_name(plot, input_data):
    """Generate the plot(s) with algorithm:
    plot_tsa_name
    specified in the specification file.

    :param plot: Plot to generate.
    :param input_data: Data to process.
    :type plot: pandas.Series
    :type input_data: InputData
    """

    # Transform the data
    plot_title = plot.get(u"title", u"")
    logging.info(
        f"    Creating data set for the {plot.get(u'type', u'')} {plot_title}."
    )
    data = input_data.filter_tests_by_name(
        plot,
        params=[u"throughput", u"gbps", u"parent", u"tags", u"type"]
    )
    if data is None:
        logging.error(u"No data.")
        return

    plot_title = plot_title.lower()

    if u"-gbps" in plot_title:
        value = u"gbps"
        h_unit = u"Gbps"
        multiplier = 1e6
    else:
        value = u"throughput"
        h_unit = u"Mpps"
        multiplier = 1.0

    for ttype in plot.get(u"test-type", (u"ndr", u"pdr")):
        y_vals = OrderedDict()
        for item in plot.get(u"include", tuple()):
            reg_ex = re.compile(str(item).lower())
            for job in data:
                for build in job:
                    for test_id, test in build.iteritems():
                        if re.match(reg_ex, str(test_id).lower()):
                            if y_vals.get(test[u"parent"], None) is None:
                                y_vals[test[u"parent"]] = {
                                    u"1": list(),
                                    u"2": list(),
                                    u"4": list()
                                }
                            try:
                                if test[u"type"] not in (u"NDRPDR", u"CPS"):
                                    continue

                                if u"1C" in test[u"tags"]:
                                    y_vals[test[u"parent"]][u"1"].append(
                                        test[value][ttype.upper()][u"LOWER"] *
                                        multiplier
                                    )
                                elif u"2C" in test[u"tags"]:
                                    y_vals[test[u"parent"]][u"2"].append(
                                        test[value][ttype.upper()][u"LOWER"] *
                                        multiplier
                                    )
                                elif u"4C" in test[u"tags"]:
                                    y_vals[test[u"parent"]][u"4"].append(
                                        test[value][ttype.upper()][u"LOWER"] *
                                        multiplier
                                    )
                            except (KeyError, TypeError):
                                pass

        if not y_vals:
            logging.warning(f"No data for the plot {plot.get(u'title', u'')}")
            return

        y_1c_max = dict()
        for test_name, test_vals in y_vals.items():
            for key, test_val in test_vals.items():
                if test_val:
                    avg_val = sum(test_val) / len(test_val)
                    y_vals[test_name][key] = [avg_val, len(test_val)]
                    ideal = avg_val / (int(key) * 1e6)
                    if test_name not in y_1c_max or ideal > y_1c_max[test_name]:
                        y_1c_max[test_name] = ideal

        vals = OrderedDict()
        y_max = list()
        nic_limit = 0
        lnk_limit = 0
        pci_limit = 0
        for test_name, test_vals in y_vals.items():
            try:
                if test_vals[u"1"][1]:
                    name = re.sub(
                        REGEX_NIC,
                        u"",
                        test_name.replace(u'-ndrpdr', u'').
                        replace(u'2n1l-', u'')
                    )
                    vals[name] = OrderedDict()
                    y_val_1 = test_vals[u"1"][0] / 1e6
                    y_val_2 = test_vals[u"2"][0] / 1e6 if test_vals[u"2"][0] \
                        else None
                    y_val_4 = test_vals[u"4"][0] / 1e6 if test_vals[u"4"][0] \
                        else None

                    vals[name][u"val"] = [y_val_1, y_val_2, y_val_4]
                    vals[name][u"rel"] = [1.0, None, None]
                    vals[name][u"ideal"] = [
                        y_1c_max[test_name],
                        y_1c_max[test_name] * 2,
                        y_1c_max[test_name] * 4
                    ]
                    vals[name][u"diff"] = [
                        (y_val_1 - y_1c_max[test_name]) * 100 / y_val_1,
                        None,
                        None
                    ]
                    vals[name][u"count"] = [
                        test_vals[u"1"][1],
                        test_vals[u"2"][1],
                        test_vals[u"4"][1]
                    ]

                    try:
                        val_max = max(vals[name][u"val"])
                    except ValueError as err:
                        logging.error(repr(err))
                        continue
                    if val_max:
                        y_max.append(val_max)

                    if y_val_2:
                        vals[name][u"rel"][1] = round(y_val_2 / y_val_1, 2)
                        vals[name][u"diff"][1] = \
                            (y_val_2 - vals[name][u"ideal"][1]) * 100 / y_val_2
                    if y_val_4:
                        vals[name][u"rel"][2] = round(y_val_4 / y_val_1, 2)
                        vals[name][u"diff"][2] = \
                            (y_val_4 - vals[name][u"ideal"][2]) * 100 / y_val_4
            except IndexError as err:
                logging.warning(f"No data for {test_name}")
                logging.warning(repr(err))

            # Limits:
            if u"x520" in test_name:
                limit = plot[u"limits"][u"nic"][u"x520"]
            elif u"x710" in test_name:
                limit = plot[u"limits"][u"nic"][u"x710"]
            elif u"xxv710" in test_name:
                limit = plot[u"limits"][u"nic"][u"xxv710"]
            elif u"xl710" in test_name:
                limit = plot[u"limits"][u"nic"][u"xl710"]
            elif u"x553" in test_name:
                limit = plot[u"limits"][u"nic"][u"x553"]
            elif u"cx556a" in test_name:
                limit = plot[u"limits"][u"nic"][u"cx556a"]
            elif u"e810cq" in test_name:
                limit = plot[u"limits"][u"nic"][u"e810cq"]
            elif u"e810xxv" in test_name:
                limit = plot[u"limits"][u"nic"][u"e810xxv"]
            elif u"e822cq" in test_name:
                limit = plot[u"limits"][u"nic"][u"e822cq"]
            else:
                limit = 0
            if limit > nic_limit:
                nic_limit = limit

            mul = 2 if u"ge2p" in test_name else 1
            if u"10ge" in test_name:
                limit = plot[u"limits"][u"link"][u"10ge"] * mul
            elif u"25ge" in test_name:
                limit = plot[u"limits"][u"link"][u"25ge"] * mul
            elif u"40ge" in test_name:
                limit = plot[u"limits"][u"link"][u"40ge"] * mul
            elif u"100ge" in test_name:
                limit = plot[u"limits"][u"link"][u"100ge"] * mul
            else:
                limit = 0
            if limit > lnk_limit:
                lnk_limit = limit

            if u"cx556a" in test_name:
                limit = plot[u"limits"][u"pci"][u"pci-g3-x8"]
            else:
                limit = plot[u"limits"][u"pci"][u"pci-g3-x16"]
            if limit > pci_limit:
                pci_limit = limit

        traces = list()
        annotations = list()
        x_vals = [1, 2, 4]

        # Limits:
        if u"-gbps" not in plot_title and u"-cps-" not in plot_title:
            nic_limit /= 1e6
            lnk_limit /= 1e6
            pci_limit /= 1e6
            min_limit = min((nic_limit, lnk_limit, pci_limit))
            if nic_limit == min_limit:
                traces.append(plgo.Scatter(
                    x=x_vals,
                    y=[nic_limit, ] * len(x_vals),
                    name=f"NIC: {nic_limit:.2f}Mpps",
                    showlegend=False,
                    mode=u"lines",
                    line=dict(
                        dash=u"dot",
                        color=COLORS[-1],
                        width=1),
                    hoverinfo=u"none"
                ))
                annotations.append(dict(
                    x=1,
                    y=nic_limit,
                    xref=u"x",
                    yref=u"y",
                    xanchor=u"left",
                    yanchor=u"bottom",
                    text=f"NIC: {nic_limit:.2f}Mpps",
                    font=dict(
                        size=14,
                        color=COLORS[-1],
                    ),
                    align=u"left",
                    showarrow=False
                ))
                y_max.append(nic_limit)
            elif lnk_limit == min_limit:
                traces.append(plgo.Scatter(
                    x=x_vals,
                    y=[lnk_limit, ] * len(x_vals),
                    name=f"Link: {lnk_limit:.2f}Mpps",
                    showlegend=False,
                    mode=u"lines",
                    line=dict(
                        dash=u"dot",
                        color=COLORS[-1],
                        width=1),
                    hoverinfo=u"none"
                ))
                annotations.append(dict(
                    x=1,
                    y=lnk_limit,
                    xref=u"x",
                    yref=u"y",
                    xanchor=u"left",
                    yanchor=u"bottom",
                    text=f"Link: {lnk_limit:.2f}Mpps",
                    font=dict(
                        size=14,
                        color=COLORS[-1],
                    ),
                    align=u"left",
                    showarrow=False
                ))
                y_max.append(lnk_limit)
            elif pci_limit == min_limit:
                traces.append(plgo.Scatter(
                    x=x_vals,
                    y=[pci_limit, ] * len(x_vals),
                    name=f"PCIe: {pci_limit:.2f}Mpps",
                    showlegend=False,
                    mode=u"lines",
                    line=dict(
                        dash=u"dot",
                        color=COLORS[-1],
                        width=1),
                    hoverinfo=u"none"
                ))
                annotations.append(dict(
                    x=1,
                    y=pci_limit,
                    xref=u"x",
                    yref=u"y",
                    xanchor=u"left",
                    yanchor=u"bottom",
                    text=f"PCIe: {pci_limit:.2f}Mpps",
                    font=dict(
                        size=14,
                        color=COLORS[-1],
                    ),
                    align=u"left",
                    showarrow=False
                ))
                y_max.append(pci_limit)

        # Perfect and measured:
        cidx = 0
        for name, val in vals.items():
            hovertext = list()
            try:
                for idx in range(len(val[u"val"])):
                    htext = ""
                    if isinstance(val[u"val"][idx], float):
                        htext += (
                            f"No. of Runs: {val[u'count'][idx]}<br>"
                            f"Mean: {val[u'val'][idx]:.2f}{h_unit}<br>"
                        )
                    if isinstance(val[u"diff"][idx], float):
                        htext += f"Diff: {round(val[u'diff'][idx]):.0f}%<br>"
                    if isinstance(val[u"rel"][idx], float):
                        htext += f"Speedup: {val[u'rel'][idx]:.2f}"
                    hovertext.append(htext)
                traces.append(
                    plgo.Scatter(
                        x=x_vals,
                        y=val[u"val"],
                        name=name,
                        legendgroup=name,
                        mode=u"lines+markers",
                        line=dict(
                            color=COLORS[cidx],
                            width=2),
                        marker=dict(
                            symbol=u"circle",
                            size=10
                        ),
                        text=hovertext,
                        hoverinfo=u"text+name"
                    )
                )
                traces.append(
                    plgo.Scatter(
                        x=x_vals,
                        y=val[u"ideal"],
                        name=f"{name} perfect",
                        legendgroup=name,
                        showlegend=False,
                        mode=u"lines",
                        line=dict(
                            color=COLORS[cidx],
                            width=2,
                            dash=u"dash"),
                        text=[f"Perfect: {y:.2f}Mpps" for y in val[u"ideal"]],
                        hoverinfo=u"text"
                    )
                )
                cidx += 1
            except (IndexError, ValueError, KeyError) as err:
                logging.warning(f"No data for {name}\n{repr(err)}")

        try:
            # Create plot
            file_name = f"{plot[u'output-file'].format(test_type=ttype)}.html"
            logging.info(f"    Writing file {file_name}")
            layout = deepcopy(plot[u"layout"])
            if layout.get(u"title", None):
                layout[u"title"] = (
                    f"<b>Speedup Multi-core:</b> "
                    f"{layout[u'title'].format(test_type=ttype)}"
                )
            layout[u"yaxis"][u"range"] = [0, int(max(y_max) * 1.1)]
            layout[u"annotations"].extend(annotations)
            plpl = plgo.Figure(data=traces, layout=layout)

            # Export Plot
            ploff.plot(
                plpl,
                show_link=False,
                auto_open=False,
                filename=file_name
            )
        except PlotlyError as err:
            logging.error(
                f"   Finished with error: {repr(err)}".replace(u"\n", u" ")
            )


def plot_http_server_perf_box(plot, input_data):
    """Generate the plot(s) with algorithm: plot_http_server_perf_box
    specified in the specification file.

    :param plot: Plot to generate.
    :param input_data: Data to process.
    :type plot: pandas.Series
    :type input_data: InputData
    """

    # Transform the data
    logging.info(
        f"    Creating the data set for the {plot.get(u'type', u'')} "
        f"{plot.get(u'title', u'')}."
    )
    data = input_data.filter_data(plot)
    if data is None:
        logging.error(u"No data.")
        return

    # Prepare the data for the plot
    y_vals = dict()
    for job in data:
        for build in job:
            for test in build:
                if y_vals.get(test[u"name"], None) is None:
                    y_vals[test[u"name"]] = list()
                try:
                    y_vals[test[u"name"]].append(test[u"result"])
                except (KeyError, TypeError):
                    y_vals[test[u"name"]].append(None)

    # Add None to the lists with missing data
    max_len = 0
    nr_of_samples = list()
    for val in y_vals.values():
        if len(val) > max_len:
            max_len = len(val)
        nr_of_samples.append(len(val))
    for val in y_vals.values():
        if len(val) < max_len:
            val.extend([None for _ in range(max_len - len(val))])

    # Add plot traces
    traces = list()
    df_y = pd.DataFrame(y_vals)
    df_y.head()
    for i, col in enumerate(df_y.columns):
        name = \
            f"{i + 1}. " \
            f"({nr_of_samples[i]:02d} " \
            f"run{u's' if nr_of_samples[i] > 1 else u''}) " \
            f"{col.lower().replace(u'-ndrpdr', u'')}"
        if len(name) > 50:
            name_lst = name.split(u'-')
            name = u""
            split_name = True
            for segment in name_lst:
                if (len(name) + len(segment) + 1) > 50 and split_name:
                    name += u"<br>    "
                    split_name = False
                name += segment + u'-'
            name = name[:-1]

        traces.append(plgo.Box(x=[str(i + 1) + u'.'] * len(df_y[col]),
                               y=df_y[col],
                               name=name,
                               **plot[u"traces"]))
    try:
        # Create plot
        plpl = plgo.Figure(data=traces, layout=plot[u"layout"])

        # Export Plot
        logging.info(
            f"    Writing file {plot[u'output-file']}"
            f"{plot[u'output-file-type']}."
        )
        ploff.plot(
            plpl,
            show_link=False,
            auto_open=False,
            filename=f"{plot[u'output-file']}{plot[u'output-file-type']}"
        )
    except PlotlyError as err:
        logging.error(
            f"   Finished with error: {repr(err)}".replace(u"\n", u" ")
        )
        return


def plot_nf_heatmap(plot, input_data):
    """Generate the plot(s) with algorithm: plot_nf_heatmap
    specified in the specification file.

    :param plot: Plot to generate.
    :param input_data: Data to process.
    :type plot: pandas.Series
    :type input_data: InputData
    """

    def sort_by_int(value):
        """Makes possible to sort a list of strings which represent integers.

        :param value: Integer as a string.
        :type value: str
        :returns: Integer representation of input parameter 'value'.
        :rtype: int
        """
        return int(value)

    regex_cn = re.compile(r'^(\d*)R(\d*)C$')
    regex_test_name = re.compile(r'^.*-(\d+ch|\d+pl)-'
                                 r'(\d+mif|\d+vh)-'
                                 r'(\d+vm\d+t|\d+dcr\d+t|\d+dcr\d+c).*$')
    # Transform the data
    logging.info(
        f"    Creating the data set for the {plot.get(u'type', u'')} "
        f"{plot.get(u'title', u'')}."
    )
    in_data = input_data.filter_tests_by_name(
        plot,
        continue_on_error=True,
        params=[u"throughput", u"result", u"name", u"tags", u"type"]
    )
    if in_data is None or in_data.empty:
        logging.error(u"No data.")
        return

    for ttype in plot.get(u"test-type", (u"ndr", u"pdr")):
        for core in plot.get(u"core", tuple()):
            vals = dict()
            for item in plot.get(u"include", tuple()):
                reg_ex = re.compile(str(item.format(core=core)).lower())
                for job in in_data:
                    for build in job:
                        for test_id, test in build.iteritems():
                            if not re.match(reg_ex, str(test_id).lower()):
                                continue
                            for tag in test[u"tags"]:
                                groups = re.search(regex_cn, tag)
                                if groups:
                                    chain = str(groups.group(1))
                                    node = str(groups.group(2))
                                    break
                            else:
                                continue
                            groups = re.search(regex_test_name, test[u"name"])
                            if groups and len(groups.groups()) == 3:
                                hover_name = (
                                    f"{str(groups.group(1))}-"
                                    f"{str(groups.group(2))}-"
                                    f"{str(groups.group(3))}"
                                )
                            else:
                                hover_name = u""
                            if vals.get(chain, None) is None:
                                vals[chain] = dict()
                            if vals[chain].get(node, None) is None:
                                vals[chain][node] = dict(
                                    name=hover_name,
                                    vals=list(),
                                    nr=None,
                                    mean=None,
                                    stdev=None
                                )
                            try:
                                if ttype == u"mrr":
                                    result = test[u"result"][u"receive-rate"]
                                elif ttype == u"pdr":
                                    result = \
                                        test[u"throughput"][u"PDR"][u"LOWER"]
                                elif ttype == u"ndr":
                                    result = \
                                        test[u"throughput"][u"NDR"][u"LOWER"]
                                else:
                                    result = None
                            except TypeError:
                                result = None

                            if result:
                                vals[chain][node][u"vals"].append(result)

            if not vals:
                logging.error(u"No data.")
                return

            txt_chains = list()
            txt_nodes = list()
            for key_c in vals:
                txt_chains.append(key_c)
                for key_n in vals[key_c].keys():
                    txt_nodes.append(key_n)
                    if vals[key_c][key_n][u"vals"]:
                        vals[key_c][key_n][u"nr"] = \
                            len(vals[key_c][key_n][u"vals"])
                        vals[key_c][key_n][u"mean"] = \
                            round(mean(vals[key_c][key_n][u"vals"]) / 1e6, 1)
                        vals[key_c][key_n][u"stdev"] = \
                            round(stdev(vals[key_c][key_n][u"vals"]) / 1e6, 1)
            txt_nodes = list(set(txt_nodes))

            txt_chains = sorted(txt_chains, key=sort_by_int)
            txt_nodes = sorted(txt_nodes, key=sort_by_int)

            chains = [i + 1 for i in range(len(txt_chains))]
            nodes = [i + 1 for i in range(len(txt_nodes))]

            data = [list() for _ in range(len(chains))]
            for chain in chains:
                for node in nodes:
                    try:
                        val = vals[txt_chains[chain - 1]] \
                            [txt_nodes[node - 1]][u"mean"]
                    except (KeyError, IndexError):
                        val = None
                    data[chain - 1].append(val)

            # Color scales:
            my_green = [[0.0, u"rgb(235, 249, 242)"],
                        [1.0, u"rgb(45, 134, 89)"]]

            my_blue = [[0.0, u"rgb(236, 242, 248)"],
                       [1.0, u"rgb(57, 115, 172)"]]

            my_grey = [[0.0, u"rgb(230, 230, 230)"],
                       [1.0, u"rgb(102, 102, 102)"]]

            hovertext = list()
            annotations = list()

            text = (u"Test: {name}<br>"
                    u"Runs: {nr}<br>"
                    u"Thput: {val}<br>"
                    u"StDev: {stdev}")

            for chain, _ in enumerate(txt_chains):
                hover_line = list()
                for node, _ in enumerate(txt_nodes):
                    if data[chain][node] is not None:
                        annotations.append(
                            dict(
                                x=node+1,
                                y=chain+1,
                                xref=u"x",
                                yref=u"y",
                                xanchor=u"center",
                                yanchor=u"middle",
                                text=str(data[chain][node]),
                                font=dict(
                                    size=14,
                                ),
                                align=u"center",
                                showarrow=False
                            )
                        )
                        hover_line.append(text.format(
                            name=vals[txt_chains[chain]][txt_nodes[node]]
                            [u"name"],
                            nr=vals[txt_chains[chain]][txt_nodes[node]][u"nr"],
                            val=data[chain][node],
                            stdev=vals[txt_chains[chain]][txt_nodes[node]]
                            [u"stdev"]
                        ))
                hovertext.append(hover_line)

            traces = [
                plgo.Heatmap(
                    x=nodes,
                    y=chains,
                    z=data,
                    colorbar=dict(
                        title=plot.get(u"z-axis", u"{test_type}").
                        format(test_type=ttype.upper()),
                        titleside=u"right",
                        titlefont=dict(
                            size=16
                        ),
                        tickfont=dict(
                            size=16,
                        ),
                        tickformat=u".1f",
                        yanchor=u"bottom",
                        y=-0.02,
                        len=0.925,
                    ),
                    showscale=True,
                    colorscale=my_green,
                    text=hovertext,
                    hoverinfo=u"text"
                )
            ]

            for idx, item in enumerate(txt_nodes):
                # X-axis, numbers:
                annotations.append(
                    dict(
                        x=idx+1,
                        y=0.05,
                        xref=u"x",
                        yref=u"y",
                        xanchor=u"center",
                        yanchor=u"top",
                        text=item,
                        font=dict(
                            size=16,
                        ),
                        align=u"center",
                        showarrow=False
                    )
                )
            for idx, item in enumerate(txt_chains):
                # Y-axis, numbers:
                annotations.append(
                    dict(
                        x=0.35,
                        y=idx+1,
                        xref=u"x",
                        yref=u"y",
                        xanchor=u"right",
                        yanchor=u"middle",
                        text=item,
                        font=dict(
                            size=16,
                        ),
                        align=u"center",
                        showarrow=False
                    )
                )
            # X-axis, title:
            annotations.append(
                dict(
                    x=0.55,
                    y=-0.15,
                    xref=u"paper",
                    yref=u"y",
                    xanchor=u"center",
                    yanchor=u"bottom",
                    text=plot.get(u"x-axis", u""),
                    font=dict(
                        size=16,
                    ),
                    align=u"center",
                    showarrow=False
                )
            )
            # Y-axis, title:
            annotations.append(
                dict(
                    x=-0.1,
                    y=0.5,
                    xref=u"x",
                    yref=u"paper",
                    xanchor=u"center",
                    yanchor=u"middle",
                    text=plot.get(u"y-axis", u""),
                    font=dict(
                        size=16,
                    ),
                    align=u"center",
                    textangle=270,
                    showarrow=False
                )
            )
            updatemenus = list([
                dict(
                    x=1.0,
                    y=0.0,
                    xanchor=u"right",
                    yanchor=u"bottom",
                    direction=u"up",
                    buttons=list([
                        dict(
                            args=[
                                {
                                    u"colorscale": [my_green, ],
                                    u"reversescale": False
                                }
                            ],
                            label=u"Green",
                            method=u"update"
                        ),
                        dict(
                            args=[
                                {
                                    u"colorscale": [my_blue, ],
                                    u"reversescale": False
                                }
                            ],
                            label=u"Blue",
                            method=u"update"
                        ),
                        dict(
                            args=[
                                {
                                    u"colorscale": [my_grey, ],
                                    u"reversescale": False
                                }
                            ],
                            label=u"Grey",
                            method=u"update"
                        )
                    ])
                )
            ])

            try:
                layout = deepcopy(plot[u"layout"])
            except KeyError as err:
                logging.error(
                    f"Finished with error: No layout defined\n{repr(err)}"
                )
                return

            layout[u"annotations"] = annotations
            layout[u'updatemenus'] = updatemenus
            if layout.get(u"title", None):
                layout[u"title"] = layout[u'title'].replace(u"test_type", ttype)

            try:
                # Create plot
                plpl = plgo.Figure(data=traces, layout=layout)

                # Export Plot
                file_name = (
                    f"{plot[u'output-file'].format(core=core, test_type=ttype)}"
                    f".html"
                )
                logging.info(f"    Writing file {file_name}")
                ploff.plot(
                    plpl,
                    show_link=False,
                    auto_open=False,
                    filename=file_name
                )
            except PlotlyError as err:
                logging.error(
                    f"   Finished with error: {repr(err)}".replace(u"\n", u" ")
                )