// Copyright 2022 Google Inc. All Rights Reserved.
//
// 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.

package metrics

import (
 "fmt"
 "strings"
 "time"
)

// EventHandler tracks nested events and their start/stop times in a single
// thread.
type EventHandler struct {
 completedEvents []Event

 // These fields handle event scoping. When starting a new event, a new entry
 // is pushed onto these fields. When ending an event, these fields are popped.
 scopeIds        []string
 scopeStartTimes []time.Time
}

// _now simply delegates to time.Now() function. _now is declared for unit testing purpose.
var _now = time.Now

// Event holds the performance metrics data of a single build event.
type Event struct {
 // A unique human-readable identifier / "name" for the build event. Event
 // names use period-delimited scoping. For example, if an event alpha starts,
 // then an event bravo starts, then an event charlie starts and ends, the
 // unique identifier for charlie will be 'alpha.bravo.charlie'.
 Id string

 Start time.Time
 end   time.Time
}

// RuntimeNanoseconds returns the number of nanoseconds between the start
// and end times of the event.
func (e Event) RuntimeNanoseconds() uint64 {
 return uint64(e.end.Sub(e.Start).Nanoseconds())
}

// Begin logs the start of an event. This must be followed by a corresponding
// call to End (though other events may begin and end before this event ends).
// Events within the same scope must have unique names.
func (h *EventHandler) Begin(name string) {
 if strings.ContainsRune(name, '.') {
  panic(fmt.Sprintf("illegal event name (avoid dot): %s", name))
 }
 h.scopeIds = append(h.scopeIds, name)
 h.scopeStartTimes = append(h.scopeStartTimes, _now())
}

// Do wraps a function with calls to Begin() and End().
func (h *EventHandler) Do(name string, f func()) {
 h.Begin(name)
 defer h.End(name)
 f()
}

// End logs the end of an event. All events nested within this event must have
// themselves been marked completed.
func (h *EventHandler) End(name string) {
 if len(h.scopeIds) == 0 || name != h.scopeIds[len(h.scopeIds)-1] {
  panic(fmt.Errorf("unexpected scope end '%s'. Current scope: (%s)",
   name, h.scopeIds))
 }
 event := Event{
  // The event Id is formed from the period-delimited scope names of all
  // active events (e.g. `alpha.beta.charlie`). See Event.Id documentation
  // for more detail.
  Id:    strings.Join(h.scopeIds, "."),
  Start: h.scopeStartTimes[len(h.scopeStartTimes)-1],
  end:   _now(),
 }
 h.completedEvents = append(h.completedEvents, event)
 h.scopeIds = h.scopeIds[:len(h.scopeIds)-1]
 h.scopeStartTimes = h.scopeStartTimes[:len(h.scopeStartTimes)-1]
}

// CompletedEvents returns all events which have been completed, after
// validation.
// It is an error to call this method if there are still ongoing events, or
// if two events were completed with the same scope and name.
func (h *EventHandler) CompletedEvents() []Event {
 if len(h.scopeIds) > 0 {
  panic(fmt.Errorf(
   "retrieving events before all events have been closed. Current scope: (%s)",
   h.scopeIds))
 }
 // Validate no two events have the same full id.
 ids := map[string]struct{}{}
 for _, event := range h.completedEvents {
  if _, containsId := ids[event.Id]; containsId {
   panic(fmt.Errorf("duplicate event registered: %s", event.Id))
  }
  ids[event.Id] = struct{}{}
 }
 return h.completedEvents
}