lingniu-vehicle-ingest/vehicle-data-platform/apps/api/tmp/standard-model-trial/main.go

package main

import (
	"bytes"
	"compress/gzip"
	"encoding/csv"
	"encoding/json"
	"fmt"
	"io"
	"math"
	"net/http"
	"net/url"
	"os"
	"path/filepath"
	"sort"
	"strconv"
	"strings"
	"sync"
	"time"

	"lingniu/vehicle-data-platform/apps/api/internal/openplatform"
)

const (
	baseURL           = "http://115.29.187.205:20200"
	hydrogenEnergyKWh = 16.0
	maxIntegrationGap = 30 * time.Second
)

type vehicleMetadata struct {
	VIN                string  `json:"vin"`
	Plate              string  `json:"plate"`
	Model              string  `json:"model"`
	BatteryCapacityKWh float64 `json:"battery_capacity_kwh"`
	TankCapacityL      float64 `json:"tank_capacity_l"`
}

type rawFrame struct {
	TS             string         `json:"ts"`
	FrameID        string         `json:"frame_id"`
	EventID        string         `json:"event_id"`
	MessageID      int            `json:"message_id"`
	EventTime      string         `json:"event_time"`
	ParseStatus    string         `json:"parse_status"`
	SourceEndpoint string         `json:"source_endpoint"`
	VIN            string         `json:"vin"`
	ParsedFields   map[string]any `json:"parsed_fields"`
}

type rawResponse struct {
	Items []rawFrame `json:"items"`
	Total int        `json:"total"`
}

type energySample struct {
	At               time.Time
	VehicleStatus    int
	ChargeStatus     int
	SOC              float64
	Mileage          float64
	BatteryVoltageV  float64
	BatteryCurrentA  float64
	FuelCellVoltageV float64
	FuelCellCurrentA float64
	HasSOC           bool
	HasMileage       bool
	HasBatteryPower  bool
	HasFuelCellPower bool
	HasVehicleStatus bool
	HasChargeStatus  bool
}

type energyResult struct {
	FirstTime                     string  `json:"firstTime"`
	LastTime                      string  `json:"lastTime"`
	StartSOC                      float64 `json:"startSoc"`
	EndSOC                        float64 `json:"endSoc"`
	SOCChangePctEndMinusStart     float64 `json:"socChangePctEndMinusStart"`
	StoredEnergyChangeKWhSOC      float64 `json:"storedEnergyChangeKWhSoc"`
	BatteryNetOutputKWhSOC        float64 `json:"batteryNetOutputKWhSoc"`
	BatteryNetOutputKWhIntegrated float64 `json:"batteryNetOutputKWhIntegrated"`
	FuelCellOutputKWhIntegrated   float64 `json:"fuelCellOutputKWhIntegrated"`
	BatteryCoverageSeconds        float64 `json:"batteryCoverageSeconds"`
	FuelCellCoverageSeconds       float64 `json:"fuelCellCoverageSeconds"`
	OperatingSpanSeconds          float64 `json:"operatingSpanSeconds"`
	BatteryCoverageRatio          float64 `json:"batteryCoverageRatio"`
	FuelCellCoverageRatio         float64 `json:"fuelCellCoverageRatio"`
	ExternalChargeFrameCount      int     `json:"externalChargeFrameCount"`
	EnergySampleCount             int     `json:"energySampleCount"`
}

