using System;
using System.Buffers;
using System.Collections.Generic;
using System.IO;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;
using Duplicati.Proprietary.DiskImage.Disk;
using Duplicati.Proprietary.DiskImage.General;
using Duplicati.Proprietary.DiskImage.Partition;

namespace Duplicati.Proprietary.DiskImage.Filesystem;

/// <summary>
/// Metadata for unknown filesystems, storing basic block size information.
/// </summary>
public sealed record UnkownFilesystemMetadata
{
    /// <summary>
    /// Gets the block size used for reading/writing data.
    /// </summary>
    public int BlockSize { get; init; }
}

/// <summary>
/// Represents a file in an unknown filesystem.
/// Used for raw block-based access when filesystem type cannot be determined.
/// </summary>
public class UnknownFilesystemFile : IFile
{
    /// <inheritdoc />
    public string? Path { get; init; }

    /// <inheritdoc />
    public long? Address { get; init; }

    /// <inheritdoc />
    public long Size { get; init; }

    /// <inheritdoc />
    public bool IsDirectory => false;
}

/// <summary>
/// Represents an unknown or unsupported filesystem.
/// Provides raw block-level access to partition data when the filesystem type cannot be determined.
/// </summary>
internal class UnknownFilesystem : IFilesystem
{
    /// <inheritdoc />
    public FileSystemType Type => FileSystemType.Unknown;

    /// <inheritdoc />
    public IPartition Partition { get => m_partition; }

    /// <summary>
    /// Gets or sets the block size used for reading/writing data. Must be a multiple of the partition sector size.
    /// </summary>
    private int m_blockSize;

    /// <summary>
    /// Flag to indicate whether the object has been disposed. Used to prevent multiple disposals and access after disposal.
    /// </summary>
    private bool m_disposed = false;

    /// <summary>
    /// The parent partition containing this filesystem.
    /// </summary>
    private readonly IPartition m_partition;

    /// <summary>
    /// Initializes a new instance of the <see cref="UnknownFilesystem"/> class.
    /// </summary>
    /// <param name="partition">The parent partition.</param>
    /// <param name="blockSize">The block size for reading/writing (default is 1MB).</param>
    /// <exception cref="ArgumentException">Thrown if block size is invalid.</exception>
    public UnknownFilesystem(IPartition partition, int blockSize = 1024 * 1024)
    {
        m_partition = partition;
        if (blockSize < 0 || blockSize % partition.PartitionTable.RawDisk?.SectorSize != 0)
            throw new ArgumentException("Block size must be non-negative and a multiple of the partition sector size.", nameof(blockSize));
        m_blockSize = blockSize;
    }

    /// <inheritdoc />
    public void Dispose()
    {
        if (m_disposed)
            return;

        m_disposed = true;
    }

    /// <inheritdoc />
    public Task<object?> GetFilesystemMetadataAsync(CancellationToken cancellationToken)
    {
        var cfg = new UnkownFilesystemMetadata
        {
            BlockSize = m_blockSize,
        };

        return Task.FromResult<object?>(cfg);
    }

    /// <inheritdoc />
    public async IAsyncEnumerable<IFile> ListFilesAsync([EnumeratorCancellation] CancellationToken cancellationToken)
    {
        long totalSize = m_partition.Size;
        long blockSize = m_blockSize;
        long blockCount = (totalSize + blockSize - 1) / blockSize;

        for (long i = 0; i < blockCount; i++)
        {
            long address = i * blockSize;
            long size = Math.Min(blockSize, totalSize - i * blockSize);

            if (size > 0)
                yield return new UnknownFilesystemFile()
                {
                    Address = address,
                    Size = size
                };
        }
    }

    /// <inheritdoc />
    public async IAsyncEnumerable<IFile> ListFilesAsync(IFile directory, [EnumeratorCancellation] CancellationToken cancellationToken)
    {
        ArgumentNullException.ThrowIfNull(directory);

        if (directory is not UnknownFilesystemFile)
            throw new ArgumentException("The specified directory does not belong to this filesystem.", nameof(directory));
        if (!directory.IsDirectory)
            throw new ArgumentException("The specified file is not a directory.", nameof(directory));

        yield break;
    }

    /// <summary>
    /// Parses a file path to extract the corresponding block address for raw access.
    /// </summary>
    /// <param name="path">The file path to parse.</param>
    /// <returns>The block address corresponding to the file path.</returns>
    /// <exception cref="ArgumentException">Thrown if the path format is invalid.</exception>
    private static long ParsePathToAddress(string path)
    {
        // Path format: root/part_{PartitionTableType}_{PartitionNumber}/fs_{FileSystemType}/{Address}
        // We need to extract the part after the last slash
        var parts = path.Split(['/', '\\'], StringSplitOptions.RemoveEmptyEntries);
        if (parts.Length < 4)
            throw new ArgumentException("Invalid path format.", nameof(path));

        return Convert.ToInt64(parts[^1], 16);
    }

