package main

import "testing"

func TestUPSParsing(t *testing.T) {
	values := parseColonValues("battery.charge: 98.5\nups.status: OL\nbattery.runtime: 1200\n")
	metrics := upsFromValues("NUT", "ups", values)
	if metrics.ChargePercent == nil || *metrics.ChargePercent != 98.5 {
		t.Fatalf("неожиданный заряд: %v", metrics.ChargePercent)
	}
	if metrics.StatusLabel != "Питание от сети" {
		t.Fatalf("неожиданный статус: %s", metrics.StatusLabel)
	}
}

const cyberPowerSample = `device.mfr: CPS
device.model: VP700ELCD
battery.charge: 100
battery.charge.low: 10
battery.charge.warning: 20
battery.mfr.date: CPS
battery.runtime: 450
battery.runtime.low: 300
battery.type: PbAcid
battery.voltage: 13.4
battery.voltage.nominal: 12
input.frequency: 498.0
input.transfer.high: 295
input.transfer.low: 167
input.voltage: 224.0
input.voltage.nominal: 230
output.voltage: 225.0
ups.beeper.status: disabled
ups.delay.shutdown: 20
ups.delay.start: 30
ups.load: 46
ups.realpower.nominal: 390
ups.status: OL
ups.test.result: No test initiated
driver.name: usbhid-ups
driver.version: 2.8.1
`

func TestCyberPowerFrequencyPowerAndRaw(t *testing.T) {
	raw := parseColonValues(cyberPowerSample)
	m := upsFromValues("NUT", "cyberpower", raw)
	if !m.FrequencyCorrected || *m.InputFrequency != 49.8 || *m.InputFrequencyRaw != 498 || m.Raw["input.frequency"] != "498.0" {
		t.Fatalf("frequency %+v", m)
	}
	if m.Power == nil || *m.Power != 179.4 || !m.PowerEstimated {
		t.Fatalf("power %+v", m)
	}
	if m.BatteryDate != "" || m.BatteryAgeDays != 0 || m.Raw["battery.mfr.date"] != "CPS" {
		t.Fatal("invalid date not preserved as raw only")
	}
	raw["input.frequency"] = "49.8"
	raw["ups.realpower"] = "165"
	m = upsFromValues("NUT", "ups", raw)
	if m.FrequencyCorrected || *m.InputFrequency != 49.8 || m.PowerEstimated || *m.Power != 165 {
		t.Fatal("double correction or ignored measured power")
	}
	raw["device.mfr"] = "Other"
	raw["input.frequency"] = "498"
	if m = upsFromValues("NUT", "ups", raw); m.FrequencyCorrected || *m.InputFrequency != 498 {
		t.Fatal("other vendor corrected")
	}
	for _, v := range []string{"NaN", "Inf", "-Inf", ""} {
		if numberPointer(v) != nil {
			t.Fatal("nonfinite accepted")
		}
	}
	if m = upsFromValues("NUT", "ups", map[string]string{"ups.load": "46"}); m.Power != nil {
		t.Fatal("invented power without nominal")
	}
}
func TestUPSHistoryRecordsCorrectedValuesAndGaps(t *testing.T) {
	s, a := trafficFixture(t)
	_ = a
	u := upsFromValues("NUT", "cyberpower", parseColonValues(cyberPowerSample))
	s.AddEntityMetrics(dashboardMetrics{UPS: u})
	for _, tc := range []struct {
		kind, name string
		want       float64
	}{{"ups-frequency", "Частота", 49.8}, {"ups-power", "Расчётная ≈", 179.4}, {"ups-runtime", "Автономность", 450}} {
		rows, err := s.EntityHistory(tc.kind, 1)
		if err != nil {
			t.Fatal(err)
		}
		found := false
		for _, r := range rows {
			if r.Name == tc.name {
				found = true
				if r.Points[0].Value1 == nil || *r.Points[0].Value1 != tc.want {
					t.Fatalf("bad %s: %+v", tc.kind, r)
				}
			}
		}
		if !found {
			t.Fatal("missing history")
		}
	}
	u.Available = false
	u.CommunicationOK = false
	s.AddEntityMetrics(dashboardMetrics{UPS: u})
	rows, _ := s.EntityHistory("ups-frequency", 1)
	for _, r := range rows {
		if r.Points[len(r.Points)-1].Value1 != nil {
			t.Fatal("stale reading stored as live")
		}
	}
	p := historyPointFromMetrics(dashboardMetrics{UPS: u})
	if p.UPSCharge != nil || p.UPSLoad != nil {
		t.Fatal("stale charge stored")
	}
}