package main

import (
	"bytes"
	"compress/gzip"
	"crypto/sha256"
	"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"
	hydrogenKWh = 16.0
)

type candidate struct {
	VIN            string  `json:"vin"`
	StatDate       string  `json:"stat_date"`
	PlatformName   string  `json:"platform_name"`
	DailyMileageKm float64 `json:"daily_mileage_km"`
	RawTotal       int     `json:"raw_total"`
	Plate          string  `json:"plate,omitempty"`
	SampleNo       int     `json:"sample_no,omitempty"`
	MileageBin     int     `json:"mileage_bin,omitempty"`
	Model          string  `json:"model,omitempty"`
	TankCapacityL  float64 `json:"tank_capacity_l,omitempty"`
	BatteryKWh     float64 `json:"battery_capacity_kwh,omitempty"`
}

type capacityRecord struct {
	VIN, Plate, Model string
	TankCapacityL     float64
	Active            int
}

type rawFrame struct {
	TS             string         `json:"ts"`
	FrameID        string         `json:"frame_id"`
	EventID        string         `json:"event_id"`
	MessageID      int            `json:"message_id"`
	MessageIDHex   string         `json:"message_id_hex"`
	EventTime      string         `json:"event_time"`
	ReceivedAt     string         `json:"received_at"`
	RawSizeBytes   int            `json:"raw_size_bytes"`
	RawHex         string         `json:"raw_hex"`
	ParsedFields   map[string]any `json:"parsed_fields"`
	ParseStatus    string         `json:"parse_status"`
	SourceEndpoint string         `json:"source_endpoint"`
	Protocol       string         `json:"protocol"`
	VIN            string         `json:"vin"`
}

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

type dayOutput struct {
	Candidate           candidate                      `json:"candidate"`
	APIRawFrameCount    int                            `json:"apiRawFrameCount"`
	UniqueFrameCount    int                            `json:"uniqueFrameCount"`
	DuplicateFrameCount int                            `json:"duplicateFrameCount"`
	AlgorithmSamples    int                            `json:"algorithmSamples"`
	CriticalFieldRows   int                            `json:"criticalFieldRows"`
	EarliestEventTime   string                         `json:"earliestEventTime"`
	LatestEventTime     string                         `json:"latestEventTime"`
	RawArchiveFile      string                         `json:"rawArchiveFile"`
	RawArchiveSHA256    string                         `json:"rawArchiveSha256"`
	RawArchiveBytes     int64                          `json:"rawArchiveBytes"`
	Stat                openplatform.HydrogenDailyStat `json:"stat"`
}