    /// <summary>
    /// Checks if the specified range is valid for the partition.
    /// </summary>
    /// <param name="start">The starting address of the range.</param>
    /// <param name="size">The size of the range.</param>
    /// <exception cref="ArgumentOutOfRangeException">Thrown if the start or size is negative or exceeds the partition size.</exception>
    /// <exception cref="ArgumentException">Thrown if the start or size is not a multiple of the sector size.</exception>
    public void BoundsCheck(long start, long size)
    {
        if (start < 0 || size < 0)
            throw new ArgumentOutOfRangeException("Start and size must be non-negative.");

        if (start + size > m_partition.Size)
            throw new ArgumentOutOfRangeException("The specified range exceeds the partition size.");

        var sectorSize = m_partition.PartitionTable.RawDisk?.SectorSize ?? 512;

        if (start % sectorSize != 0 || size % sectorSize != 0)
            throw new ArgumentException($"Start and size must be multiples of the sector size ({sectorSize} bytes).");
    }

    /// <inheritdoc />
    public async Task<Stream> OpenReadStreamAsync(IFile file, CancellationToken cancellationToken)
    {
        if (file is not UnknownFilesystemFile unknownFile)
            throw new ArgumentException("The specified file does not belong to this filesystem.", nameof(file));

        if (file.IsDirectory)
            throw new ArgumentException("The specified file is a directory.", nameof(file));

        long address = unknownFile.Address ?? throw new ArgumentException("File address is required.", nameof(file));
        long size = unknownFile.Size;

        BoundsCheck(address, size);

        return new UnknownFilesystemStream(m_partition.PartitionTable.RawDisk!, m_partition.StartOffset + address, size, readEnabled: true, writeEnabled: false);
    }

    /// <inheritdoc />
    public async Task<Stream> OpenReadStreamAsync(string path, CancellationToken cancellationToken)
    {
        long address = ParsePathToAddress(path);
        long size = Math.Min((long)m_blockSize, m_partition.Size - address);

        return await OpenReadStreamAsync(new UnknownFilesystemFile { Address = address, Size = size }, cancellationToken);
    }

    /// <inheritdoc />
    public async Task<Stream> OpenWriteStreamAsync(IFile file, CancellationToken cancellationToken)
    {
        if (file is not UnknownFilesystemFile unknownFile)
            throw new ArgumentException("The specified file does not belong to this filesystem.", nameof(file));

        if (file.IsDirectory)
            throw new ArgumentException("The specified file is a directory.", nameof(file));

        long address = unknownFile.Address ?? throw new ArgumentException("File address is required.", nameof(file));
        long size = unknownFile.Size;

        BoundsCheck(address, size);

        return new UnknownFilesystemStream(m_partition.PartitionTable.RawDisk!, m_partition.StartOffset + address, size, readEnabled: false, writeEnabled: true);
    }

    /// <inheritdoc />
    public async Task<Stream> OpenWriteStreamAsync(string path, CancellationToken cancellationToken)
    {
        long address = ParsePathToAddress(path);
        long size = Math.Min((long)m_blockSize, m_partition.Size - address);

        return await OpenWriteStreamAsync(new UnknownFilesystemFile { Address = address, Size = size }, cancellationToken);
    }

    /// <inheritdoc />
    public async Task<Stream> OpenReadWriteStreamAsync(IFile file, CancellationToken cancellationToken)
    {
        if (file is not UnknownFilesystemFile unknownFile)
            throw new ArgumentException("The specified file does not belong to this filesystem.", nameof(file));

        if (file.IsDirectory)
            throw new ArgumentException("The specified file is a directory.", nameof(file));

        long address = unknownFile.Address ?? throw new ArgumentException("File address is required.", nameof(file));
        long size = unknownFile.Size;

        BoundsCheck(address, size);

        return new UnknownFilesystemStream(m_partition.PartitionTable.RawDisk!, m_partition.StartOffset + address, size, readEnabled: true, writeEnabled: true);
    }

    /// <inheritdoc />
    public async Task<Stream> OpenReadWriteStreamAsync(string path, CancellationToken cancellationToken)
    {
        long address = ParsePathToAddress(path);
        long size = Math.Min((long)m_blockSize, m_partition.Size - address);

        return await OpenReadWriteStreamAsync(new UnknownFilesystemFile { Address = address, Size = size }, cancellationToken);
    }

