#!/usr/bin/python
from builtins import str
import os

from base.proto import ReadProtoAsText
from data.chum import chumpy
from mined_metric.builder.pmav.analyze_pmav_run import RunAnalyzer
from mined_metric.builder.proto.builder_configs_pb2 import MetricBuilderConfig
from mined_metric.builder.metrics_impl.junction_metrics.junction_proto_pb2 import JunctionLabeledDataLoaderOptions

class NtljRunAnalyzer(RunAnalyzer):

    def get_mh_config_by_metric_id(self, metric_id):
        base_dir = "mined_metric/builder/all_metric_builder_configs/"
        config_file = "slac_junction_offline_metric_builder_config.pbtxt"
        fpath = os.path.join(base_dir, config_file)
        metric_config = MetricBuilderConfig()
        try:
            if ReadProtoAsText(fpath, metric_config):
                options = metric_config.exec_data_loader.data_loader_options
                proto_opt = options.Extensions[JunctionLabeledDataLoaderOptions.ext]
                if proto_opt:
                    return proto_opt.file_path
        except:
            self.log.info("Failed to read configuration file: {}".format(config_file))

        self.log.info("Could not find config for consistency check.")
        return None

    def format_data(self, data, metadata):
        result_json = {}

        for entry in data:
            uri_proto = chumpy.parseChumUriToProto(entry["chum_uri"])
            start = str(round(chumpy.getStartTime(uri_proto) * 1.e-9, 3))
            end = str(round(chumpy.getEndTime(uri_proto) * 1.e-9, 3))
            uri = entry["chum_uri"].split("@")[0] + "@" + start + "-" + end

            if "sim_failed" in entry:
                result_json[uri] = {
                    "failed": "sim_failure",
                }
            else:
                uri_list = entry[self.toCamelCase("chum_uri")].split("?")
                variant = uri_list[1] if len(uri_list) > 1 else ""
                result_json[uri] = {
                    "minTTC": entry[self.toCamelCase("min_time_to_collision")],
                    "longAcc": entry[self.toCamelCase("longitudinal_acceleration_unweighted_sum")],
                    "longJerk": entry[self.toCamelCase("longitudinal_jerk_unweighted_sum")],
                    "jnClear": entry[self.toCamelCase("junction_clear_s")],
                    "variant": variant,
                }

        return result_json

def main():
    analyzer = NtljRunAnalyzer()
    analyzer.main()

if __name__ == "__main__":
    main()