using CsToml;
using System.Text;

var tomlText = @"
key = ""value""
number = 123
"u8;

var document = CsTomlSerializer.Deserialize<TomlDocument>(tomlText);

if (document!.TryFind("key"u8, out var value))
{
    var str = value!.GetString(); // value
    Console.WriteLine($"key = {str}"); // key = value
}

Console.WriteLine($"key = {document!.RootNode["key"u8].GetString()}"); // key = value

using var serializedTomlText = CsTomlSerializer.Serialize(document);
Console.WriteLine(Encoding.UTF8.GetString(serializedTomlText.ByteSpan));
// key = "value"
// number = 123

var tomlText = @"
key = ""value""
number = 123
"u8;

var document = CsTomlSerializer.Deserialize<TomlDocument>(tomlText);

var tomlText = @"
key = ""value""
number = ""Error
"u8;

try
{
    // throw CsTomlException
    var error = CsTomlSerializer.Deserialize<TomlDocument>(tomlText);
}
catch(CsTomlSerializeException ctse)
{
    foreach (var cte in ctse.Exceptions)
    {
        // A syntax error (CsTomlException) occurred while parsing line 3 of the TOML file. Check InnerException for details.
        var e = cte.InnerException; // InnerException: 10 is a character that cannot be converted to a number.
    }
}

var document = CsTomlSerializer.Deserialize<TomlDocument>(tomlText);

// The first is obtained by ByteMemoryResult.
using var result = CsTomlSerializer.Serialize(document);
Console.WriteLine(Encoding.UTF8.GetString(result.ByteSpan));

// The second is obtained via IBufferWriter<byte>.
var bufferWriter = new ArrayBufferWriter<byte>();
CsTomlSerializer.Serialize(ref bufferWriter, document);

var tomlText = @"
key = ""value""
number = 123
"u8;

var document = CsTomlSerializer.Deserialize<TomlDocument>(tomlText);

var value = document!.Find("key"u8)!.GetString();
Console.WriteLine($"key = {value}"); // key = value

if (document!.TryFind("key"u8, out var value2))
{
    var str = value2!.GetString(); // value
    Console.WriteLine($"key = {str}"); // key = value
}

var tomlText = @"
array = [1, 2, 3]
inlineTable = { key = ""value"", number = 123 }

[table]
key = ""value""

[[arrayOfTables]]
key = ""value""

[[arrayOfTables]]
number = 123
"u8;

var document = CsTomlSerializer.Deserialize<TomlDocument>(tomlText);
// Array
{
    var tomlArray = document!.Find("array"u8);
    foreach (var tomlValue in tomlArray!.GetArray())
    {
        var value = tomlValue!.GetInt64(); // 1, 2, 3
    }
}
// InlineTable
{
    var tomlInlineTable = document!.Find("inlineTable"u8)!.Find("key"u8);
    var tomlInlineTable2 = document!.Find("inlineTable.key"u8, isDottedKeys:true);
   var value = tomlInlineTable!.GetString(); // "value"
}
// Table
{
    var tomlValue = document!.Find("table"u8, "key"u8);
    var value = tomlValue!.GetString(); // "value"
}
// ArrayOfTables
{
    var tomlValue = document!.Find("arrayOfTables"u8, 0, "key"u8);  // "value"
    var value = tomlValue!.GetString(); // "value"
}

var tomlText = @"
dotted.keys = ""value""

"u8;

var document = CsTomlSerializer.Deserialize<TomlDocument>(tomlText);
if (document!.TryFind(["dotted"u8, "keys"u8], out var tomlValue))
{
    var value = tomlValue!.GetString(); // "value"
}
if (document!.TryFind("dotted.keys"u8, out var tomlValue2, isDottedKeys: true))
{
    var value2 = tomlValue2!.GetString(); // "value"
}
var value3 = document!.RootNode["dotted"u8]["keys"u8].GetString(); // "value"

public partial class TomlValue :
    ISpanFormattable,
    IUtf8SpanFormattable
{
    public bool CanGetValue(TomlValueFeature feature)
    public ReadOnlyCollection<TomlValue> GetArray()
    public TomlValue GetArrayValue(int index)
    public string GetString()
    public long GetInt64()
    public double GetDouble()
    public bool GetBool()
    public DateTime GetDateTime()
    public DateTimeOffset GetDateTimeOffset()
    public DateOnly GetDateOnly()
    public TimeOnly GetTimeOnly()
    public object GetObject()
    public T GetNumber<T>() where T : struct, INumberBase<T>
    public T GetValue<T>()
    public bool TryGetArray(out IReadOnlyList<TomlValue> value)
    public bool TryGetArrayValue(int index, out TomlValue value)
    public bool TryGetString(out string value)
    public bool TryGetInt64(out long value)
    public bool TryGetDouble(out double value)
    public bool TryGetBool(out bool value)
    public bool TryGetDateTime(out DateTime value)
    public bool TryGetDateTimeOffset(out DateTimeOffset value)
    public bool TryGetDateOnly(out DateOnly value)
    public bool TryGetTimeOnly(out TimeOnly value)
    public bool TryGetObject(out object value)
    public bool TryGetNumber<T>(out T value) where T : struct, INumberBase<T>
    public bool TryGetValue<T>(out T value)
    public TomlValue? Find(ReadOnlySpan<byte> keys, bool isDottedKeys = false)
    public TomlValue? Find(ReadOnlySpan<char> keys, bool isDottedKeys = false)
    public TomlValue? Find(ReadOnlySpan<ByteArray> dottedKeys)
    public bool TryFind(ReadOnlySpan<byte> key, out TomlValue? value, bool isDottedKeys = false)
    public bool TryFind(ReadOnlySpan<char> key, out TomlValue? value, bool isDottedKeys = false)
    public bool TryFind(ReadOnlySpan<ByteArray> dottedKeys, out TomlValue? value)
}

[TomlSerializedObject]
public partial class CsTomlClass
{
    [TomlValueOnSerialized(TomlValueType.KeyValue)]
    public string Key { get; set; }

    [TomlValueOnSerialized(TomlValueType.KeyValue)]
    public int Number { get; set; }

    [TomlValueOnSerialized(TomlValueType.Array)]
    public int[] Array { get; set; }

    [TomlValueOnSerialized(TomlValueType.Table)]
    public TableClass Table { get; set; } = new TableClass();

    public class TableClass
    {
        [TomlValueOnSerialized(TomlValueType.KeyValue)]
        public string Key { get; set; }

        [TomlValueOnSerialized(TomlValueType.KeyValue)]
        public int Number { get; set; }
    }
}

var tomlText = @"
Key = ""value""
Number = 123
Array = [1, 2, 3]

[Table]
Key = ""value""
Number = 123
"u8;

var value = CsTomlSerializer.Deserialize<CsTomlClass>(tomlText);
using var serializedText = CsTomlSerializer.Serialize(ref value);

// Key = "value"
// Number = 123
// Array = [1, 2, 3]
//
// [Table]
// Key = "value"
// Number = 123
var serializedTomlText = Encoding.UTF8.GetString(serializedText.ByteSpan);

// deserialize from TOML File
var document = CsTomlFileSerializer.Deserialize<TomlDocument>("test.toml");
var document2 = await CsTomlFileSerializer.DeserializeAsync<TomlDocument>("test.toml");

// seserialize To TOML File
CsTomlFileSerializer.Serialize("test.toml", document);
await CsTomlFileSerializer.SerializeAsync("test.toml", document);