    /// <inheritdoc />
    public Task<long> GetFileLengthAsync(IFile file, CancellationToken cancellationToken)
    {
        if (file is not UnknownFilesystemFile unknownFile)
            throw new ArgumentException("The specified file does not belong to this filesystem.", nameof(file));

        if (file.IsDirectory)
            throw new ArgumentException("The specified file is a directory.", nameof(file));

        return Task.FromResult(unknownFile.Size);
    }

    /// <inheritdoc />
    public Task<long> GetFileLengthAsync(string path, CancellationToken cancellationToken)
    {
        long address = ParsePathToAddress(path);
        long totalSize = m_partition.Size;
        long size = Math.Min((long)m_blockSize, totalSize - address);

        return Task.FromResult(size);
    }

    /// <summary>
    /// A stream that writes data directly to a specific address on the raw disk.
    /// </summary>
    private class UnknownFilesystemStream : Stream
    {
        /// <summary>
        /// The raw disk to read from.
        /// </summary>
        private readonly IRawDisk _disk;

        /// <summary>
        /// The starting address on the disk for this stream.
        /// </summary>
        private readonly long _address;

        /// <summary>
        /// The size of the stream in bytes.
        /// </summary>
        private readonly long _size;

        /// <summary>
        /// The buffer used to store data before writing to disk.
        /// Rented from ArrayPool to avoid LOH allocations for large buffers.
        /// </summary>
        private readonly byte[] _buffer;

        /// <summary>
        /// Indicates whether the buffer was rented from the ArrayPool and needs to be returned.
        /// </summary>
        private readonly bool _bufferRented;

        /// <summary>
        /// The current position within the buffer.
        /// </summary>
        private long _position;

        /// <summary>
        /// Indicates whether the data in the buffer is valid (has been read from disk).
        /// </summary>
        private bool _validData;

        /// <summary>
        /// Indicates whether the stream has been disposed.
        /// </summary>
        private bool _disposed;

        /// <summary>
        /// Indicates whether the stream supports reading.
        /// </summary>
        private readonly bool _readEnabled;

        /// <summary>
        /// Indicates whether the stream supports writing.
        /// </summary>
        private readonly bool _writeEnabled;

        /// <summary>
        /// Indicates whether the buffer has been modified (dirty).
        /// </summary>
        private bool _dirty;

        /// <summary>
        /// Initializes a new instance of the <see cref="UnknownFilesystemStream"/> class.
        /// </summary>
        /// <param name="disk">The raw disk to read from/write to.</param>
        /// <param name="address">The starting address on the disk for this stream.</param>
        /// <param name="size">The size of the stream in bytes.</param>
        /// <param name="readEnabled">Whether reading is enabled.</param>
        /// <param name="writeEnabled">Whether writing is enabled.</param>
        public UnknownFilesystemStream(IRawDisk disk, long address, long size, bool readEnabled, bool writeEnabled)
        {
            _disk = disk;
            _address = address;
            _size = size;
            _readEnabled = readEnabled;
            _writeEnabled = writeEnabled;
            // Rent buffer from ArrayPool to avoid LOH allocations for large buffers (typically 1 MB)
            _buffer = ArrayPool<byte>.Shared.Rent((int)size);
            _bufferRented = true;
            _position = 0;
            _validData = false;
            _disposed = false;
            _dirty = false;
        }

        public override bool CanRead => _readEnabled;
        public override bool CanWrite => _writeEnabled;
        public override bool CanSeek => true;
        public override long Length => _size;
        public override long Position
        {
            get => _position;
            set
            {
                if (value < 0 || value > _size)
                    throw new ArgumentOutOfRangeException(nameof(value));
                _position = value;
            }
        }

        public override void Flush()
        {
            // No-op - data is written on dispose
        }

        public override long Seek(long offset, SeekOrigin origin)
        {
            long newPosition = origin switch
            {
                SeekOrigin.Begin => offset,
                SeekOrigin.Current => _position + offset,
                SeekOrigin.End => _size + offset,
                _ => throw new ArgumentException("Invalid seek origin", nameof(origin))
            };

            if (newPosition < 0 || newPosition > _size)
                throw new ArgumentOutOfRangeException(nameof(offset));

            _position = newPosition;
            return _position;
        }

        public override void SetLength(long value)
        {
            throw new NotSupportedException("Cannot change the length of this stream.");
        }