type row struct {
	Date                            string  `json:"date"`
	Plate                           string  `json:"plate"`
	VIN                             string  `json:"vin"`
	Model                           string  `json:"model"`
	RawFrameCount                   int     `json:"rawFrameCount"`
	CurrentQuality                  string  `json:"currentQuality"`
	CurrentReason                   string  `json:"currentReason"`
	RefuelCount                     int     `json:"refuelCount"`
	ChargeCount                     int     `json:"chargeCount"`
	TotalMileageKm                  float64 `json:"totalMileageKm"`
	PureElectricMileageKm           float64 `json:"pureElectricMileageKm"`
	CurrentMixedMileageKm           float64 `json:"currentMixedMileageKm"`
	PhysicalHydrogenKg              float64 `json:"physicalHydrogenKg"`
	CurrentSOCBalancedKg            float64 `json:"currentSocBalancedKg"`
	CurrentRatePerMixedKm           float64 `json:"currentRatePerMixedKm"`
	PhysicalRatePerTotalKm          float64 `json:"physicalRatePerTotalKm"`
	FullDayStartSOC                 float64 `json:"fullDayStartSoc"`
	FullDayEndSOC                   float64 `json:"fullDayEndSoc"`
	FullDaySOCChangePct             float64 `json:"fullDaySocChangePct"`
	StoredEnergyChangeKWhSOC        float64 `json:"storedEnergyChangeKWhSoc"`
	BatteryEquivalentKgFixed16      float64 `json:"batteryEquivalentKgFixed16"`
	StandardLikeBalancedKg          float64 `json:"standardLikeBalancedKg"`
	StandardLikeRatePerTotalKm      float64 `json:"standardLikeRatePerTotalKm"`
	StandardLikeApplicable          bool    `json:"standardLikeApplicable"`
	StandardLikeReason              string  `json:"standardLikeReason"`
	BatteryNetOutputKWhIntegrated   float64 `json:"batteryNetOutputKWhIntegrated"`
	FuelCellOutputKWhIntegrated     float64 `json:"fuelCellOutputKWhIntegrated"`
	BatteryEnergyShare              float64 `json:"batteryEnergyShare"`
	FuelCellEnergyShare             float64 `json:"fuelCellEnergyShare"`
	BatteryContributionKm           float64 `json:"batteryContributionKm"`
	FuelCellContributionKm          float64 `json:"fuelCellContributionKm"`
	HydrogenRatePerFCContributionKm float64 `json:"hydrogenRatePerFcContributionKm"`
	BatteryCoverageRatio            float64 `json:"batteryCoverageRatio"`
	FuelCellCoverageRatio           float64 `json:"fuelCellCoverageRatio"`
	ExternalChargeFrameCount        int     `json:"externalChargeFrameCount"`
	PowerIntegrationUsable          bool    `json:"powerIntegrationUsable"`
}

type job struct {
	Vehicle vehicleMetadata
	Date    string
}

func main() {
	if len(os.Args) != 5 {
		panic("usage: standard-model-trial <metadata.json> <start-date> <end-date> <output-dir>")
	}
	metadataPath, startDate, endDate, outputDir := os.Args[1], os.Args[2], os.Args[3], os.Args[4]
	start := mustDate(startDate)
	end := mustDate(endDate)
	if end.Before(start) {
		panic("end date is before start date")
	}
	var vehicles []vehicleMetadata
	mustReadJSON(metadataPath, &vehicles)
	if len(vehicles) == 0 {
		panic("metadata is empty")
	}
	if err := os.MkdirAll(outputDir, 0o755); err != nil {
		panic(err)
	}

	jobs := make(chan job)
	results := make(chan row)
	errs := make(chan error, 128)
	var wg sync.WaitGroup
	for worker := 0; worker < 16; worker++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for item := range jobs {
				result, err := process(item)
				if err != nil {
					errs <- fmt.Errorf("%s %s %s: %w", item.Date, item.Vehicle.Plate, item.Vehicle.VIN, err)
					continue
				}
				if result.RawFrameCount > 0 {
					results <- result
				}
			}
		}()
	}
	go func() {
		for day := start; !day.After(end); day = day.AddDate(0, 0, 1) {
			for _, vehicle := range vehicles {
				if len(strings.TrimSpace(vehicle.VIN)) != 17 || vehicle.TankCapacityL <= 0 || vehicle.BatteryCapacityKWh <= 0 {
					continue
				}
				jobs <- job{Vehicle: vehicle, Date: day.Format("2006-01-02")}
			}
		}
		close(jobs)
		wg.Wait()
		close(results)
		close(errs)
	}()

	var rows []row
	completed := 0
	for result := range results {
		rows = append(rows, result)
		completed++
		if completed%25 == 0 {
			fmt.Fprintf(os.Stderr, "completed=%d latest=%s %s quality=%s raw=%d\n", completed, result.Date, result.Plate, result.CurrentQuality, result.RawFrameCount)
		}
	}
	var errorMessages []string
	for err := range errs {
		errorMessages = append(errorMessages, err.Error())
	}
	if len(errorMessages) > 0 {
		panic(strings.Join(errorMessages, "\n"))
	}
	sort.Slice(rows, func(i, j int) bool {
		if rows[i].Date != rows[j].Date {
			return rows[i].Date < rows[j].Date
		}
		if rows[i].Plate != rows[j].Plate {
			return rows[i].Plate < rows[j].Plate
		}
		return rows[i].VIN < rows[j].VIN
	})
	writeJSON(filepath.Join(outputDir, "results.json"), rows)
	writeCSV(filepath.Join(outputDir, "results.csv"), rows)
	writeJSON(filepath.Join(outputDir, "summary.json"), summarize(rows))
	fmt.Printf("vehicle_days=%d output=%s\n", len(rows), outputDir)
}