func main() {
	if len(os.Args) != 5 && len(os.Args) != 6 {
		panic("usage: audit <vehicle-metadata.json> <start-date> <end-date> <output-dir> [source-archive-dir]")
	}
	metadataPath, startDate, endDate, outputDir := os.Args[1], os.Args[2], os.Args[3], os.Args[4]
	sourceArchiveDir := ""
	if len(os.Args) == 6 {
		sourceArchiveDir = os.Args[5]
	}
	start, err := time.Parse("2006-01-02", startDate)
	if err != nil {
		panic(err)
	}
	end, err := time.Parse("2006-01-02", endDate)
	if err != nil || end.Before(start) {
		panic("invalid date range")
	}
	var metadata []struct {
		VIN                string  `json:"vin"`
		Plate              string  `json:"plate"`
		Model              string  `json:"model"`
		TankCapacityL      float64 `json:"tank_capacity_l"`
		BatteryCapacityKWh float64 `json:"battery_capacity_kwh"`
	}
	mustReadJSON(metadataPath, &metadata)
	if len(metadata) == 0 {
		panic("vehicle metadata is empty")
	}
	selected := make([]candidate, 0, len(metadata)*int(end.Sub(start).Hours()/24+1))
	for day := start; !day.After(end); day = day.AddDate(0, 0, 1) {
		statDate := day.Format("2006-01-02")
		for _, item := range metadata {
			if len(strings.TrimSpace(item.VIN)) != 17 || item.TankCapacityL <= 0 || item.BatteryCapacityKWh <= 0 {
				continue
			}
			selected = append(selected, candidate{
				VIN: strings.ToUpper(strings.TrimSpace(item.VIN)), StatDate: statDate,
				Plate: item.Plate, Model: item.Model, TankCapacityL: item.TankCapacityL,
				BatteryKWh: item.BatteryCapacityKWh,
			})
		}
	}
	sort.Slice(selected, func(i, j int) bool {
		if selected[i].StatDate != selected[j].StatDate {
			return selected[i].StatDate < selected[j].StatDate
		}
		if selected[i].Plate != selected[j].Plate {
			return selected[i].Plate < selected[j].Plate
		}
		return selected[i].VIN < selected[j].VIN
	})
	for index := range selected {
		selected[index].SampleNo = index + 1
	}
	if sourceArchiveDir == "" {
		for day := start; !day.After(end); day = day.AddDate(0, 0, 1) {
			if err := os.MkdirAll(filepath.Join(outputDir, "raw", day.Format("2006-01-02")), 0o755); err != nil {
				panic(err)
			}
		}
	}
	writeJSON(filepath.Join(outputDir, "selected_vehicles.json"), selected)

	jobs := make(chan candidate)
	results := make(chan dayOutput)
	errs := make(chan error, len(selected))
	var wg sync.WaitGroup
	for i := 0; i < 12; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for c := range jobs {
				out, err := processDay(c, outputDir, sourceArchiveDir)
				if err != nil {
					errs <- err
					continue
				}
				results <- out
			}
		}()
	}
	go func() {
		for _, c := range selected {
			jobs <- c
		}
		close(jobs)
		wg.Wait()
		close(results)
		close(errs)
	}()
	outputs := make([]dayOutput, 0, len(selected))
	for out := range results {
		if out.APIRawFrameCount == 0 {
			continue
		}
		outputs = append(outputs, out)
		fmt.Fprintf(os.Stderr, "completed %03d %s %s raw=%d samples=%d quality=%s\n", out.Candidate.SampleNo, out.Candidate.Plate, out.Candidate.VIN, out.APIRawFrameCount, out.AlgorithmSamples, out.Stat.QualityStatus)
	}
	var allErrs []string
	for err := range errs {
		allErrs = append(allErrs, err.Error())
	}
	if len(allErrs) > 0 {
		panic(strings.Join(allErrs, "\n"))
	}
	sort.Slice(outputs, func(i, j int) bool { return outputs[i].Candidate.SampleNo < outputs[j].Candidate.SampleNo })
	writeJSON(filepath.Join(outputDir, "daily_results.json"), outputs)
	writeManifest(filepath.Join(outputDir, "raw_manifest.csv"), outputs)
	fmt.Printf("processed=%d raw_frames=%d algorithm_samples=%d intervals=%d\n", len(outputs), sumRaw(outputs), sumSamples(outputs), sumIntervals(outputs))
}

func stratifiedSelect(all []candidate, plateByVIN map[string]string, capacityByVIN map[string]capacityRecord) []candidate {
	general, cold := make([]candidate, 0), make([]candidate, 0)
	for _, c := range all {
		cap, ok := capacityByVIN[strings.ToUpper(c.VIN)]
		if !ok || cap.Active != 1 || c.DailyMileageKm < 10 || c.DailyMileageKm > 600 || c.RawTotal < 300 {
			continue
		}
		if cap.Model != "4.5吨货车" && cap.Model != "帕力安牌4.5吨冷链车" {
			continue
		}
		c.Plate = cap.Plate
		if c.Plate == "" {
			c.Plate = plateByVIN[strings.ToUpper(c.VIN)]
		}
		c.Model = cap.Model
		c.TankCapacityL = cap.TankCapacityL
		if cap.Model == "4.5吨货车" {
			general = append(general, c)
		} else {
			cold = append(cold, c)
		}
	}
	if len(general) < 41 || len(cold) < 59 {
		panic(fmt.Sprintf("insufficient pools general=%d cold=%d", len(general), len(cold)))
	}
	selected := append(selectEvenly(general, 41), selectEvenly(cold, 59)...)
	sort.Slice(selected, func(i, j int) bool {
		if selected[i].DailyMileageKm != selected[j].DailyMileageKm {
			return selected[i].DailyMileageKm < selected[j].DailyMileageKm
		}
		return selected[i].VIN < selected[j].VIN
	})
	for i := range selected {
		selected[i].SampleNo = i + 1
		selected[i].MileageBin = i/10 + 1
	}
	return selected
}

