# Copyright 2020 The ChromiumOS Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

"""Objects for describing template code to be generated from structured.xml."""

import hashlib
import os
import re
import struct


class Util:
    """Helpers for generating C++."""

    @staticmethod
    def sanitize_name(name):
        return re.sub("[^0-9a-zA-Z_]", "_", name)

    @staticmethod
    def camel_to_snake(name):
        pat = "((?<=[a-z0-9])[A-Z]|(?!^)[A-Z](?=[a-z]))"
        return re.sub(pat, r"_\1", name).lower()

    @staticmethod
    def hash_name(name):
        # This must match the hash function in chromium's
        # //metrics/uploader/metric_hashes.cc. >Q means 8 bytes, big endian.
        name = name.encode("utf-8")
        md5 = hashlib.md5(name)
        return struct.unpack(">Q", md5.digest()[:8])[0]

    @staticmethod
    def event_name_hash(project_name, event_name):
        """Make the name hash for an event.

        This gets uploaded in the StructuredEventProto.event_name_hash field. It
        is the sole means of recording which event from structured.xml a
        StructuredEventProto instance represents.

        To avoid naming collisions, it must contain three pieces of information:
         - the name of the event itself
         - the name of the event's project, to avoid collisions with events of
           the same name in other projects
         - an identifier that this comes from chromeos, to avoid collisions with
           events and projects of the same name defined in chromiumos's
           structured.xml

        This must use sanitized names for the project and event.
        """
        event_name = Util.sanitize_name(event_name)
        project_name = Util.sanitize_name(project_name)
        return Util.hash_name(f"cros::{project_name}::{event_name}")


class FileInfo:
    """Codegen-related info about a file."""

    def __init__(self, dirname, basename):
        self.dirname = dirname
        self.basename = basename
        self.filepath = os.path.join(dirname, basename)

        # This takes the last three components of the filepath for use in the
        # header guard, ie. METRICS_STRUCTURED_STRUCTURED_EVENTS_H_
        relative_path = os.sep.join(self.filepath.split(os.sep)[-3:])
        self.guard_path = Util.sanitize_name(relative_path).upper()


class ProjectInfo:
    """Codegen-related info about a project."""

    def __init__(self, project):
        self.raw_name = project.name
        self.name = Util.sanitize_name(project.name)
        self.namespace = Util.camel_to_snake(self.name)
        self.name_hash = Util.hash_name(self.name)
        self.is_event_sequence = project.is_event_sequence_project

        # Set ID Type.
        if project.id == "uma":
            self.id_type = "kUmaId"
        elif project.id == "per-project":
            self.id_type = "kProjectId"
        elif project.id == "none":
            self.id_type = "kUnidentified"

        # Set the event type.
        if self.is_event_sequence:
            self.event_type = "SEQUENCE"
        else:
            # Set event type. This is inferred by checking all metrics within
            # the project. If any of a project's metrics is a raw string, then
            # it's events are considered raw string events, even if they also
            # contain non-strings.
            self.event_type = "REGULAR"
            for event in project.events:
                for metric in event.metrics:
                    if metric.type == "raw-string":
                        self.event_type = "RAW_STRING"
                        break


class EventInfo:
    """Codegen-related info about an event."""

    def __init__(self, event, project_info):
        self.raw_name = event.name
        self.name = Util.sanitize_name(event.name)
        self.name_hash = Util.event_name_hash(project_info.name, self.name)


