package internal

import (
	"bytes"
	"container/heap"
	"encoding/json"
	"sort"
	"time"

	"github.com/newrelic/go-agent/internal/jsonx"
)

// See https://source.datanerd.us/agents/agent-specs/blob/master/Transaction-Trace-LEGACY.md

type traceNodeHeap []traceNode

// traceNodeParams is used for trace node parameters.  A struct is used in place
// of a map[string]interface{} to facilitate testing and reduce JSON Marshal
// overhead.  If too many fields get added here, it probably makes sense to
// start using a map.  This struct is not embedded into traceNode to minimize
// the size of traceNode:  Not all nodes will have parameters.
type traceNodeParams struct {
	StackTrace      *StackTrace
	CleanURL        string
	Database        string
	Host            string
	PortPathOrID    string
	Query           string
	queryParameters queryParameters
}

func (p *traceNodeParams) WriteJSON(buf *bytes.Buffer) {
	w := jsonFieldsWriter{buf: buf}
	buf.WriteByte('{')
	if nil != p.StackTrace {
		w.writerField("backtrace", p.StackTrace)
	}
	if "" != p.CleanURL {
		w.stringField("uri", p.CleanURL)
	}
	if "" != p.Database {
		w.stringField("database_name", p.Database)
	}
	if "" != p.Host {
		w.stringField("host", p.Host)
	}
	if "" != p.PortPathOrID {
		w.stringField("port_path_or_id", p.PortPathOrID)
	}
	if "" != p.Query {
		w.stringField("query", p.Query)
	}
	if nil != p.queryParameters {
		w.writerField("query_parameters", p.queryParameters)
	}
	buf.WriteByte('}')
}

// MarshalJSON is used for testing.
func (p *traceNodeParams) MarshalJSON() ([]byte, error) {
	buf := &bytes.Buffer{}
	p.WriteJSON(buf)
	return buf.Bytes(), nil
}

type traceNode struct {
	start    segmentTime
	stop     segmentTime
	duration time.Duration
	params   *traceNodeParams
	name     string
}

func (h traceNodeHeap) Len() int           { return len(h) }
func (h traceNodeHeap) Less(i, j int) bool { return h[i].duration < h[j].duration }
func (h traceNodeHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }

// Push and Pop are unused: only heap.Init and heap.Fix are used.
func (h traceNodeHeap) Push(x interface{}) {}
func (h traceNodeHeap) Pop() interface{}   { return nil }

// TxnTrace contains the work in progress transaction trace.
type TxnTrace struct {
	Enabled             bool
	SegmentThreshold    time.Duration
	StackTraceThreshold time.Duration
	nodes               traceNodeHeap
	maxNodes            int
}

// considerNode exists to prevent unnecessary calls to witnessNode: constructing
// the metric name and params map requires allocations.
func (trace *TxnTrace) considerNode(end segmentEnd) bool {
	return trace.Enabled && (end.duration >= trace.SegmentThreshold)
}

func (trace *TxnTrace) witnessNode(end segmentEnd, name string, params *traceNodeParams) {
	node := traceNode{
		start:    end.start,
		stop:     end.stop,
		duration: end.duration,
		name:     name,
		params:   params,
	}
	if !trace.considerNode(end) {
		return
	}
	if trace.nodes == nil {
		max := trace.maxNodes
		if 0 == max {
			max = maxTxnTraceNodes
		}
		trace.nodes = make(traceNodeHeap, 0, max)
	}
	if end.exclusive >= trace.StackTraceThreshold {
		if node.params == nil {
			p := new(traceNodeParams)
			node.params = p
		}
		// skip the following stack frames:
		//   this method
		//   function in tracing.go      (EndBasicSegment, EndExternalSegment, EndDatastoreSegment)
		//   function in internal_txn.go (endSegment, endExternal, endDatastore)
		//   segment end method
		skip := 4
		node.params.StackTrace = GetStackTrace(skip)
	}
	if len(trace.nodes) < cap(trace.nodes) {
		trace.nodes = append(trace.nodes, node)
		if len(trace.nodes) == cap(trace.nodes) {
			heap.Init(trace.nodes)
		}
		return
	}
	if node.duration <= trace.nodes[0].duration {
		return
	}
	trace.nodes[0] = node
	heap.Fix(trace.nodes, 0)
}

// HarvestTrace contains a finished transaction trace ready for serialization to
// the collector.
type HarvestTrace struct {
	Start                time.Time
	Duration             time.Duration
	MetricName           string
	CleanURL             string
	Trace                TxnTrace
	ForcePersist         bool
	GUID                 string
	SyntheticsResourceID string
	Attrs                *Attributes
}

type nodeDetails struct {
	name          string
	relativeStart time.Duration
	relativeStop  time.Duration
	params        *traceNodeParams
}