func process(item job) (row, error) {
	frames, total, err := fetchFrames(item.Vehicle.VIN, item.Date)
	if err != nil || total == 0 {
		return row{Date: item.Date, Plate: item.Vehicle.Plate, VIN: item.Vehicle.VIN, Model: item.Vehicle.Model, RawFrameCount: total}, err
	}
	sort.SliceStable(frames, func(i, j int) bool {
		if frames[i].EventTime != frames[j].EventTime {
			return frames[i].EventTime < frames[j].EventTime
		}
		return frames[i].EventID < frames[j].EventID
	})
	observations := make([]openplatform.HydrogenObservation, 0, len(frames))
	energySamples := make([]energySample, 0, len(frames))
	for _, frame := range frames {
		if observation, ok := observationFromFrame(frame, item.Vehicle.TankCapacityL, item.Date); ok {
			observations = append(observations, observation)
		}
		if sample, ok := energySampleFromFrame(frame, item.Date); ok {
			energySamples = append(energySamples, sample)
		}
	}
	params := map[string]openplatform.HydrogenCalculationParameters{
		item.Vehicle.VIN: {BatteryCapacityKWh: item.Vehicle.BatteryCapacityKWh, HydrogenEnergyKWhKg: hydrogenEnergyKWh},
	}
	stats := openplatform.BuildHydrogenDailyStatsOrderedWithParameters(observations, item.Date, 0.05, 20, params)
	stat := openplatform.HydrogenDailyStat{VIN: item.Vehicle.VIN, Date: item.Date, QualityStatus: "NO_DATA", QualityReason: "无有效压力温度样本"}
	if len(stats) == 1 {
		stat = stats[0]
	}
	energy := calculateEnergy(energySamples, item.Vehicle.BatteryCapacityKWh)
	totalMileage := stat.MixedMileageKm + stat.PureElectricMileageKm
	result := row{
		Date: item.Date, Plate: item.Vehicle.Plate, VIN: item.Vehicle.VIN, Model: item.Vehicle.Model,
		RawFrameCount: total, CurrentQuality: stat.QualityStatus, CurrentReason: stat.QualityReason,
		RefuelCount: stat.RefuelCount, ChargeCount: stat.ChargeCount,
		TotalMileageKm: totalMileage, PureElectricMileageKm: stat.PureElectricMileageKm,
		CurrentMixedMileageKm: stat.MixedMileageKm, PhysicalHydrogenKg: stat.ConsumptionKg,
		FullDayStartSOC: energy.StartSOC, FullDayEndSOC: energy.EndSOC,
		FullDaySOCChangePct:           energy.SOCChangePctEndMinusStart,
		StoredEnergyChangeKWhSOC:      energy.StoredEnergyChangeKWhSOC,
		BatteryNetOutputKWhIntegrated: energy.BatteryNetOutputKWhIntegrated,
		FuelCellOutputKWhIntegrated:   energy.FuelCellOutputKWhIntegrated,
		BatteryCoverageRatio:          energy.BatteryCoverageRatio,
		FuelCellCoverageRatio:         energy.FuelCellCoverageRatio,
		ExternalChargeFrameCount:      energy.ExternalChargeFrameCount,
	}
	if stat.SOCBalancedConsumptionKg != nil {
		result.CurrentSOCBalancedKg = *stat.SOCBalancedConsumptionKg
	}
	if stat.SOCBalancedKgPer100Km != nil {
		result.CurrentRatePerMixedKm = *stat.SOCBalancedKgPer100Km
	}
	if totalMileage > 0 {
		result.PhysicalRatePerTotalKm = round(stat.ConsumptionKg * 100 / totalMileage)
		result.BatteryEquivalentKgFixed16 = round(-energy.StoredEnergyChangeKWhSOC / hydrogenEnergyKWh)
		result.StandardLikeBalancedKg = round(stat.ConsumptionKg + result.BatteryEquivalentKgFixed16)
		result.StandardLikeRatePerTotalKm = round(result.StandardLikeBalancedKg * 100 / totalMileage)
		switch {
		case energy.ExternalChargeFrameCount > 0:
			result.StandardLikeReason = "检测到外部充电，整日SOC平衡修正不适用，应按CD/CS分段"
		case result.StandardLikeBalancedKg < 0:
			result.StandardLikeReason = "SOC平衡氢量为负，端点、SOC或换算系数需复核"
		default:
			result.StandardLikeApplicable = true
		}
	} else {
		result.StandardLikeReason = "无有效总里程"
	}
	// The GB/T 43252 contribution trial uses positive battery net output and
	// fuel-cell output measured over non-external-charge vehicle-on intervals.
	// Coverage gates prevent sparse power fields from being treated as precise.
	if totalMileage >= 10 && stat.ConsumptionKg > 0 && energy.ExternalChargeFrameCount == 0 && energy.BatteryCoverageRatio >= 0.98 && energy.FuelCellCoverageRatio >= 0.98 && energy.FuelCellOutputKWhIntegrated > 0 {
		batteryOutput := math.Max(0, energy.BatteryNetOutputKWhIntegrated)
		totalOutput := batteryOutput + energy.FuelCellOutputKWhIntegrated
		if totalOutput > 0 {
			result.PowerIntegrationUsable = true
			result.BatteryEnergyShare = round(batteryOutput / totalOutput)
			result.FuelCellEnergyShare = round(energy.FuelCellOutputKWhIntegrated / totalOutput)
			result.BatteryContributionKm = round(totalMileage * result.BatteryEnergyShare)
			result.FuelCellContributionKm = round(totalMileage * result.FuelCellEnergyShare)
			if result.FuelCellContributionKm > 0 {
				result.HydrogenRatePerFCContributionKm = round(stat.ConsumptionKg * 100 / result.FuelCellContributionKm)
			}
		}
	}
	return result, nil
}