class MetricInfo:
    """Codegen-related info about a metric."""

    def __init__(self, metric):
        self.raw_name = metric.name
        self.name = Util.sanitize_name(metric.name)
        self.hash = Util.hash_name(metric.name)
        self.type_name = metric.type

        if metric.type == "hmac-string":
            self.setter_type = "std::string&"
            self.setter = "AddHmacMetric"
            self.getter_type = "std::string"
            self.getter = "GetHmacMetricForTest"
            self.arg_parser = "ParseStringStructuredMetricsArg"
        elif metric.type == "int":
            self.setter_type = "int64_t"
            self.setter = "AddIntMetric"
            self.getter_type = "int64_t"
            self.getter = "GetIntMetricForTest"
            self.arg_parser = "ParseIntStructuredMetricsArg"
        elif metric.type == "raw-string":
            self.setter_type = "std::string&"
            self.setter = "AddRawStringMetric"
            self.getter_type = "std::string"
            self.getter = "GetRawStringMetricForTest"
            self.arg_parser = "ParseStringStructuredMetricsArg"
        elif metric.type == "double":
            self.setter_type = "double"
            self.setter = "AddDoubleMetric"
            self.getter_type = "double"
            self.getter = "GetDoubleMetricForTest"
            self.arg_parser = "ParseDoubleStructuredMetricsArg"
        elif metric.type == "int-array":
            self.setter_type = "std::vector<int64_t>&"
            self.max_size = metric.max_size
            self.setter = "AddIntArrayMetric"
            self.getter_type = "std::vector<int64_t>"
            self.getter = "GetIntArrayMetricForTest"
            self.arg_parser = "ParseIntArrayStructuredMetricsArg"
        else:
            raise ValueError("Invalid metric type.")


class Template:
    """Template for producing code from structured.xml."""

    def __init__(
        self,
        model,
        dirname,
        basename,
        file_template,
        project_template,
        event_template,
        pre_metric_template,
        metric_template,
        array_template,
        is_header,
    ):
        self.model = model
        self.dirname = dirname
        self.basename = basename
        self.file_template = file_template
        self.project_template = project_template
        self.event_template = event_template
        self.pre_metric_template = pre_metric_template
        self.metric_template = metric_template
        self.array_template = array_template
        self.is_header = is_header

    def write_file(self):
        file_info = FileInfo(self.dirname, self.basename)
        with open(file_info.filepath, "w", encoding="utf-8") as f:
            f.write(self._stamp_file(file_info))

    def _stamp_file(self, file_info):
        project_code = "".join(
            self._stamp_project(file_info, p) for p in self.model.projects
        )

        project_names = sorted([p.name for p in self.model.projects])
        project_hashes_list = [
            f"UINT64_C({Util.hash_name(n)})" for n in project_names
        ]
        project_hashes_literal = "{" + ", ".join(project_hashes_list) + "}"

        return self.file_template.format(
            file=file_info,
            project_code=project_code,
            project_hashes=project_hashes_literal,
        )

    def _stamp_project(self, file_info, project):
        project_info = ProjectInfo(project)
        event_code = "".join(
            self._stamp_event(file_info, project_info, event)
            for event in project.events
        )
        return self.project_template.format(
            file=file_info, project=project_info, event_code=event_code
        )

    def _stamp_event(self, file_info, project_info, event):
        event_info = EventInfo(event, project_info)
        if self.is_header:
            metric_code = "".join(
                self._stamp_metric(file_info, event_info, metric)
                for metric in event.metrics
            )
            metric_code += "".join(
                self._stamp_array_metric(file_info, event_info, metric)
                for metric in event.metrics
                if metric.is_array()
            )
        else:
            metric_code = "".join(
                self._stamp_metric(file_info, event_info, metric)
                for metric in event.metrics
                if not metric.is_array()
            )
            metric_code += "".join(
                self._stamp_array_metric(file_info, event_info, metric)
                for metric in event.metrics
                if metric.is_array()
            )

        pre_metric_code = "".join(
            self._stamp_pre_metric(file_info, event_info, metric)
            for metric in event.metrics
        )

        return self.event_template.format(
            file=file_info,
            project=project_info,
            event=event_info,
            pre_metric_code=pre_metric_code,
            metric_code=metric_code,
        )

    def _stamp_pre_metric(self, file_info, event_info, metric):
        return self.pre_metric_template.format(
            file=file_info, event=event_info, metric=MetricInfo(metric)
        )

    def _stamp_metric(self, file_info, event_info, metric):
        return self.metric_template.format(
            file=file_info, event=event_info, metric=MetricInfo(metric)
        )

    def _stamp_array_metric(self, file_info, event_info, metric):
        return self.array_template.format(
            file=file_info, event=event_info, metric=MetricInfo(metric)
        )