func selectEvenly(values []candidate, count int) []candidate {
	sort.Slice(values, func(i, j int) bool {
		if values[i].DailyMileageKm != values[j].DailyMileageKm {
			return values[i].DailyMileageKm < values[j].DailyMileageKm
		}
		return values[i].VIN < values[j].VIN
	})
	out := make([]candidate, 0, count)
	for i := 0; i < count; i++ {
		idx := 0
		if count > 1 {
			idx = int(math.Round(float64(i) * float64(len(values)-1) / float64(count-1)))
		}
		out = append(out, values[idx])
	}
	return out
}

func processDay(c candidate, outputDir, sourceArchiveDir string) (dayOutput, error) {
	archiveName := rawArchiveName(c)
	archivePath := filepath.Join(outputDir, "raw", c.StatDate, archiveName)
	readArchivePath := archivePath
	if sourceArchiveDir != "" {
		readArchivePath = filepath.Join(sourceArchiveDir, "raw", c.StatDate, archiveName)
		if _, statErr := os.Stat(readArchivePath); os.IsNotExist(statErr) {
			// Sample numbers depend on the selected vehicle/date set. Reuse an
			// existing archive by its stable plate/VIN/date suffix when rerunning
			// only a small subset for validation.
			pattern := filepath.Join(sourceArchiveDir, "raw", c.StatDate, "*_"+c.Plate+"_"+c.VIN+"_"+c.StatDate+".csv.gz")
			if matches, _ := filepath.Glob(pattern); len(matches) == 1 {
				readArchivePath = matches[0]
			}
		}
	}
	frames := []rawFrame(nil)
	total := 0
	var err error
	if _, statErr := os.Stat(readArchivePath); statErr == nil {
		frames, err = readRawArchive(readArchivePath)
		total = len(frames)
	} else if sourceArchiveDir != "" && os.IsNotExist(statErr) {
		return dayOutput{Candidate: c}, nil
	} else {
		for attempt := 1; attempt <= 3; attempt++ {
			frames, total, err = fetchFrames(c.VIN, c.StatDate)
			if err == nil {
				break
			}
			if attempt < 3 {
				time.Sleep(time.Duration(attempt) * time.Second)
			}
		}
	}
	if err != nil {
		return dayOutput{}, fmt.Errorf("%s %s: %w", c.StatDate, c.VIN, err)
	}
	if total == 0 {
		return dayOutput{Candidate: c}, nil
	}
	sort.SliceStable(frames, func(i, j int) bool {
		if frames[i].EventTime != frames[j].EventTime {
			return frames[i].EventTime < frames[j].EventTime
		}
		if frames[i].SourceEndpoint != frames[j].SourceEndpoint {
			return frames[i].SourceEndpoint < frames[j].SourceEndpoint
		}
		return frames[i].TS < frames[j].TS
	})
	seen := map[string]bool{}
	duplicateFrames := 0
	observations := make([]openplatform.HydrogenObservation, 0, len(frames))
	criticalRows := 0
	for _, f := range frames {
		if f.FrameID != "" {
			if seen[f.FrameID] {
				duplicateFrames++
			}
			seen[f.FrameID] = true
		}
		obs, ok, critical := observationFromFrame(f, c.TankCapacityL, c.StatDate)
		if critical {
			criticalRows++
		}
		if ok {
			observations = append(observations, obs)
		}
	}
	params := map[string]openplatform.HydrogenCalculationParameters{c.VIN: {BatteryCapacityKWh: c.BatteryKWh, HydrogenEnergyKWhKg: hydrogenKWh}}
	stats := openplatform.BuildHydrogenDailyStatsOrderedWithParameters(observations, c.StatDate, 0.05, 20, params)
	var stat openplatform.HydrogenDailyStat
	if len(stats) == 1 {
		stat = stats[0]
	} else {
		stat = openplatform.HydrogenDailyStat{VIN: c.VIN, Date: c.StatDate, SampleCount: len(observations), QualityStatus: "NO_DATA", QualityReason: "无有效压力温度样本"}
	}
	roles := map[string]string{}
	for _, interval := range stat.Intervals {
		appendRole(roles, interval.StartEventID, fmt.Sprintf("运行区间%d(%s)起点", interval.Index, interval.Type))
		appendRole(roles, interval.EndEventID, fmt.Sprintf("运行区间%d(%s)终点", interval.Index, interval.Type))
	}
	for _, interval := range stat.HydrogenIntervals {
		appendRole(roles, interval.StartEventID, fmt.Sprintf("氢量分段%d起点", interval.Index))
		appendRole(roles, interval.EndEventID, fmt.Sprintf("氢量分段%d终点", interval.Index))
	}
	// Even when the original frames are reused, rewrite the audit CSV so its
	// “计算角色/排除原因” column matches the current algorithm version and
	// interval boundaries. The original HEX and parsed fields remain unchanged.
	if sourceArchiveDir == "" {
		if err := writeRawCSV(archivePath, c, frames, roles); err != nil {
			return dayOutput{}, err
		}
	}
	checksum, size, err := fileSHA256(readArchivePath)
	if err != nil {
		return dayOutput{}, err
	}
	out := dayOutput{Candidate: c, APIRawFrameCount: total, UniqueFrameCount: len(seen), DuplicateFrameCount: duplicateFrames, AlgorithmSamples: len(observations), CriticalFieldRows: criticalRows, RawArchiveFile: filepath.ToSlash(filepath.Join("raw", c.StatDate, archiveName)), RawArchiveSHA256: checksum, RawArchiveBytes: size, Stat: stat}
	if len(frames) > 0 {
		out.EarliestEventTime = frames[0].EventTime
		out.LatestEventTime = frames[len(frames)-1].EventTime
	}
	return out, nil
}

