class Gladys::Report

def build_errors_summary
  {
    total: @timeseries[:errors_per_second].values.sum,
    per_second: @timeseries[:errors_per_second].values.sum / @time
  }
end

def build_json
  JSON.pretty_generate(build_report)
end

def build_latency_summary
  {
    min: @timeseries[:latency_95th].values.min.round(4),
    avg: (@timeseries[:latency_95th].values.sum / @timeseries[:latency_95th].values.length).round(4),
    max: @timeseries[:latency_95th].values.max.round(4),
    p95th: @timeseries[:latency_95th].values.percentile(95).round(4),
    sum: @timeseries[:latency_95th].values.sum.round(4)
  }
end

def build_queries_summary
  {
    total: @timeseries[:queries_per_second].values.sum,
    per_second: @timeseries[:queries_per_second].values.sum / @time
  }
end

def build_reconnects_summary
  {
    total: @timeseries[:reconnects_per_second].values.sum,
    per_second: @timeseries[:reconnects_per_second].values.sum / @time
  }
end

def build_report
  {
    script: @script.name,
    version: @script.running_version,
    threads: @threads,
    time: @time,
    started_at: @started_at,
    finished_at: @finished_at,
    database_size: number_to_human_size(@database_size),
    metadata: @metadata,
    summary: @summary,
    timeseries: @timeseries
  }
end

def build_summary
  {
    queries: build_queries_summary,
    transactions: build_transactions_summary,
    latency: build_latency_summary,
    errors: build_errors_summary,
    reconnects: build_reconnects_summary
  }
end

def build_text
  JSON.pretty_generate(build_report)
end

def build_timeseries
  {
    queries_per_second: @metrics[:qps],
    transactions_per_second: @metrics[:tps],
    latency_95th: @metrics[:latency],
    errors_per_second: @metrics[:errors],
    reconnects_per_second: @metrics[:reconnects]
  }
end

def build_transactions_summary
  {
    total: @timeseries[:transactions_per_second].values.sum,
    per_second: @timeseries[:transactions_per_second].values.sum / @time
  }
end

def format_latency(value)
  precision = if value < 1
                4
              elsif value < 10
                2
              else
                1
              end
  "#{number_to_rounded(value, precision: precision)} ms"
end

def format_number(value)
  if value == value.to_i
    number_to_delimited(value.to_i)
  else
    number_to_rounded(value, precision: 2, delimiter: ",")
  end
end

def format_rate(value)
  precision = if value < 1
                4
              elsif value < 10
                2
              else
                1
              end
  "#{number_to_rounded(value, precision: precision)}/sec"
end

def initialize(script:, threads:, time:, started_at:, finished_at:, database_size:, metrics:, metadata:)
  @script = script
  @threads = threads
  @time = time
  @started_at = started_at
  @finished_at = finished_at
  @database_size = database_size
  @metrics = metrics.current(start: @started_at, finish: @finished_at)
  @metadata = metadata
  @timeseries = build_timeseries
  @summary = build_summary
end