using System.Collections;
using System.Collections.Generic;
#if UNITY
using UnityEngine;
#endif
using System.Data;
using System.IO;
using System;
using Cysharp.Threading.Tasks;
using Microsoft.SqlServer.Server;
using System.Linq;

namespace BITKit
{
    public class BITBinary
    {
        static Dictionary<string, INetMessageReader> netReaders = new();
        static List<Type> serializableTypes = new();
        [ExcuteOnStart]
        public static async void Start()
        {
            netReaders.Clear();
            serializableTypes.Clear();
            foreach (var x in await ReflectionHelper.GetInstances<INetMessageReader>())
            {
                var typeName = x.GetMessageType().FullName;
                netReaders.Add(typeName, x);
                BIT4Log.Log<BITBinary>($"已注册类型:{typeName}");
            }
            IEnumerable<IBinarySerialize> serializes = await ReflectionHelper.GetInstances<IBinarySerialize>();
#if UNITY
            serializes = serializes.Where(x => x is not UnityEngine.Object);
#else
#endif
            foreach (var x in serializes)
            {
                serializableTypes.Add(x.GetType());
                BIT4Log.Log<BITBinary>($"已注册类型:{x.GetType().FullName}");
            }
        }

        public static object Read<T>(byte[] buffer) => (T)ReadAsValue(buffer);
        public static object ReadAsValue(byte[] buffer)
        {
            using var ms = new MemoryStream(buffer);
            using var reader = new BinaryReader(ms);
            return Read(reader);
        }
        public static object Read(BinaryReader reader)
        {
            var typeName = reader.ReadString();
            if (netReaders.TryGetValue(typeName, out var netReader))
            {
                return netReader.ReadBinaryAsObject(reader);
            }
            else if(BITSharp.TryGetTypeFromFullName(typeName,out var type))
            {
                var instance = System.Activator.CreateInstance(type) as IBinarySerialize;
                instance!.Read(reader);
                return instance;
            }
            else
            {
                throw new Exception("未找到读取该二进制的BinaryReader");
            }
        }

        public static byte[] WriteAsBytes(object value)
        {
            using var ms = new MemoryStream();
            using var writer = new BinaryWriter(ms);
            Write(writer, value);
            return ms.ToArray();
        }
        public static void Write(BinaryWriter writer, object value)
        {
            var typeName = value.GetType().FullName;
            writer.Write(typeName!);
            if (netReaders.TryGetValue(typeName, out var netReader))
            {
                netReader.WriteBinaryAsObject(writer,value);
            }
            else if( value is IBinarySerialize serialize)
            {
                serialize.Write(writer);
            }   
            else
            {
                throw new Exception($"没有找到{value.GetType().Name}的Binary写入方法");
            }
        }
        public static bool IsSupport(object obj) => IsSupport(obj.GetType().FullName);
        public static bool IsSupport(Type type) => IsSupport(type.FullName);
        public static bool IsSupport<T>() => IsSupport(typeof(T).FullName);
        public static bool IsSupport(string typeName)
        {
            if (netReaders.ContainsKey(typeName))
            {
                return true;
            }
            else if (serializableTypes.Any(x => x.FullName == typeName))
            {
                return true;
            }
            return false;
        }

        

        public static bool TryWrite(object obj, out byte[] bytes)
        {
            if (IsSupport(obj))
            {
                bytes = WriteAsBytes(obj);
                return true;
            }
            bytes = null;
            return false;
        }
    }
}