using System.Diagnostics;
using System.Net;
using FASTER.core;
using MemoryPack;

namespace MyFaster
{
    [MemoryPackable()]
    public partial class MyData
    {
        public string? FirstName { get; set; }
        public string? LastName { get; set; }
        public int Age { get; set; }
        public string? DetailData { get; set; }
    }
    internal class Program
    {
        public static byte[] Serialize<T>(T obj)
        {
            return MemoryPackSerializer.Serialize(obj);
        }

        public static T Deserialize<T>(byte[] data)
        {
            return MemoryPackSerializer.Deserialize<T>(data);
        }

        public class MyValueSerializer1 : BinaryObjectSerializer<MyData>
        {
            public override void Serialize(ref MyData value)
            {
                writer.Write(value.FirstName);
                writer.Write(value.LastName);
                writer.Write(value.Age);
                writer.Write(value.DetailData);
            }

            public override void Deserialize(out MyData value)
            {
                value = new MyData
                {
                    FirstName = reader.ReadString(),
                    LastName = reader.ReadString(),
                    Age = reader.ReadInt32(),
                    DetailData = reader.ReadString()
                };
            }
        }

        public class MyValueSerializer : BinaryObjectSerializer<MyData>
        {
            public override void Serialize(ref MyData value)
            {
                //writer.Write(IPAddress.HostToNetworkOrder(Q.Length)); // 4字节长度头
                var Q = MemoryPackSerializer.Serialize(value);
                writer.Write(Q.Length); // 4字节长度头
                writer.Write(Q);
            }

            public override void Deserialize(out MyData value)
            {
                int length = reader.ReadInt32(); // 读长度头
                byte[] buffer = reader.ReadBytes(length); // 读数据体
                value = MemoryPackSerializer.Deserialize<MyData>(buffer); // 反序列化
            }
        }

        static async Task Main(string[] args)
        {
            using var settings = new FasterKVSettings<string, MyData>()
            {
                LogDevice = Devices.CreateLogDevice("c:/mytemp/log"),       // 元数据日志
                ObjectLogDevice = Devices.CreateLogDevice("c:/mytemp/obj"),  // 对象数据日志
                TryRecoverLatest = true,
                ValueSerializer = () => new MyValueSerializer()
            };
            using var store = new FasterKV<string, MyData>(settings);
            using var session = store.NewSession(new SimpleFunctions<string, MyData>());

            MyData mydata0 = new MyData() { FirstName = "1", LastName = "fdfdf", DetailData = "detail1" };
            MyData mydata1 = new MyData() { FirstName = "1", LastName = "fdfdf", DetailData = "detail1" };
            MyData mydata2 = new MyData() { FirstName = "1", LastName = "fdfdf", DetailData = "detail1" };

            string mma0 = "a";
            string mma1 = "b";
            string mma2 = "c";

            session.Upsert(ref mma0, ref mydata0);
            session.Upsert(ref mma1, ref mydata1);
            session.Upsert(ref mma2, ref mydata2);

            session.CompletePending(true);
            // 创建增量检查点（性能更好）
            await store.TakeHybridLogCheckpointAsync(CheckpointType.FoldOver);

            // 方法1：完整检查点（推荐）
            await store.TakeFullCheckpointAsync(CheckpointType.Snapshot);

            //完整检查点
            await store.TakeFullCheckpointAsync(CheckpointType.FoldOver);

            MyData output = null;
            var status = session.Read(ref mma0, ref output);

            Console.WriteLine("Hello, World!");
        }
    }
}