// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;

namespace System.IO.Compression
{
    internal static class ZstandardUtils
    {
        // Zstandard compression level constants from native library
        internal static readonly int Quality_Min = Interop.Zstd.ZSTD_minCLevel();
        internal static readonly int Quality_Max = Interop.Zstd.ZSTD_maxCLevel();
        internal static readonly int Quality_Default = Interop.Zstd.ZSTD_defaultCLevel();

        // Window size constraints based on Zstandard specification
        internal const int WindowLog_Min = 10;    // 1KB window
        internal static int WindowLog_Max => Environment.Is64BitProcess ? 31 : 30;    // 1GB or 2GB window, depending on platform
        internal const int WindowLog_Default = 23; // 8MB window

        internal const int TargetBlockSize_Min = 1340;
        internal const int TargetBlockSize_Max = 131072;   // (2^17)

        // Buffer sizes for Zstandard operations
        internal const int DefaultInternalBufferSize = (1 << 16) - 16; // 65520 bytes, similar to Brotli

        /// <summary>Checks if a Zstandard operation result indicates an error.</summary>
        internal static bool IsError(nuint result) => Interop.Zstd.ZSTD_isError(result) != 0;
        internal static bool IsError(nuint result, out Interop.Zstd.ZSTD_error error)
        {
            if (IsError(result))
            {
                error = (Interop.Zstd.ZSTD_error)result;
                return true;
            }

            error = Interop.Zstd.ZSTD_error.no_error;
            return false;
        }

        /// <summary>Gets the error message for a Zstandard error code.</summary>
        internal static string GetErrorMessage(Interop.Zstd.ZSTD_error error)
        {
            IntPtr errorNamePtr = Interop.Zstd.ZSTD_getErrorName((nuint)error);
            return System.Runtime.InteropServices.Marshal.PtrToStringAnsi(errorNamePtr) ?? $"Unknown error {error}";
        }

        internal static void ThrowIfError(nuint result)
        {
            if (IsError(result, out var error))
            {
                Throw(error);
            }
        }

        [DoesNotReturn]
        internal static void Throw(Interop.Zstd.ZSTD_error error)
        {
            Debug.Assert(IsError((nuint)error));
            throw CreateExceptionForError(error);
        }

        internal static Exception CreateExceptionForError(Interop.Zstd.ZSTD_error error)
        {
            Debug.Assert(IsError((nuint)error));

            switch (error)
            {
                case Interop.Zstd.ZSTD_error.frameParameter_windowTooLarge:
                    return new IOException(SR.ZstandardDecoder_WindowTooLarge);

                case Interop.Zstd.ZSTD_error.dictionary_wrong:
                    return new InvalidDataException(SR.ZstandardDecoder_DictionaryWrong);

                case Interop.Zstd.ZSTD_error.memory_allocation:
                    return new OutOfMemoryException();

                case Interop.Zstd.ZSTD_error.stage_wrong:
                    return new InvalidOperationException(SR.ZstandardEncoderDecoder_InvalidState);

                default:
                    return new IOException(SR.Format(SR.Zstd_InternalError, GetErrorMessage(error)));
            }
        }

        internal static int GetQualityFromCompressionLevel(CompressionLevel compressionLevel) =>
            compressionLevel switch
            {
                // zstd supports negative quality levels, all negative levels map to the
                // same behavior (essentially no compression). Quality 0 means "default" = 3.
                // 1 is therefore the fastest compression level with some compression.
                CompressionLevel.NoCompression => Quality_Min,
                CompressionLevel.Fastest => 1,
                CompressionLevel.Optimal => Quality_Default,
                CompressionLevel.SmallestSize => Quality_Max,
                _ => throw new ArgumentOutOfRangeException(nameof(compressionLevel), compressionLevel, SR.ArgumentOutOfRange_Enum)
            };
    }
}