func calculateEnergy(samples []energySample, batteryCapacityKWh float64) energyResult {
	result := energyResult{EnergySampleCount: len(samples)}
	if len(samples) == 0 {
		return result
	}
	for _, sample := range samples {
		if sample.HasChargeStatus && sample.ChargeStatus == 1 {
			result.ExternalChargeFrameCount++
		}
	}
	operating := make([]energySample, 0, len(samples))
	for _, sample := range samples {
		if sample.HasVehicleStatus && sample.VehicleStatus == 1 && (!sample.HasChargeStatus || sample.ChargeStatus != 1) {
			operating = append(operating, sample)
		}
	}
	if len(operating) == 0 {
		return result
	}
	result.FirstTime = operating[0].At.Format(time.RFC3339)
	result.LastTime = operating[len(operating)-1].At.Format(time.RFC3339)
	result.OperatingSpanSeconds = operating[len(operating)-1].At.Sub(operating[0].At).Seconds()
	for _, sample := range operating {
		if sample.HasSOC {
			result.StartSOC = sample.SOC
			break
		}
	}
	for index := len(operating) - 1; index >= 0; index-- {
		if operating[index].HasSOC {
			result.EndSOC = operating[index].SOC
			break
		}
	}
	result.SOCChangePctEndMinusStart = round(result.EndSOC - result.StartSOC)
	result.StoredEnergyChangeKWhSOC = round(batteryCapacityKWh * result.SOCChangePctEndMinusStart / 100)
	result.BatteryNetOutputKWhSOC = round(-result.StoredEnergyChangeKWhSOC)
	for index := 1; index < len(operating); index++ {
		previous, current := operating[index-1], operating[index]
		delta := current.At.Sub(previous.At)
		if delta <= 0 || delta > maxIntegrationGap {
			continue
		}
		hours := delta.Hours()
		if previous.HasBatteryPower && current.HasBatteryPower {
			power0 := previous.BatteryVoltageV * previous.BatteryCurrentA / 1000
			power1 := current.BatteryVoltageV * current.BatteryCurrentA / 1000
			result.BatteryNetOutputKWhIntegrated += (power0 + power1) * 0.5 * hours
			result.BatteryCoverageSeconds += delta.Seconds()
		}
		if previous.HasFuelCellPower && current.HasFuelCellPower {
			power0 := previous.FuelCellVoltageV * previous.FuelCellCurrentA / 1000
			power1 := current.FuelCellVoltageV * current.FuelCellCurrentA / 1000
			result.FuelCellOutputKWhIntegrated += (power0 + power1) * 0.5 * hours
			result.FuelCellCoverageSeconds += delta.Seconds()
		}
	}
	result.BatteryNetOutputKWhIntegrated = round(result.BatteryNetOutputKWhIntegrated)
	result.FuelCellOutputKWhIntegrated = round(result.FuelCellOutputKWhIntegrated)
	if result.OperatingSpanSeconds > 0 {
		result.BatteryCoverageRatio = round(result.BatteryCoverageSeconds / result.OperatingSpanSeconds)
		result.FuelCellCoverageRatio = round(result.FuelCellCoverageSeconds / result.OperatingSpanSeconds)
	}
	return result
}