        public override int Read(byte[] buffer, int offset, int count)
        {
            if (!_readEnabled)
                throw new NotSupportedException("Read is not supported on this stream.");

            if (buffer == null)
                throw new ArgumentNullException(nameof(buffer));
            if (offset < 0)
                throw new ArgumentOutOfRangeException(nameof(offset));
            if (count < 0)
                throw new ArgumentOutOfRangeException(nameof(count));
            if (buffer.Length - offset < count)
                throw new ArgumentException("Invalid offset and count for buffer length");

            if (!_validData)
            {
                // Load the data from disk into the buffer on the first read
                // Use _size to limit the read to the actual data size, not the potentially larger rented buffer
                _disk.ReadBytesAsync(_address, _buffer.AsMemory(0, (int)_size), CancellationToken.None).GetAwaiter().GetResult();
                _validData = true;
            }

            int bytesToRead = (int)Math.Min(count, _size - _position);
            if (bytesToRead <= 0)
                return 0;

            Buffer.BlockCopy(_buffer, (int)_position, buffer, offset, bytesToRead);
            _position += bytesToRead;
            return bytesToRead;
        }

        public override void Write(byte[] buffer, int offset, int count)
        {
            if (!_writeEnabled)
                throw new NotSupportedException("Write is not supported on this stream.");

            if (buffer == null)
                throw new ArgumentNullException(nameof(buffer));
            if (offset < 0)
                throw new ArgumentOutOfRangeException(nameof(offset));
            if (count < 0)
                throw new ArgumentOutOfRangeException(nameof(count));
            if (buffer.Length - offset < count)
                throw new ArgumentException("Invalid offset and count for buffer length");

            if (_position + count > _size)
                throw new ArgumentException("Write would exceed stream size");

            Buffer.BlockCopy(buffer, offset, _buffer, (int)_position, count);
            _position += count;
            _validData = true;
            _dirty = true;
        }

        public override async Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
        {
            if (!_readEnabled)
                throw new NotSupportedException("Read is not supported on this stream.");

            if (buffer == null)
                throw new ArgumentNullException(nameof(buffer));
            if (offset < 0)
                throw new ArgumentOutOfRangeException(nameof(offset));
            if (count < 0)
                throw new ArgumentOutOfRangeException(nameof(count));
            if (buffer.Length - offset < count)
                throw new ArgumentException("Invalid offset and count for buffer length");

            if (!_validData)
            {
                // Load the data from disk into the buffer on the first read
                // Use _size to limit the read to the actual data size, not the potentially larger rented buffer
                await _disk.ReadBytesAsync(_address, _buffer.AsMemory(0, (int)_size), cancellationToken);
                _validData = true;
            }

            int bytesToRead = (int)Math.Min(count, _size - _position);
            if (bytesToRead <= 0)
                return 0;

            Buffer.BlockCopy(_buffer, (int)_position, buffer, offset, bytesToRead);
            _position += bytesToRead;
            return bytesToRead;
        }

        public override async Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
        {
            if (!_writeEnabled)
                throw new NotSupportedException("Write is not supported on this stream.");

            if (buffer == null)
                throw new ArgumentNullException(nameof(buffer));
            if (offset < 0)
                throw new ArgumentOutOfRangeException(nameof(offset));
            if (count < 0)
                throw new ArgumentOutOfRangeException(nameof(count));
            if (buffer.Length - offset < count)
                throw new ArgumentException("Invalid offset and count for buffer length");

            if (_position + count > _size)
                throw new ArgumentException("Write would exceed stream size");

            Buffer.BlockCopy(buffer, offset, _buffer, (int)_position, count);
            _position += count;
            _validData = true;
            _dirty = true;

            await Task.CompletedTask;
        }

        protected override void Dispose(bool disposing)
        {
            if (!_disposed)
            {
                if (disposing)
                {
                    if (_writeEnabled && _dirty)
                    {
                        // Write all buffered data to disk
                        _disk.WriteBytesAsync(_address, _buffer.AsMemory(0, (int)_size), CancellationToken.None).GetAwaiter().GetResult();
                    }
                    // Return the rented buffer to the pool
                    if (_bufferRented)
                    {
                        ArrayPool<byte>.Shared.Return(_buffer);
                    }
                }
                _disposed = true;
            }
            base.Dispose(disposing);
        }

        /// <summary>
        /// Asynchronously releases the unmanaged resources used by the <see cref="UnknownFilesystemStream"/>.
        /// </summary>
        public override async ValueTask DisposeAsync()
        {
            if (!_disposed)
            {
                if (_writeEnabled && _dirty)
                {
                    // Write all buffered data to disk
                    await _disk.WriteBytesAsync(_address, _buffer.AsMemory(0, (int)_size), CancellationToken.None);
                }
                // Return the rented buffer to the pool
                if (_bufferRented)
                {
                    ArrayPool<byte>.Shared.Return(_buffer);
                }
                _disposed = true;
            }
        }
    }
}