func rawArchiveName(c candidate) string {
	return fmt.Sprintf("%04d_%s_%s_%s.csv.gz", c.SampleNo, safeName(c.Plate), c.VIN, c.StatDate)
}

func appendRole(roles map[string]string, eventID, role string) {
	if eventID == "" {
		return
	}
	if roles[eventID] == "" {
		roles[eventID] = role
		return
	}
	roles[eventID] += "；" + role
}

func fileSHA256(path string) (string, int64, error) {
	file, err := os.Open(path)
	if err != nil {
		return "", 0, err
	}
	defer file.Close()
	hash := sha256.New()
	size, err := io.Copy(hash, file)
	if err != nil {
		return "", 0, err
	}
	return fmt.Sprintf("%x", hash.Sum(nil)), size, nil
}

func readRawArchive(path string) ([]rawFrame, error) {
	file, err := os.Open(path)
	if err != nil {
		return nil, err
	}
	defer file.Close()
	gz, err := gzip.NewReader(file)
	if err != nil {
		return nil, err
	}
	defer gz.Close()
	reader := csv.NewReader(gz)
	rows, err := reader.ReadAll()
	if err != nil {
		return nil, err
	}
	if len(rows) == 0 {
		return nil, fmt.Errorf("empty raw archive %s", path)
	}
	columns := map[string]int{}
	for index, name := range rows[0] {
		columns[name] = index
	}
	cell := func(row []string, name string) string {
		index, ok := columns[name]
		if !ok || index >= len(row) {
			return ""
		}
		return row[index]
	}
	frames := make([]rawFrame, 0, len(rows)-1)
	for _, row := range rows[1:] {
		fields := map[string]any{}
		if rawFields := cell(row, "完整解析字段JSON"); rawFields != "" {
			_ = json.Unmarshal([]byte(rawFields), &fields)
		}
		messageID, _ := strconv.Atoi(cell(row, "消息ID"))
		rawSize, _ := strconv.Atoi(cell(row, "原始字节数"))
		frames = append(frames, rawFrame{
			FrameID: cell(row, "帧ID"), EventID: cell(row, "事件ID"), MessageID: messageID,
			MessageIDHex: cell(row, "消息ID_HEX"), EventTime: cell(row, "事件时间"), ReceivedAt: cell(row, "接收时间"),
			RawSizeBytes: rawSize, RawHex: cell(row, "原始报文HEX"), ParsedFields: fields,
			ParseStatus: cell(row, "解析状态"), SourceEndpoint: cell(row, "源端点"), Protocol: "GB32960", VIN: cell(row, "VIN"),
		})
	}
	return frames, nil
}