func observationFromFrame(frame rawFrame, tankCapacity float64, statDate string) (openplatform.HydrogenObservation, bool) {
	if frame.MessageID != 2 || !strings.EqualFold(frame.ParseStatus, "OK") {
		return openplatform.HydrogenObservation{}, false
	}
	pressure, pressureOK := number(frame.ParsedFields["gb32960.fuel_cell.max_hydrogen_pressure_mpa"])
	temperature, temperatureOK := number(frame.ParsedFields["gb32960.fuel_cell.max_hydrogen_temperature_c"])
	if !pressureOK || !temperatureOK || pressure <= 0 || pressure > 70 || temperature <= -40 || temperature > 726.85 {
		return openplatform.HydrogenObservation{}, false
	}
	mass, ok := openplatform.PressureHydrogenMassKg(pressure, temperature, tankCapacity)
	if !ok {
		return openplatform.HydrogenObservation{}, false
	}
	step, _ := openplatform.PressureHydrogenMassKg(math.Max(0, pressure-0.2), temperature, tankCapacity)
	at, err := parseEventTime(frame.EventTime)
	if err != nil || at.Format("2006-01-02") != statDate {
		return openplatform.HydrogenObservation{}, false
	}
	parsed, _ := json.Marshal(frame.ParsedFields)
	_, _, active, known, _ := openplatform.ExtractHydrogenTelemetry(string(parsed))
	observation := openplatform.HydrogenObservation{
		VIN: frame.VIN, Source: frame.SourceEndpoint, EventID: frame.EventID, ObservedAt: at,
		MassKg: mass, TankCapacityLiter: tankCapacity, PressureMPa: pressure, TemperatureC: temperature,
		NoiseKg: math.Min(1, math.Max(0.05, mass-step)), RefuelThresholdKg: math.Max(1, mass*0.05),
		FuelCellActive: active, FuelCellStateKnown: known,
	}
	if value, ok := number(frame.ParsedFields["gb32960.vehicle.soc_percent"]); ok && value >= 0 && value <= 100 {
		observation.SOCPercent, observation.SOCKnown = value, true
	}
	if value, ok := number(frame.ParsedFields["gb32960.vehicle.total_mileage_km"]); ok && value >= 0 {
		observation.MileageKm, observation.MileageKnown = value, true
	}
	if value, ok := number(frame.ParsedFields["gb32960.vehicle.vehicle_status"]); ok {
		observation.VehicleState, observation.VehicleStateKnown = int(value), value >= 0 && value <= 255
	}
	if value, ok := number(frame.ParsedFields["gb32960.vehicle.charge_status"]); ok {
		observation.ChargeState, observation.ChargeStateKnown = int(value), value >= 0 && value <= 255
	}
	if value, ok := number(frame.ParsedFields["gb32960.vehicle.running_mode"]); ok {
		observation.RunningMode, observation.RunningModeKnown = int(value), value >= 0 && value <= 255
	}
	return observation, true
}

