using System.Diagnostics;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;

namespace XFEExtension.NetCore.FileExtension;

/// <summary>
/// 文件的拓展
/// </summary>
public static class FileExtension
{
    /// <summary>
    /// 将非法字符串写入文件
    /// </summary>
    /// <param name="objectToWrite"></param>
    /// <param name="fileName">文件名</param>
    [Obsolete("序列化方法在.NET 8.0中已经不再受支持")]
    public static void WriteInObj(this object objectToWrite, string fileName)
    {
        FileInfo fileInfo = new(fileName);
        using var fileStream = fileInfo.Create();
        BinaryFormatter binaryFormatter = new();
        binaryFormatter.Serialize(fileStream, objectToWrite);
        fileStream.Flush();
        fileStream.Close();
    }

    /// <param name="name"></param>
    extension(string name)
    {
        /// <summary>
        /// 读取文件中的字符串
        /// </summary>
        /// <param name="content">读取的内容</param>
        /// <returns>被读取的文件是否存在</returns>
        public bool ReadOut(out string? content)
        {
            FileInfo fileInfo = new(name);
            if (fileInfo.Exists)
            {
                using var streamReader = fileInfo.OpenText();
                content = streamReader.ReadToEnd();
                streamReader.Close();
                return true;
            }
            content = string.Empty;
            return false;
        }

        /// <summary>
        /// 读取文件中的字符串
        /// </summary>
        /// <returns>目标文件内容，如不存在则返回-1</returns>
        public string ReadOut()
        {
            FileInfo fileInfo = new(name);
            if (!fileInfo.Exists)
                return "-1";
            using var streamReader = fileInfo.OpenText();
            var text = streamReader.ReadToEnd();
            streamReader.Close();
            return text;
        }

        /// <summary>
        /// 读取文件中的字符串
        /// </summary>
        /// <returns></returns>
        [Obsolete("序列化方法在.NET 8.0中已经不再受支持")]
        public T? ReadOutObj<T>()
        {
            var fileInfo = new FileInfo(name);
            if (!fileInfo.Exists)
                return default;
            using var fileStream = fileInfo.OpenRead();
            BinaryFormatter bf = new();
            var result = (T)bf.Deserialize(fileStream);
            fileStream.Close();
            return result;
        }

        /// <summary>
        /// 将字符串写入文件
        /// </summary>
        /// <param name="fileName">目标文件路径及文件名</param>
        public void WriteIn(string fileName)
        {
            FileInfo fileInfo = new(fileName);
            using var fileStream = fileInfo.Create();
            var stream = Encoding.UTF8.GetBytes(name);
            fileStream.Write(stream, 0, stream.Length);
            fileStream.Flush();
        }

        /// <summary>
        /// 读取文件中的字符串
        /// </summary>
        /// <param name="exist">是否存在</param>
        /// <returns></returns>
        [Obsolete("序列化方法在.NET 8.0中已经不再受支持")]
        public string? ReadOutObj(out bool exist)
        {
            FileInfo fileInfo = new(name);
            exist = fileInfo.Exists;
            if (!fileInfo.Exists)
                return "-1";
            using var fileStream = fileInfo.OpenRead();
            BinaryFormatter binaryFormatter = new();
            var text = binaryFormatter.Deserialize(fileStream).ToString();
            fileStream.Close();
            return text;
        }

        /// <summary>
        /// 从文件反序列化对象
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <returns></returns>
        [Obsolete("序列化方法在.NET 8.0中已经不再受支持")]
        public T DeserializeFromFile<T>()
        {
            BinaryFormatter readBinary = new();
            using var readStream = File.OpenRead(name);
            var obj = (T)readBinary.Deserialize(readStream);
            readStream.Close();
            return obj;
        }

        /// <summary>
        /// 获取占用某个文件的程序
        /// </summary>
        /// <returns></returns>
        public Process? GetOwningProcess()
        {
            try
            {
                // 获取所有正在运行的进程
                var processes = Process.GetProcesses();

                foreach (var process in processes)
                {
                    try
                    {
                        // 获取进程打开的文件句柄信息
                        if (process.Modules.Cast<ProcessModule>().Any(module =>
                                module.FileName.Equals(name, StringComparison.OrdinalIgnoreCase)))
                            return process; // 返回占用文件的进程
                    }
                    catch (Exception)
                    {
                        // 忽略无法访问的进程
                    }
                }
            }
            catch (Exception)
            {
                // 忽略获取进程信息时的异常
            }
            return null; // 如果没有找到占用文件的进程，返回null
        }
    }

    /// <summary>
    /// 读取文件中的字符串
    /// </summary>
    /// <param name="fileName">目标文件路径及文件名</param>
    /// <param name="exist">目标文件是否存在</param>
    /// <returns>目标文件内容，如不存在则返回-1</returns>
    public static string? ReadOut(string fileName, out bool exist)
    {
        FileInfo fileInfo = new(fileName);
        exist = fileInfo.Exists;
        if (!fileInfo.Exists)
            return "-1";
        using var streamReader = fileInfo.OpenText();
        var text = streamReader.ReadLine();
        streamReader.Close();
        return text;
    }

    /// <summary>
    /// 序列化对象到文件
    /// </summary>
    /// <param name="obj"></param>
    /// <param name="fileName">文件路径</param>
    [Obsolete("序列化方法在.NET 8.0中已经不再受支持")]
    public static void SerializeToFile(this object obj, string fileName)
    {
        BinaryFormatter writeBinary = new();
        using var writeStream = File.OpenWrite(fileName);
        writeBinary.Serialize(writeStream, obj);
        writeStream.Flush();
        writeStream.Close();
    }

    /// <summary>
    /// 输出文件大小
    /// </summary>
    /// <param name="bufferLength"></param>
    /// <returns></returns>
    public static string FileSize(this long bufferLength)
    {
        string[] sizes = ["B", "KB", "MB", "GB", "TB"];
        double len = bufferLength;
        var order = 0;
        while (len >= 1024 && order < sizes.Length - 1)
        {
            order++;
            len /= 1024;
        }
        return $"{len:0.##} {sizes[order]}";
    }

    /// <param name="fileStream">文件流</param>
    extension(FileStream fileStream)
    {
        /// <summary>
        /// 获取文件的有效起始位置
        /// </summary>
        /// <param name="startPosition">起始搜寻位置</param>
        /// <param name="endPosition">结束搜寻位置</param>
        /// <returns>一个长整型，介于起始位置和结束位置之间</returns>
        public async Task<long> GetValidPosition(long startPosition, long endPosition)
        {
            var seekPosition = endPosition;
            fileStream.Seek(startPosition, SeekOrigin.Begin);
            var buffer = new byte[endPosition - startPosition];
            await fileStream.ReadExactlyAsync(buffer.AsMemory(0, (int)(endPosition - startPosition)));
            for (var i = buffer.Length - 1; i >= 0; i--)
            {
                if (buffer[i] != 0)
                    break;
                seekPosition--;
            }
            return seekPosition > startPosition ? seekPosition : startPosition;
        }

        /// <summary>
        /// 获取文件的有效起始位置
        /// </summary>
        /// <param name="startPosition">起始搜寻位置</param>
        /// <returns>一个长整型，介于起始位置和结束位置之间</returns>
        public async Task<long> GetValidPosition(long startPosition) => await fileStream.GetValidPosition(startPosition, fileStream.Length);

        /// <summary>
        /// 获取文件的有效起始位置
        /// </summary>
        /// <returns>一个长整型，介于起始位置和结束位置之间</returns>
        public async Task<long> GetValidPosition() => await fileStream.GetValidPosition(0, fileStream.Length);
    }
}