using System.Globalization; using System.Security.Cryptography; using System.Text; using TuneBoss.Core.Models; namespace TuneBoss.Core.IO; /// /// Reader/writer for the TuneBoss .fsr configuration format (v1) — a /// text-based, self-describing container for a full ECU tuning configuration. /// See FSR_FORMAT_SPEC.md for the authoritative specification. /// /// This type is model-based and standalone: it (de)serialises the actual table /// models, so it does not depend on the app's nav-tree/codec plumbing. /// public static class FsrFile { public const int FormatVersion = 1; // ── Public data structures ────────────────────────────────────────────── public sealed class FsrDocument { public FsrHeader Header { get; set; } = new(); public List Sections { get; } = new(); public FsrSection? Find(string name) => Sections.FirstOrDefault(s => string.Equals(s.Name, name, StringComparison.OrdinalIgnoreCase)); } public sealed class FsrHeader { public int FsrVersion { get; set; } = FormatVersion; public string Generator { get; set; } = ""; public string CreatedUtc { get; set; } = ""; public string CreatorId { get; set; } = ""; public int FwVersion { get; set; } public int HwVersion { get; set; } public int Make { get; set; } public int Model { get; set; } public int Cylinders { get; set; } = 1; public int Generation { get; set; } = 3; public string SaveType { get; set; } = "full_config"; public string Note { get; set; } = "none"; // Modification tags public string ModEngineBlock { get; set; } = "none"; public string ModCamshaft { get; set; } = "none"; public string ModExhaust { get; set; } = "none"; public string ModAirFilter { get; set; } = "none"; public string ModCylinderHead { get; set; } = "none"; public string ModInjector { get; set; } = "none"; public string ModThrottleBody { get; set; } = "none"; public string ModJackRod { get; set; } = "none"; /// Any header keys not recognised — preserved on round-trip. public Dictionary Extra { get; } = new(StringComparer.OrdinalIgnoreCase); } public enum SectionType { Table2D, Table1D, SubTable, Afr, Misc, Unknown } public sealed class FsrSection { public SectionType Type { get; set; } public string TypeToken { get; set; } = ""; // raw token, preserves Unknown public string Name { get; set; } = ""; // stable feature key public string Label { get; set; } = ""; public ushort Addr { get; set; } public byte Length { get; set; } // last-inclusive-offset (bytes-1) public int Gen { get; set; } // Exactly one of these is populated depending on Type. public TuningTable? Table2D { get; set; } public AfrTable? Afr { get; set; } public OneDimTable? Table1D { get; set; } public SubTable? Sub { get; set; } public byte[]? MiscBytes { get; set; } /// Raw field lines for Unknown sections / unrecognised keys. public Dictionary Extra { get; } = new(StringComparer.OrdinalIgnoreCase); } // ════════════════════════════════════════════════════════════════════════ // WRITE // ════════════════════════════════════════════════════════════════════════ /// Serialises a document to .fsr text (with an optional whole-body sha256). public static string Write(FsrDocument doc, bool includeSha256 = true) { var body = new StringBuilder(); WriteHeader(body, doc.Header); body.Append('\n'); foreach (var s in doc.Sections) WriteSection(body, s); if (!includeSha256) return body.ToString(); // sha256 covers everything after the sha256 line — write header line first. string bodyText = body.ToString(); string hash = Sha256Hex(bodyText); return $"# integrity\nsha256 = {hash}\n{bodyText}"; } private static void WriteHeader(StringBuilder sb, FsrHeader h) { sb.Append("# TuneBoss configuration — .fsr v").Append(h.FsrVersion).Append('\n'); void F(string k, object v) => sb.Append(k).Append(" = ").Append(v).Append('\n'); F("fsr_version", h.FsrVersion); if (!string.IsNullOrEmpty(h.Generator)) F("generator", h.Generator); if (!string.IsNullOrEmpty(h.CreatedUtc)) F("created_utc", h.CreatedUtc); F("creator_id", h.CreatorId); F("fw_version", h.FwVersion); F("hw_version", h.HwVersion); F("make", h.Make); F("model", h.Model); F("cylinders", h.Cylinders); F("generation", h.Generation); F("save_type", h.SaveType); F("mod_engine_block", h.ModEngineBlock); F("mod_camshaft", h.ModCamshaft); F("mod_exhaust", h.ModExhaust); F("mod_air_filter", h.ModAirFilter); F("mod_cylinder_head", h.ModCylinderHead); F("mod_injector", h.ModInjector); F("mod_throttle_body", h.ModThrottleBody); F("mod_jack_rod", h.ModJackRod); F("note", h.Note); foreach (var kv in h.Extra) F(kv.Key, kv.Value); } private static void WriteSection(StringBuilder sb, FsrSection s) { string typeToken = s.Type switch { SectionType.Table2D => "TABLE2D", SectionType.Afr => "AFR", SectionType.Table1D => "TABLE1D", SectionType.SubTable => "SUBTABLE", SectionType.Misc => "MISC", _ => s.TypeToken, }; sb.Append('[').Append(typeToken).Append(' ').Append(s.Name).Append("]\n"); void F(string k, object v) => sb.Append(k).Append(" = ").Append(v).Append('\n'); F("label", s.Label); F("addr", Hex16(s.Addr)); F("length", Hex8(s.Length)); if (s.Gen != 0) F("gen", s.Gen); switch (s.Type) { case SectionType.Table2D when s.Table2D is { } t: Write2D(sb, t.Data, t.RpmAxis, t.LoadAxis, t.Sign, t.MaxRaw, t.MinRaw, t.Mult); break; case SectionType.Afr when s.Afr is { } a: Write2D(sb, a.Data, a.RpmAxis, a.LoadAxis, a.Sign, a.MaxRaw, a.MinRaw, a.Mult); break; case SectionType.Table1D when s.Table1D is { } o: Write1D(sb, o); break; case SectionType.SubTable when s.Sub is { } sub: WriteSub(sb, sub); break; case SectionType.Misc when s.MiscBytes is { } b: WriteBytes(sb, b); break; default: foreach (var kv in s.Extra) F(kv.Key, kv.Value); break; } sb.Append('\n'); } private static void Write2D(StringBuilder sb, byte[] data, byte[] rpm, byte[] load, byte sign, byte maxRaw, byte minRaw, byte mult) { sb.Append("signed = ").Append(sign > 0 ? 1 : 0).Append('\n'); sb.Append("mult = ").Append(mult).Append('\n'); sb.Append("max_raw = ").Append(maxRaw).Append('\n'); sb.Append("min_raw = ").Append(minRaw).Append('\n'); sb.Append("rpm_axis = ").Append(HexBytes(rpm)).Append('\n'); sb.Append("load_axis = ").Append(HexBytes(load)).Append('\n'); for (int r = 0; r < TuningTable.Rows; r++) { sb.Append("row").Append(r).Append(" = "); for (int c = 0; c < TuningTable.Cols; c++) { if (c > 0) sb.Append(' '); sb.Append(Hex8(data[r * TuningTable.Cols + c])); } sb.Append('\n'); } } private static void Write1D(StringBuilder sb, OneDimTable o) { sb.Append("raw_signed = ").Append(o.RawSignedFlag > 0 ? 1 : 0).Append('\n'); sb.Append("conv_signed = ").Append(o.ConvSignedFlag > 0 ? 1 : 0).Append('\n'); sb.Append("raw_mult = ").Append(o.RawMultiplier).Append('\n'); sb.Append("conv_mult = ").Append(o.ConvMultiplier).Append('\n'); sb.Append("raw_round = ").Append(o.RawRounding).Append('\n'); sb.Append("conv_offset = ").Append((int)o.ConvOffset).Append('\n'); sb.Append("max_raw = ").Append(o.MaxRaw).Append('\n'); sb.Append("min_raw = ").Append(o.MinRaw).Append('\n'); for (int i = 0; i < OneDimTable.PointCount; i++) sb.Append('p').Append(i).Append(" = ").Append(o.RawAxis[i]).Append(", ").Append(o.ConvValues[i]).Append('\n'); } private static void WriteSub(StringBuilder sb, SubTable sub) { for (int r = 0; r < SubTable.Rows; r++) { sb.Append("row").Append(r).Append(" = "); for (int c = 0; c < SubTable.Cols; c++) { if (c > 0) sb.Append(", "); sb.Append((int)unchecked((sbyte)sub.Data[r * SubTable.Cols + c])); } sb.Append('\n'); } } private static void WriteBytes(StringBuilder sb, byte[] bytes) { const int perLine = 32; for (int off = 0; off < bytes.Length; off += perLine) { int n = Math.Min(perLine, bytes.Length - off); sb.Append("bytes = "); for (int i = 0; i < n; i++) { if (i > 0) sb.Append(' '); sb.Append(Hex8(bytes[off + i])); } sb.Append('\n'); } } // ════════════════════════════════════════════════════════════════════════ // READ // ════════════════════════════════════════════════════════════════════════ public static FsrDocument Read(string text) { var doc = new FsrDocument(); FsrSection? cur = null; var secFields = new Dictionary(StringComparer.OrdinalIgnoreCase); var rowLines = new List<(string key, string val)>(); void Flush() { if (cur == null) return; BuildSection(cur, secFields, rowLines); doc.Sections.Add(cur); secFields = new(StringComparer.OrdinalIgnoreCase); rowLines = new(); } foreach (var raw in text.Split('\n')) { var line = raw.TrimEnd('\r'); var t = line.TrimStart(); if (t.Length == 0 || t[0] == '#') continue; if (t[0] == '[') { Flush(); int close = t.IndexOf(']'); var inner = (close > 0 ? t[1..close] : t[1..]).Trim(); int sp = inner.IndexOf(' '); string typeTok = sp > 0 ? inner[..sp] : inner; string name = sp > 0 ? inner[(sp + 1)..].Trim() : ""; cur = new FsrSection { TypeToken = typeTok, Type = ParseType(typeTok), Name = name }; continue; } int eq = line.IndexOf('='); if (eq < 0) continue; string key = line[..eq].Trim(); string val = line[(eq + 1)..].Trim(); if (cur == null) { ApplyHeader(doc.Header, key, val); continue; } // Row-style keys accumulate (rowN, pN, bytes); everything else is a field. if (IsRowKey(key)) rowLines.Add((key, val)); else secFields[key] = val; } Flush(); return doc; } private static bool IsRowKey(string k) => k.StartsWith("row", StringComparison.OrdinalIgnoreCase) || (k.Length >= 2 && (k[0] == 'p' || k[0] == 'P') && char.IsDigit(k[1])) || k.Equals("bytes", StringComparison.OrdinalIgnoreCase); private static SectionType ParseType(string tok) => tok.ToUpperInvariant() switch { "TABLE2D" => SectionType.Table2D, "AFR" => SectionType.Afr, "TABLE1D" => SectionType.Table1D, "SUBTABLE" => SectionType.SubTable, "MISC" => SectionType.Misc, _ => SectionType.Unknown, }; private static void ApplyHeader(FsrHeader h, string key, string val) { switch (key.ToLowerInvariant()) { case "fsr_version": h.FsrVersion = ParseInt(val); break; case "generator": h.Generator = val; break; case "created_utc": h.CreatedUtc = val; break; case "creator_id": h.CreatorId = val; break; case "fw_version": h.FwVersion = ParseInt(val); break; case "hw_version": h.HwVersion = ParseInt(val); break; case "make": h.Make = ParseInt(val); break; case "model": h.Model = ParseInt(val); break; case "cylinders": h.Cylinders = ParseInt(val); break; case "generation": h.Generation = ParseInt(val); break; case "save_type": h.SaveType = val; break; case "note": h.Note = val; break; case "mod_engine_block": h.ModEngineBlock = val; break; case "mod_camshaft": h.ModCamshaft = val; break; case "mod_exhaust": h.ModExhaust = val; break; case "mod_air_filter": h.ModAirFilter = val; break; case "mod_cylinder_head": h.ModCylinderHead = val; break; case "mod_injector": h.ModInjector = val; break; case "mod_throttle_body": h.ModThrottleBody = val; break; case "mod_jack_rod": h.ModJackRod = val; break; case "sha256": break; // integrity only; not structural default: h.Extra[key] = val; break; // forward-compat } } private static void BuildSection(FsrSection s, Dictionary f, List<(string key, string val)> rows) { s.Label = f.GetValueOrDefault("label", s.Name); s.Addr = (ushort)ParseInt(f.GetValueOrDefault("addr", "0")); s.Length = (byte)ParseInt(f.GetValueOrDefault("length", "0")); s.Gen = ParseInt(f.GetValueOrDefault("gen", "0")); switch (s.Type) { case SectionType.Table2D: s.Table2D = Build2D(f, rows); break; case SectionType.Afr: s.Afr = BuildAfr(f, rows); break; case SectionType.Table1D: s.Table1D = Build1D(f, rows); break; case SectionType.SubTable:s.Sub = BuildSub(rows); break; case SectionType.Misc: s.MiscBytes = BuildBytes(rows); break; default: foreach (var kv in f) s.Extra[kv.Key] = kv.Value; break; } } private static (byte[] data, byte[] rpm, byte[] load, byte sign, byte maxRaw, byte minRaw, byte mult) Read2DCore( Dictionary f, List<(string key, string val)> rows) { var rpm = ParseHexBytes(f.GetValueOrDefault("rpm_axis", "")); var load = ParseHexBytes(f.GetValueOrDefault("load_axis", "")); byte sign = (byte)(ParseInt(f.GetValueOrDefault("signed", "0")) > 0 ? 1 : 0); byte maxRaw = (byte)ParseInt(f.GetValueOrDefault("max_raw", "0")); byte minRaw = (byte)ParseInt(f.GetValueOrDefault("min_raw", "0")); byte mult = (byte)ParseInt(f.GetValueOrDefault("mult", "1")); var data = new byte[TuningTable.DataBytes]; foreach (var (key, val) in rows) { if (!key.StartsWith("row", StringComparison.OrdinalIgnoreCase)) continue; int r = ParseInt(key[3..]); var cells = ParseHexBytes(val); for (int c = 0; c < cells.Length && c < TuningTable.Cols; c++) data[r * TuningTable.Cols + c] = cells[c]; } return (data, rpm, load, sign, maxRaw, minRaw, mult); } private static TuningTable Build2D(Dictionary f, List<(string, string)> rows) { var (data, rpm, load, sign, maxRaw, minRaw, mult) = Read2DCore(f, rows); return new TuningTable { Data = data, RpmAxis = rpm, LoadAxis = load, Sign = sign, MaxRaw = maxRaw, MinRaw = minRaw, Mult = mult }; } private static AfrTable BuildAfr(Dictionary f, List<(string, string)> rows) { var (data, rpm, load, sign, maxRaw, minRaw, mult) = Read2DCore(f, rows); return new AfrTable { Data = data, RpmAxis = rpm, LoadAxis = load, Sign = sign, MaxRaw = maxRaw, MinRaw = minRaw, Mult = mult }; } private static OneDimTable Build1D(Dictionary f, List<(string key, string val)> rows) { var o = new OneDimTable { RawSignedFlag = (byte)(ParseInt(f.GetValueOrDefault("raw_signed", "0")) > 0 ? 1 : 0), ConvSignedFlag = (byte)(ParseInt(f.GetValueOrDefault("conv_signed", "0")) > 0 ? 1 : 0), RawMultiplier = (byte)ParseInt(f.GetValueOrDefault("raw_mult", "1")), ConvMultiplier = (byte)ParseInt(f.GetValueOrDefault("conv_mult", "1")), RawRounding = (byte)ParseInt(f.GetValueOrDefault("raw_round", "0")), ConvOffset = (sbyte)ParseInt(f.GetValueOrDefault("conv_offset", "0")), MaxRaw = ParseInt(f.GetValueOrDefault("max_raw", "0")), MinRaw = ParseInt(f.GetValueOrDefault("min_raw", "0")), }; foreach (var (key, val) in rows) { if (key.Length < 2 || (key[0] != 'p' && key[0] != 'P')) continue; int i = ParseInt(key[1..]); if (i < 0 || i >= OneDimTable.PointCount) continue; var parts = val.Split(','); if (parts.Length >= 1) o.RawAxis[i] = ParseInt(parts[0].Trim()); if (parts.Length >= 2) o.ConvValues[i] = ParseInt(parts[1].Trim()); } return o; } private static SubTable BuildSub(List<(string key, string val)> rows) { var data = new byte[SubTable.DataBytes]; foreach (var (key, val) in rows) { if (!key.StartsWith("row", StringComparison.OrdinalIgnoreCase)) continue; int r = ParseInt(key[3..]); var parts = val.Split(','); for (int c = 0; c < parts.Length && c < SubTable.Cols; c++) data[r * SubTable.Cols + c] = unchecked((byte)(sbyte)ParseInt(parts[c].Trim())); } return new SubTable { Data = data }; } private static byte[] BuildBytes(List<(string key, string val)> rows) { var all = new List(); foreach (var (key, val) in rows) if (key.Equals("bytes", StringComparison.OrdinalIgnoreCase)) all.AddRange(ParseHexBytes(val)); return all.ToArray(); } // ── Helpers ───────────────────────────────────────────────────────────── private static string Hex8(byte b) => "0x" + b.ToString("X2", CultureInfo.InvariantCulture); private static string Hex16(ushort v) => "0x" + v.ToString("X4", CultureInfo.InvariantCulture); private static string HexBytes(byte[] bytes) { var sb = new StringBuilder(bytes.Length * 3); for (int i = 0; i < bytes.Length; i++) { if (i > 0) sb.Append(' '); sb.Append(bytes[i].ToString("X2", CultureInfo.InvariantCulture)); } return sb.ToString(); } private static byte[] ParseHexBytes(string s) { if (string.IsNullOrWhiteSpace(s)) return Array.Empty(); var toks = s.Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries); var outp = new byte[toks.Length]; for (int i = 0; i < toks.Length; i++) { var tok = toks[i]; if (tok.StartsWith("0x", StringComparison.OrdinalIgnoreCase)) tok = tok[2..]; outp[i] = byte.Parse(tok, NumberStyles.HexNumber, CultureInfo.InvariantCulture); } return outp; } private static int ParseInt(string s) { s = s.Trim(); if (s.Length == 0) return 0; if (s.StartsWith("0x", StringComparison.OrdinalIgnoreCase)) return int.Parse(s[2..], NumberStyles.HexNumber, CultureInfo.InvariantCulture); return int.Parse(s, NumberStyles.Integer | NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture); } private static string Sha256Hex(string body) { var bytes = SHA256.HashData(Encoding.UTF8.GetBytes(body)); var sb = new StringBuilder(bytes.Length * 2); foreach (var b in bytes) sb.Append(b.ToString("x2", CultureInfo.InvariantCulture)); return sb.ToString(); } }