func energySampleFromFrame(frame rawFrame, statDate string) (energySample, bool) {
	if frame.MessageID != 2 || !strings.EqualFold(frame.ParseStatus, "OK") {
		return energySample{}, false
	}
	at, err := parseEventTime(frame.EventTime)
	if err != nil || at.Format("2006-01-02") != statDate {
		return energySample{}, false
	}
	sample := energySample{At: at}
	if value, ok := number(frame.ParsedFields["gb32960.vehicle.vehicle_status"]); ok {
		sample.VehicleStatus, sample.HasVehicleStatus = int(value), true
	}
	if value, ok := number(frame.ParsedFields["gb32960.vehicle.charge_status"]); ok {
		sample.ChargeStatus, sample.HasChargeStatus = int(value), true
	}
	if value, ok := number(frame.ParsedFields["gb32960.vehicle.soc_percent"]); ok && value >= 0 && value <= 100 {
		sample.SOC, sample.HasSOC = value, true
	}
	if value, ok := number(frame.ParsedFields["gb32960.vehicle.total_mileage_km"]); ok && value >= 0 {
		sample.Mileage, sample.HasMileage = value, true
	}
	batteryVoltage, batteryVoltageOK := number(frame.ParsedFields["gb32960.vehicle.total_voltage_v"])
	batteryCurrent, batteryCurrentOK := number(frame.ParsedFields["gb32960.vehicle.total_current_a"])
	if batteryVoltageOK && batteryCurrentOK && batteryVoltage > 0 && batteryVoltage <= 1000 && batteryCurrent >= -1000 && batteryCurrent <= 1000 {
		sample.BatteryVoltageV, sample.BatteryCurrentA, sample.HasBatteryPower = batteryVoltage, batteryCurrent, true
	}
	fuelCellVoltage, fuelCellVoltageOK := number(frame.ParsedFields["gb32960.fuel_cell.fuel_cell_voltage_v"])
	fuelCellCurrent, fuelCellCurrentOK := number(frame.ParsedFields["gb32960.fuel_cell.fuel_cell_current_a"])
	if fuelCellVoltageOK && fuelCellCurrentOK && fuelCellVoltage >= 0 && fuelCellVoltage <= 2000 && fuelCellCurrent >= 0 && fuelCellCurrent <= 2000 {
		sample.FuelCellVoltageV, sample.FuelCellCurrentA, sample.HasFuelCellPower = fuelCellVoltage, fuelCellCurrent, true
	}
	return sample, sample.HasVehicleStatus || sample.HasSOC || sample.HasBatteryPower || sample.HasFuelCellPower
}

func fetchFrames(vin, date string) ([]rawFrame, int, error) {
	const limit = 500
	first, err := fetchPage(vin, date, 0, limit, true)
	if err != nil {
		return nil, 0, err
	}
	frames := append([]rawFrame(nil), first.Items...)
	for offset := limit; offset < first.Total; offset += limit {
		page, err := fetchPage(vin, date, offset, limit, false)
		if err != nil {
			return nil, first.Total, err
		}
		frames = append(frames, page.Items...)
	}
	if len(frames) != first.Total {
		return nil, first.Total, fmt.Errorf("API total=%d fetched=%d", first.Total, len(frames))
	}
	return frames, first.Total, nil
}

