csv.go

package ulogo

import (
	"encoding/csv"
	"fmt"
	"io"
	"os"
	"path/filepath"
	"sort"
	"strconv"
	"strings"
)

// ConvertULogToCSV writes one CSV file per dataset, matching pyulog's file naming.
func ConvertULogToCSV(filename string, messageNames []string, outputDir string, delimiter rune, startSec, endSec int) ([]string, error) {
	var opts []Option
	if messageNames != nil {
		opts = append(opts, WithMessageFilter(messageNames))
	}
	log, err := Load(filename, opts...)
	if err != nil {
		return nil, err
	}

	prefix := filename
	if strings.EqualFold(filepath.Ext(prefix), ".ulg") {
		prefix = strings.TrimSuffix(prefix, filepath.Ext(prefix))
	}
	if outputDir != "" {
		prefix = filepath.Join(outputDir, filepath.Base(prefix))
	}

	var written []string
	for _, dataset := range log.Data {
		name := strings.ReplaceAll(dataset.Name, "/", "_")
		outputName := fmt.Sprintf("%s_%s_%d.csv", prefix, name, dataset.MultiID)
		file, err := os.Create(outputName)
		if err != nil {
			return written, err
		}
		err = WriteDatasetCSV(file, dataset, delimiter, startSec, endSec)
		closeErr := file.Close()
		if err != nil {
			return written, err
		}
		if closeErr != nil {
			return written, closeErr
		}
		written = append(written, outputName)
	}
	sort.Strings(written)
	return written, nil
}

// WriteDatasetCSV writes one dataset as CSV.
func WriteDatasetCSV(writer io.Writer, dataset Dataset, delimiter rune, startSec, endSec int) error {
	cw := csv.NewWriter(writer)
	cw.Comma = delimiter

	columns, charArrays := datasetCSVColumns(dataset)
	if err := cw.Write(columns); err != nil {
		return err
	}

	startUS := uint64(0)
	if startSec > 0 {
		startUS = uint64(startSec) * 1_000_000
	}
	endUS := uint64(0)
	if endSec > 0 {
		endUS = uint64(endSec) * 1_000_000
	}

	for _, row := range dataset.Rows {
		if row.Timestamp < startUS {
			continue
		}
		if endUS > 0 && row.Timestamp >= endUS {
			continue
		}
		record := make([]string, len(columns))
		for i, column := range columns {
			if size, ok := charArrays[column]; ok {
				record[i] = readCharArray(dataset, row, column, size)
				continue
			}
			value, ok := dataset.ValueByName(row, column)
			if !ok {
				return fmt.Errorf("missing field %q in dataset %s", column, dataset.Name)
			}
			record[i] = value.String()
		}
		if err := cw.Write(record); err != nil {
			return err
		}
	}
	cw.Flush()
	return cw.Error()
}

func datasetCSVColumns(dataset Dataset) ([]string, map[string]int) {
	columns := make([]string, 0, len(dataset.Fields))
	charArrays := map[string]int{}
	seen := map[string]struct{}{}

	for _, field := range dataset.Fields {
		if isPaddingField(field.Name) {
			continue
		}
		base, index, ok := splitArrayField(field.Name)
		if ok && field.Type == "char" {
			if index+1 > charArrays[base] {
				charArrays[base] = index + 1
			}
			if index == 0 {
				columns = append(columns, base)
				seen[base] = struct{}{}
			}
			continue
		}
		if _, ok := seen[field.Name]; ok {
			continue
		}
		columns = append(columns, field.Name)
		seen[field.Name] = struct{}{}
	}

	for i, column := range columns {
		if column == "timestamp" {
			copy(columns[1:i+1], columns[:i])
			columns[0] = "timestamp"
			break
		}
	}
	return columns, charArrays
}

func readCharArray(dataset Dataset, row Row, base string, size int) string {
	var builder strings.Builder
	for i := 0; i < size; i++ {
		value, ok := dataset.ValueByName(row, base+"["+strconv.Itoa(i)+"]")
		if !ok {
			break
		}
		ch, ok := value.Any.(uint8)
		if !ok {
			break
		}
		if ch == 0 {
			break
		}
		builder.WriteByte(ch)
	}
	return builder.String()
}

func splitArrayField(name string) (string, int, bool) {
	open := strings.LastIndexByte(name, '[')
	close := strings.LastIndexByte(name, ']')
	if open < 0 || close != len(name)-1 || open > close {
		return "", 0, false
	}
	index, err := strconv.Atoi(name[open+1 : close])
	if err != nil {
		return "", 0, false
	}
	return name[:open], index, true
}

func isPaddingField(name string) bool {
	if strings.HasPrefix(name, "_padding") {
		return true
	}
	return strings.Contains(name, "._padding")
}