case "histogram_count", "histogram_sum", "histogram_avg":
				n.SkipHistogramBuckets = false  // instead of true

import json
import math
from string import Template
import sys



def convert_json_to_promql_unittest(json_file_path):
    with open(json_file_path, 'r') as json_file:
        data = json.load(json_file)

    if "status" not in data or data["status"] != "success":
        print("Invalid JSON format: 'status' key is missing or not 'success'")
        return

    result = data.get("data", {}).get("result", [])
    if not result:
        print("No results found in the JSON data.")
        return

    for item in result:
        convertMetric(item)


def convertMetric(item):
    metric = item.get("metric", {})
    if not metric:
        print("No metric found in the item.")
        return
    metric_name = metric.get("__name__", "unknown_metric")
    labels = ["{}=\"{}\"".format(k, v) for k, v in metric.items() if k != "__name__"]
    series = metric_name + ",".join(labels)

    
    loadValues = []

    histograms = item.get("histograms", [])
    schema = 0
    prevTs = 0
    mockTs = 0
    idx = 0
    for histogram in histograms:
        Ts = int(histogram[0])
        # print("dTs: {}".format(Ts - prevTs))
        # if prevTs != 0:
        #     dTs = Ts - prevTs
        #     if dTs > 29:
        #         loadValues.append("NaN")
        #         for i in range(2, int(dTs/15)):
        #             loadValues.append("_")
        FH = histogram[1]
        schema = getSchema(FH, schema)

        if prevTs != 0:
            mockTs += Ts-prevTs

        printHistogram(FH, schema, mockTs, idx)
        idx += 1
        
        prevTs = Ts

    # series += " " + " ".join(loadValues)
    # print(series)
    # print("len: {}".format(len(loadValues)))

def getSchema(FH, schema):
    if "buckets" not in FH:
        return schema
    b = None
    for bucket in FH["buckets"]:
        l = float(bucket[1])
        h = float(bucket[2])
        if l < 0 and h > 0:
            # Zero bucket
            continue
        l=math.fabs(l)
        h=math.fabs(h)
        f=h/l
        ex=round(math.log2(math.log2(f)), 0)
        return int(-ex)
    return schema

def printHistogram(FH, schema, timestamp, idx):
    offset, deltas = convertHistogram(FH, schema)

    # t = Template('''h$idx = prompb.Histogram{
	# 	Count: &prompb.Histogram_CountInt{CountInt: $count},
	# 	Sum: $sum,
	# 	Schema: $schema,
	# 	ZeroThreshold: 0.0001,
	# 	ZeroCount: &prompb.Histogram_ZeroCountInt{ZeroCountInt: 0},
	# 	NegativeSpans: nil,
	# 	PositiveSpans: []prompb.BucketSpan{
	# 		{Offset: $offset, Length: $length},
	# 	},
	# 	NegativeDeltas: nil,
	# 	NegativeCounts: nil,
	# 	PositiveDeltas: []int64{$positiveDeltas},
	# 	PositiveCounts: nil,
	# 	ResetHint: prompb.Histogram_UNKNOWN,
	# 	Timestamp: $timestamp,
	# }''')
    # tZero = Template('''h$idx = prompb.Histogram{
    #     Count: &prompb.Histogram_CountInt{CountInt: $count},
	# 	Sum: $sum,
	# 	Schema: $schema,
	# 	ZeroThreshold: 0.0001,
	# 	ZeroCount: &prompb.Histogram_ZeroCountInt{ZeroCountInt: 0},
	# 	NegativeSpans: nil,
	# 	PositiveSpans: nil,
	# 	NegativeDeltas: nil,
	# 	NegativeCounts: nil,
	# 	PositiveDeltas: nil,
	# 	PositiveCounts: nil,
	# 	ResetHint: prompb.Histogram_UNKNOWN,
	# 	Timestamp: $timestamp,
	# }''')
    t = Template('''{Ts: $timestamp, H: &histogram.Histogram{
    CounterResetHint: histogram.UnknownCounterReset,
    Schema: $schema,
    ZeroThreshold: 0.0001,
    ZeroCount: 0,
    Count: $count,
    Sum: $sum,
    PositiveSpans: []histogram.Span{
	    {Offset: $offset, Length: $length},
    },
    NegativeSpans: nil,
    PositiveBuckets: []int64{
        $positiveDeltas,
    },
    NegativeBuckets: nil,
    CustomValues: nil,
}},
''')
    tZero = Template('''{Ts: $timestamp, H: &histogram.Histogram{
                         CounterResetHint: histogram.UnknownCounterReset,
    Schema: $schema,
    ZeroThreshold: 0.0001,
    ZeroCount: 0,
    Count: $count,
    Sum: $sum,
    PositiveSpans: nil,
    NegativeSpans: nil,
    PositiveBuckets: nil,
    NegativeBuckets: nil,
    CustomValues: nil,
}},
''')
    if len(deltas) == 0:
        print(tZero.substitute(
                idx=idx,
                schema=schema,
                count=FH["count"],
                sum=FH["sum"],
                timestamp=timestamp,
        ))
        return
    print(t.substitute(
                idx=idx,
                schema=schema,
                count=FH["count"],
                sum=FH["sum"],
                offset=offset,
                length=len(deltas),
                positiveDeltas=",".join([str(x) for x in deltas]),
                timestamp=timestamp,
    ))

def convertHistogram(FH, schema):
    count = FH["count"]
    sum = FH["sum"]
    value = "{{" + "schema:{} count:{} sum:{}".format(schema, count, sum)
    base = math.pow(2, math.pow(2, -schema))
    offset = None
    prevOffset = None
    positives = []
    for bucket in FH["buckets"]:
        l = float(bucket[1])
        h = float(bucket[2])
        if l < 0 and h > 0:
            # Zero bucket
            continue
        l=math.fabs(l)
        h=math.fabs(h)
        delta = h - l
        thisOffset = int(round(math.log(delta, base), 0))
        if offset is None:
            offset = thisOffset
            prevOffset = thisOffset
        else:
            for i in range(prevOffset, thisOffset):
                positives.append(0)
            prevOffset = thisOffset
        positives.append(int(bucket[3]))

    deltas = []
    if len(positives) > 0:
        deltas.append(positives[0])
        for i in range(1, len(positives)):
            deltas.append(positives[i] - positives[i - 1])

    return (offset, deltas)



convert_json_to_promql_unittest(sys.argv[1])