func fetchPage(vin, date string, offset, limit int, includeTotal bool) (rawResponse, error) {
	query := url.Values{
		"protocol": {"GB32960"}, "vin": {vin},
		"dateFrom": {date + " 00:00:00"}, "dateTo": {date + " 23:59:59"},
		"orderBy": {"eventTime"}, "limit": {strconv.Itoa(limit)}, "offset": {strconv.Itoa(offset)},
		"includeFields": {"true"}, "includePayload": {"false"}, "includeTotal": {strconv.FormatBool(includeTotal)},
	}
	var response *http.Response
	var err error
	for attempt := 1; attempt <= 4; attempt++ {
		request, _ := http.NewRequest(http.MethodGet, baseURL+"/api/history/raw-frames?"+query.Encode(), nil)
		request.Header.Set("Accept-Encoding", "gzip")
		response, err = (&http.Client{Timeout: 90 * time.Second}).Do(request)
		if err == nil {
			break
		}
		if attempt < 4 {
			time.Sleep(time.Duration(attempt) * 500 * time.Millisecond)
		}
	}
	if err != nil {
		return rawResponse{}, err
	}
	defer response.Body.Close()
	if response.StatusCode != http.StatusOK {
		body, _ := io.ReadAll(response.Body)
		if response.StatusCode == http.StatusInternalServerError && bytes.Contains(body, []byte("Table does not exist")) {
			return rawResponse{}, nil
		}
		return rawResponse{}, fmt.Errorf("HTTP %d: %s", response.StatusCode, body)
	}
	var reader io.Reader = response.Body
	if response.Header.Get("Content-Encoding") == "gzip" {
		gzipReader, err := gzip.NewReader(response.Body)
		if err != nil {
			return rawResponse{}, err
		}
		defer gzipReader.Close()
		reader = gzipReader
	}
	var result rawResponse
	if err := json.NewDecoder(reader).Decode(&result); err != nil {
		return rawResponse{}, err
	}
	return result, nil
}

func summarize(rows []row) map[string]any {
	byDate := map[string]map[string]any{}
	for _, date := range uniqueDates(rows) {
		var dateRows []row
		for _, value := range rows {
			if value.Date == date {
				dateRows = append(dateRows, value)
			}
		}
		quality := map[string]int{}
		valid := 0
		standardApplicable := 0
		powerUsable := 0
		physicalTotal, balancedTotal, mileageTotal, balancedMileageTotal := 0.0, 0.0, 0.0, 0.0
		for _, value := range dateRows {
			quality[value.CurrentQuality]++
			if value.CurrentQuality != "NO_DATA" && value.TotalMileageKm > 0 {
				valid++
				physicalTotal += value.PhysicalHydrogenKg
				mileageTotal += value.TotalMileageKm
			}
			if value.StandardLikeApplicable {
				standardApplicable++
				balancedTotal += value.StandardLikeBalancedKg
				balancedMileageTotal += value.TotalMileageKm
			}
			if value.PowerIntegrationUsable {
				powerUsable++
			}
		}
		physicalRate, balancedRate := 0.0, 0.0
		if mileageTotal > 0 {
			physicalRate = round(physicalTotal * 100 / mileageTotal)
		}
		if balancedMileageTotal > 0 {
			balancedRate = round(balancedTotal * 100 / balancedMileageTotal)
		}
		byDate[date] = map[string]any{
			"vehicleDaysWithFrames": len(dateRows), "validVehicleDays": valid, "standardLikeApplicableVehicleDays": standardApplicable, "qualityCounts": quality,
			"powerIntegrationUsableVehicleDays": powerUsable, "totalMileageKm": round(mileageTotal),
			"physicalHydrogenKg": round(physicalTotal), "standardLikeBalancedHydrogenKg": round(balancedTotal),
			"standardLikeMileageKm": round(balancedMileageTotal), "fleetPhysicalRateKgPer100Km": physicalRate, "fleetStandardLikeRateKgPer100Km": balancedRate,
		}
	}
	return map[string]any{"vehicleDays": len(rows), "byDate": byDate}
}

