adjust class leave the normalization stuff volume stuff alone but I want it to do quality improvements based what's best for most songs send back full class fixed ty

using System;
using System.Diagnostics;
using System.IO;
using System.Threading.Tasks;

public class SoxAudioNormalizer
{
    private readonly string _soxExePath;
    private readonly float _volumeReductionDb;

    public SoxAudioNormalizer(string soxExePath, float volumeReductionDb = -3.0f)
    {
        if (string.IsNullOrEmpty(soxExePath))
            throw new ArgumentException("SOX exe path cannot be null or empty.", nameof(soxExePath));
        if (!File.Exists(soxExePath))
            throw new FileNotFoundException("SOX exe not found at the specified path.", soxExePath);

        _soxExePath = soxExePath;
        _volumeReductionDb = volumeReductionDb;
    }

    /// <summary>
    /// Asynchronously normalizes the audio, lowers volume slightly, does some quality fixes, replaces original file.
    /// </summary>
    /// <param name="inputFile">Input audio file path</param>
    /// <returns></returns>
    public async Task NormalizeFileAsync(string inputFile)
    {
        if (string.IsNullOrEmpty(inputFile))
            throw new ArgumentException("Input file path cannot be null or empty.", nameof(inputFile));
        if (!File.Exists(inputFile))
            throw new FileNotFoundException("Input audio file not found.", inputFile);

        string directory = Path.GetDirectoryName(inputFile) ?? throw new InvalidOperationException("Cannot determine directory of input file.");
        string fileNameWithoutExt = Path.GetFileNameWithoutExtension(inputFile);
        string extension = Path.GetExtension(inputFile);
        string tempOutputFile = Path.Combine(directory, fileNameWithoutExt + "_normalized" + extension);

        // Use --norm with target gain set by _volumeReductionDb (should be negative for reduction)
        var args = $"-q \"{inputFile}\" \"{tempOutputFile}\" --norm={_volumeReductionDb} highpass 20";

        await ExecuteProcessAsync(_soxExePath, args);

        // After successful processing:
        File.Delete(inputFile);
        File.Move(tempOutputFile, inputFile);
    }

    private async Task ExecuteProcessAsync(string exePath, string arguments)
    {
        using (var process = new Process())
        {
            process.StartInfo.FileName = exePath;
            process.StartInfo.Arguments = arguments;
            process.StartInfo.CreateNoWindow = true;
            process.StartInfo.UseShellExecute = false;
            process.StartInfo.RedirectStandardOutput = true;
            process.StartInfo.RedirectStandardError = true;

            var stdOutput = string.Empty;
            var stdError = string.Empty;

            var tcs = new TaskCompletionSource<int>();

            process.OutputDataReceived += (sender, e) =>
            {
                if (e.Data != null) stdOutput += e.Data + Environment.NewLine;
            };

            process.ErrorDataReceived += (sender, e) =>
            {
                if (e.Data != null) stdError += e.Data + Environment.NewLine;
            };

            process.EnableRaisingEvents = true;
            process.Exited += (sender, e) =>
            {
                tcs.TrySetResult(process.ExitCode);
            };

            if (!process.Start())
                throw new InvalidOperationException("Failed to start process.");

            process.BeginOutputReadLine();
            process.BeginErrorReadLine();

            int exitCode = await tcs.Task.ConfigureAwait(false);

            if (exitCode != 0)
            {
                throw new InvalidOperationException(
                    $"SOX process failed with exit code {exitCode}.\nStdOut: {stdOutput}\nStdErr: {stdError}");
            }
        }
    }
}