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();
}
}