func writeCSV(path string, rows []row) {
	file, err := os.Create(path)
	if err != nil {
		panic(err)
	}
	defer file.Close()
	writer := csv.NewWriter(file)
	defer writer.Flush()
	headers := []string{"日期", "车牌", "VIN", "车型", "原始帧数", "当前质量状态", "当前质量原因", "加氢次数", "充电次数", "总里程km", "当前纯电里程km", "当前混动里程km", "物理耗氢kg", "当前SOC平衡氢量kg", "当前修正氢耗_按混动里程", "物理氢耗_按总里程", "全日起始SOC", "全日终止SOC", "全日SOC变化_末减初", "全日电池储能变化kWh", "电池等效氢量_16kWhkg", "标准式平衡氢量kg", "标准式平衡氢耗_按总里程", "标准式修正可用", "标准式修正说明", "电流积分电池净输出kWh", "燃料电池输出积分kWh", "电池能量贡献占比", "燃料电池能量贡献占比", "电池贡献里程km", "燃料电池贡献里程km", "按燃料电池贡献里程氢耗", "电池功率覆盖率", "燃料电池功率覆盖率", "外充状态帧数", "功率积分可用"}
	_ = writer.Write(headers)
	for _, value := range rows {
		_ = writer.Write([]string{
			value.Date, value.Plate, value.VIN, value.Model, integer(value.RawFrameCount), value.CurrentQuality, value.CurrentReason,
			integer(value.RefuelCount), integer(value.ChargeCount), decimal(value.TotalMileageKm), decimal(value.PureElectricMileageKm),
			decimal(value.CurrentMixedMileageKm), decimal(value.PhysicalHydrogenKg), decimal(value.CurrentSOCBalancedKg),
			decimal(value.CurrentRatePerMixedKm), decimal(value.PhysicalRatePerTotalKm), decimal(value.FullDayStartSOC),
			decimal(value.FullDayEndSOC), decimal(value.FullDaySOCChangePct), decimal(value.StoredEnergyChangeKWhSOC),
			decimal(value.BatteryEquivalentKgFixed16), decimal(value.StandardLikeBalancedKg), decimal(value.StandardLikeRatePerTotalKm),
			strconv.FormatBool(value.StandardLikeApplicable), value.StandardLikeReason,
			decimal(value.BatteryNetOutputKWhIntegrated), decimal(value.FuelCellOutputKWhIntegrated), decimal(value.BatteryEnergyShare),
			decimal(value.FuelCellEnergyShare), decimal(value.BatteryContributionKm), decimal(value.FuelCellContributionKm),
			decimal(value.HydrogenRatePerFCContributionKm), decimal(value.BatteryCoverageRatio), decimal(value.FuelCellCoverageRatio),
			integer(value.ExternalChargeFrameCount), strconv.FormatBool(value.PowerIntegrationUsable),
		})
	}
}

func uniqueDates(rows []row) []string {
	seen := map[string]bool{}
	for _, value := range rows {
		seen[value.Date] = true
	}
	dates := make([]string, 0, len(seen))
	for date := range seen {
		dates = append(dates, date)
	}
	sort.Strings(dates)
	return dates
}

func number(value any) (float64, bool) {
	switch typed := value.(type) {
	case float64:
		return typed, true
	case json.Number:
		parsed, err := typed.Float64()
		return parsed, err == nil
	case string:
		parsed, err := strconv.ParseFloat(strings.TrimSpace(typed), 64)
		return parsed, err == nil
	default:
		return 0, false
	}
}

func parseEventTime(value string) (time.Time, error) {
	location := time.FixedZone("CST", 8*3600)
	if parsed, err := time.ParseInLocation("2006-01-02 15:04:05.000", value, location); err == nil {
		return parsed, nil
	}
	return time.ParseInLocation("2006-01-02 15:04:05", value, location)
}

func mustDate(value string) time.Time {
	parsed, err := time.Parse("2006-01-02", value)
	if err != nil {
		panic(err)
	}
	return parsed
}

func mustReadJSON(path string, target any) {
	data, err := os.ReadFile(path)
	if err != nil {
		panic(err)
	}
	if err := json.Unmarshal(data, target); err != nil {
		panic(err)
	}
}

func writeJSON(path string, value any) {
	data, err := json.MarshalIndent(value, "", "  ")
	if err != nil {
		panic(err)
	}
	if err := os.WriteFile(path, data, 0o644); err != nil {
		panic(err)
	}
}

func round(value float64) float64  { return math.Round(value*1000) / 1000 }
func decimal(value float64) string { return strconv.FormatFloat(value, 'f', 3, 64) }
func integer(value int) string     { return strconv.Itoa(value) }