func fetchFrames(vin, statDate string) ([]rawFrame, int, error) {
	const limit = 500
	first, err := fetchPage(vin, statDate, 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, statDate, offset, limit, false)
		if err != nil {
			return nil, 0, 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, statDate string, offset, limit int, includeTotal bool) (rawResponse, error) {
	q := url.Values{"protocol": {"GB32960"}, "vin": {vin}, "dateFrom": {statDate + " 00:00:00"}, "dateTo": {statDate + " 23:59:59"}, "orderBy": {"eventTime"}, "limit": {strconv.Itoa(limit)}, "offset": {strconv.Itoa(offset)}, "includeFields": {"true"}, "includePayload": {"true"}, "includeTotal": {strconv.FormatBool(includeTotal)}}
	req, _ := http.NewRequest(http.MethodGet, baseURL+"/api/history/raw-frames?"+q.Encode(), nil)
	req.Header.Set("Accept-Encoding", "gzip")
	client := &http.Client{Timeout: 90 * time.Second}
	res, err := client.Do(req)
	if err != nil {
		return rawResponse{}, err
	}
	defer res.Body.Close()
	if res.StatusCode != http.StatusOK {
		body, _ := io.ReadAll(res.Body)
		if res.StatusCode == http.StatusInternalServerError && bytes.Contains(body, []byte("Table does not exist")) {
			return rawResponse{}, nil
		}
		return rawResponse{}, fmt.Errorf("HTTP %d: %s", res.StatusCode, body)
	}
	var reader io.Reader = res.Body
	if res.Header.Get("Content-Encoding") == "gzip" {
		gz, err := gzip.NewReader(res.Body)
		if err != nil {
			return rawResponse{}, err
		}
		defer gz.Close()
		reader = gz
	}
	var out rawResponse
	if err := json.NewDecoder(reader).Decode(&out); err != nil {
		return rawResponse{}, err
	}
	return out, nil
}

func observationFromFrame(f rawFrame, tankCapacity float64, statDate string) (openplatform.HydrogenObservation, bool, bool) {
	if f.MessageID != 2 || f.ParseStatus != "OK" {
		return openplatform.HydrogenObservation{}, false, false
	}
	pressure, pok := num(f.ParsedFields["gb32960.fuel_cell.max_hydrogen_pressure_mpa"])
	temp, tok := num(f.ParsedFields["gb32960.fuel_cell.max_hydrogen_temperature_c"])
	critical := pok && tok
	if !pok || !tok || pressure <= 0 || pressure > 70 || temp <= -40 || temp > 726.85 {
		return openplatform.HydrogenObservation{}, false, critical
	}
	mass, ok := openplatform.PressureHydrogenMassKg(pressure, temp, tankCapacity)
	if !ok {
		return openplatform.HydrogenObservation{}, false, critical
	}
	step, _ := openplatform.PressureHydrogenMassKg(math.Max(0, pressure-0.2), temp, tankCapacity)
	parsed, _ := json.Marshal(f.ParsedFields)
	_, _, active, known, _ := openplatform.ExtractHydrogenTelemetry(string(parsed))
	t, err := parseEventTime(f.EventTime)
	if err != nil || t.Format("2006-01-02") != statDate {
		return openplatform.HydrogenObservation{}, false, critical
	}
	o := openplatform.HydrogenObservation{VIN: f.VIN, Source: f.SourceEndpoint, EventID: f.EventID, ObservedAt: t, MassKg: mass, TankCapacityLiter: tankCapacity, PressureMPa: pressure, TemperatureC: temp, NoiseKg: math.Min(1, math.Max(0.05, mass-step)), RefuelThresholdKg: math.Max(1, mass*0.05), FuelCellActive: active, FuelCellStateKnown: known}
	if voltage, vok := num(f.ParsedFields["gb32960.fuel_cell.fuel_cell_voltage_v"]); vok && voltage > 0 && voltage <= 1000 {
		if current, cok := num(f.ParsedFields["gb32960.fuel_cell.fuel_cell_current_a"]); cok && current >= 0 && current <= 2000 {
			o.FuelCellVoltageV = voltage
			o.FuelCellCurrentA = current
			o.FuelCellPowerKnown = true
		}
	}
	if v, ok := num(f.ParsedFields["gb32960.vehicle.soc_percent"]); ok && v >= 0 && v <= 100 {
		o.SOCPercent = v
		o.SOCKnown = true
	}
	if v, ok := num(f.ParsedFields["gb32960.vehicle.total_mileage_km"]); ok && v >= 0 {
		o.MileageKm = v
		o.MileageKnown = true
	}
	if v, ok := num(f.ParsedFields["gb32960.vehicle.vehicle_status"]); ok {
		o.VehicleState = int(v)
		o.VehicleStateKnown = v >= 0 && v <= 255
	}
	if v, ok := num(f.ParsedFields["gb32960.vehicle.charge_status"]); ok {
		o.ChargeState = int(v)
		o.ChargeStateKnown = v >= 0 && v <= 255
	}
	if v, ok := num(f.ParsedFields["gb32960.vehicle.running_mode"]); ok {
		o.RunningMode = int(v)
		o.RunningModeKnown = v >= 0 && v <= 255
	}
	return o, true, critical
}

var rawHeaders = []string{"序号", "车牌", "VIN", "统计日期", "车型", "储氢总容积(L)", "额定电量(kWh)", "事件时间", "接收时间", "帧ID", "事件ID", "消息ID", "消息ID_HEX", "源端点", "解析状态", "原始字节数", "原始报文HEX", "完整解析字段JSON", "最高氢压(MPa)", "最高氢温(℃)", "电池SOC(%)", "仪表总里程(km)", "车辆状态", "充电状态", "运行模式", "燃料电池工作状态", "燃料电池电流(A)", "车端氢气质量(kg)", "系统压力换算剩余氢量(kg)", "噪声阈值(kg)", "是否算法有效样本", "计算角色/排除原因"}

func writeRawCSV(path string, c candidate, frames []rawFrame, roles map[string]string) error {
	f, err := os.Create(path)
	if err != nil {
		return err
	}
	defer f.Close()
	gz := gzip.NewWriter(f)
	defer gz.Close()
	w := csv.NewWriter(gz)
	defer w.Flush()
	if err := w.Write(rawHeaders); err != nil {
		return err
	}
	for _, rf := range frames {
		o, valid, _ := observationFromFrame(rf, c.TankCapacityL, c.StatDate)
		role := roles[rf.EventID]
		if !valid {
			if t, err := parseEventTime(rf.EventTime); err == nil && t.Format("2006-01-02") != c.StatDate {
				role = "事件时间不在统计日，不进入计算"
			} else if rf.MessageID != 2 {
				role = "非实时信息上报帧，不进入计算"
			} else if rf.ParseStatus != "OK" {
				role = "解析状态非OK，不进入计算"
			} else {
				role = "压力/温度无效或缺失，不进入计算"
			}
		} else if role == "" {
			role = "有效候选帧（由分段规则判定）"
		}
		parsedJSON, _ := json.Marshal(rf.ParsedFields)
		row := []string{fmt.Sprintf("%04d", c.SampleNo), c.Plate, c.VIN, c.StatDate, c.Model, strconv.FormatFloat(c.TankCapacityL, 'f', 2, 64), strconv.FormatFloat(c.BatteryKWh, 'f', 2, 64), rf.EventTime, rf.ReceivedAt, rf.FrameID, rf.EventID, strconv.Itoa(rf.MessageID), rf.MessageIDHex, rf.SourceEndpoint, rf.ParseStatus, strconv.Itoa(rf.RawSizeBytes), rf.RawHex, string(parsedJSON), val(rf.ParsedFields, "gb32960.fuel_cell.max_hydrogen_pressure_mpa"), val(rf.ParsedFields, "gb32960.fuel_cell.max_hydrogen_temperature_c"), val(rf.ParsedFields, "gb32960.vehicle.soc_percent"), val(rf.ParsedFields, "gb32960.vehicle.total_mileage_km"), val(rf.ParsedFields, "gb32960.vehicle.vehicle_status"), val(rf.ParsedFields, "gb32960.vehicle.charge_status"), val(rf.ParsedFields, "gb32960.vehicle.running_mode"), val(rf.ParsedFields, "gb32960.gd_fc_stack.engine_work_state"), val(rf.ParsedFields, "gb32960.fuel_cell.fuel_cell_current_a"), val(rf.ParsedFields, "gb32960.gd_fc_vehicle_info.hydrogen_mass_kg"), blankFloat(valid, o.MassKg), blankFloat(valid, o.NoiseKg), yesNo(valid), role}
		if err := w.Write(row); err != nil {
			return err
		}
	}
	return w.Error()
}

func writeManifest(path string, outputs []dayOutput) {
	f, err := os.Create(path)
	if err != nil {
		panic(err)
	}
	defer f.Close()
	w := csv.NewWriter(f)
	defer w.Flush()
	_ = w.Write([]string{"序号", "车牌", "VIN", "日期", "车型", "储氢总容积(L)", "额定电量(kWh)", "API原始帧数", "唯一帧数", "重复帧数", "算法样本数", "关键字段帧数", "最早事件时间", "最晚事件时间", "原始文件", "压缩包SHA256", "压缩字节数", "质量状态", "质量原因"})
	for _, o := range outputs {
		_ = w.Write([]string{fmt.Sprintf("%04d", o.Candidate.SampleNo), o.Candidate.Plate, o.Candidate.VIN, o.Candidate.StatDate, o.Candidate.Model, strconv.FormatFloat(o.Candidate.TankCapacityL, 'f', 2, 64), strconv.FormatFloat(o.Candidate.BatteryKWh, 'f', 2, 64), strconv.Itoa(o.APIRawFrameCount), strconv.Itoa(o.UniqueFrameCount), strconv.Itoa(o.DuplicateFrameCount), strconv.Itoa(o.AlgorithmSamples), strconv.Itoa(o.CriticalFieldRows), o.EarliestEventTime, o.LatestEventTime, o.RawArchiveFile, o.RawArchiveSHA256, strconv.FormatInt(o.RawArchiveBytes, 10), o.Stat.QualityStatus, o.Stat.QualityReason})
	}
}

func num(v any) (float64, bool) {
	switch x := v.(type) {
	case float64:
		return x, true
	case string:
		n, e := strconv.ParseFloat(strings.TrimSpace(x), 64)
		return n, e == nil
	case json.Number:
		n, e := x.Float64()
		return n, e == nil
	default:
		return 0, false
	}
}
func val(m map[string]any, k string) string {
	if v, ok := m[k]; ok {
		return fmt.Sprint(v)
	}
	return ""
}
func blankFloat(ok bool, v float64) string {
	if !ok {
		return ""
	}
	return strconv.FormatFloat(v, 'f', 6, 64)
}
func yesNo(v bool) string {
	if v {
		return "是"
	}
	return "否"
}
func safeName(v string) string {
	v = strings.TrimSpace(v)
	if v == "" {
		return "无车牌"
	}
	return strings.NewReplacer("/", "_", "\\", "_", " ", "_").Replace(v)
}
func parseEventTime(value string) (time.Time, error) {
	loc := time.FixedZone("CST", 8*3600)
	if t, e := time.ParseInLocation("2006-01-02 15:04:05.000", value, loc); e == nil {
		return t, nil
	}
	return time.ParseInLocation("2006-01-02 15:04:05", value, loc)
}
func mustReadJSON(path string, v any) {
	b, e := os.ReadFile(path)
	if e != nil {
		panic(e)
	}
	if e = json.Unmarshal(b, v); e != nil {
		panic(e)
	}
}
func writeJSON(path string, v any) {
	b, e := json.MarshalIndent(v, "", "  ")
	if e != nil {
		panic(e)
	}
	if e = os.WriteFile(path, b, 0o644); e != nil {
		panic(e)
	}
}
func sumRaw(v []dayOutput) int {
	n := 0
	for _, x := range v {
		n += x.APIRawFrameCount
	}
	return n
}
func sumSamples(v []dayOutput) int {
	n := 0
	for _, x := range v {
		n += x.AlgorithmSamples
	}
	return n
}
func sumIntervals(v []dayOutput) int {
	n := 0
	for _, x := range v {
		n += len(x.Stat.Intervals)
	}
	return n
}