func printNodeStart(buf *bytes.Buffer, n nodeDetails) {
	// time.Seconds() is intentionally not used here.  Millisecond
	// precision is enough.
	relativeStartMillis := n.relativeStart.Nanoseconds() / (1000 * 1000)
	relativeStopMillis := n.relativeStop.Nanoseconds() / (1000 * 1000)

	buf.WriteByte('[')
	jsonx.AppendInt(buf, relativeStartMillis)
	buf.WriteByte(',')
	jsonx.AppendInt(buf, relativeStopMillis)
	buf.WriteByte(',')
	jsonx.AppendString(buf, n.name)
	buf.WriteByte(',')
	if nil == n.params {
		buf.WriteString("{}")
	} else {
		n.params.WriteJSON(buf)
	}
	buf.WriteByte(',')
	buf.WriteByte('[')
}

func printChildren(buf *bytes.Buffer, traceStart time.Time, nodes sortedTraceNodes, next int, stop segmentStamp) int {
	firstChild := true
	for next < len(nodes) && nodes[next].start.Stamp < stop {
		if firstChild {
			firstChild = false
		} else {
			buf.WriteByte(',')
		}
		printNodeStart(buf, nodeDetails{
			name:          nodes[next].name,
			relativeStart: nodes[next].start.Time.Sub(traceStart),
			relativeStop:  nodes[next].stop.Time.Sub(traceStart),
			params:        nodes[next].params,
		})
		next = printChildren(buf, traceStart, nodes, next+1, nodes[next].stop.Stamp)
		buf.WriteString("]]")

	}
	return next
}

type sortedTraceNodes []*traceNode

func (s sortedTraceNodes) Len() int           { return len(s) }
func (s sortedTraceNodes) Less(i, j int) bool { return s[i].start.Stamp < s[j].start.Stamp }
func (s sortedTraceNodes) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }

func traceDataJSON(trace *HarvestTrace) []byte {
	estimate := 100 * len(trace.Trace.nodes)
	buf := bytes.NewBuffer(make([]byte, 0, estimate))

	nodes := make(sortedTraceNodes, len(trace.Trace.nodes))
	for i := 0; i < len(nodes); i++ {
		nodes[i] = &trace.Trace.nodes[i]
	}
	sort.Sort(nodes)

	buf.WriteByte('[') // begin trace data

	// If the trace string pool is used, insert another array here.

	jsonx.AppendFloat(buf, 0.0) // unused timestamp
	buf.WriteByte(',')          //
	buf.WriteString("{}")       // unused: formerly request parameters
	buf.WriteByte(',')          //
	buf.WriteString("{}")       // unused: formerly custom parameters
	buf.WriteByte(',')          //

	printNodeStart(buf, nodeDetails{ // begin outer root
		name:          "ROOT",
		relativeStart: 0,
		relativeStop:  trace.Duration,
	})

	printNodeStart(buf, nodeDetails{ // begin inner root
		name:          trace.MetricName,
		relativeStart: 0,
		relativeStop:  trace.Duration,
	})

	if len(nodes) > 0 {
		lastStopStamp := nodes[len(nodes)-1].stop.Stamp + 1
		printChildren(buf, trace.Start, nodes, 0, lastStopStamp)
	}

	buf.WriteString("]]") // end outer root
	buf.WriteString("]]") // end inner root

	buf.WriteByte(',')
	buf.WriteByte('{')
	buf.WriteString(`"agentAttributes":`)
	agentAttributesJSON(trace.Attrs, buf, destTxnTrace)
	buf.WriteByte(',')
	buf.WriteString(`"userAttributes":`)
	userAttributesJSON(trace.Attrs, buf, destTxnTrace)
	buf.WriteByte(',')
	buf.WriteString(`"intrinsics":{}`) // TODO intrinsics
	buf.WriteByte('}')

	// If the trace string pool is used, end another array here.

	buf.WriteByte(']') // end trace data

	return buf.Bytes()
}

// MarshalJSON prepares the trace in the JSON expected by the collector.
func (trace *HarvestTrace) MarshalJSON() ([]byte, error) {
	return json.Marshal([]interface{}{
		trace.Start.UnixNano() / 1000,
		trace.Duration.Seconds() * 1000.0,
		trace.MetricName,
		trace.CleanURL,
		JSONString(traceDataJSON(trace)),
		trace.GUID,
		nil, // reserved for future use
		trace.ForcePersist,
		nil, // X-Ray sessions not supported
		trace.SyntheticsResourceID,
	})
}

type harvestTraces struct {
	trace *HarvestTrace
}

func newHarvestTraces() *harvestTraces {
	return &harvestTraces{}
}

func (traces *harvestTraces) Witness(trace HarvestTrace) {
	if nil == traces.trace || traces.trace.Duration < trace.Duration {
		cpy := new(HarvestTrace)
		*cpy = trace
		traces.trace = cpy
	}
}

func (traces *harvestTraces) Data(agentRunID string, harvestStart time.Time) ([]byte, error) {
	if nil == traces.trace {
		return nil, nil
	}
	return json.Marshal([]interface{}{
		agentRunID,
		[]interface{}{
			traces.trace,
		},
	})
}

func (traces *harvestTraces) MergeIntoHarvest(h *Harvest) {}