I think you misunderstood the task I told you to make me a wav combiner class but its not really working right the combined wav file is missing stuff idk, I need you to treat this like audacity each wav a track then save it as a final wav.

using System;
using System.Collections.Generic;
using System.IO;
using NAudio.Wave;
using NAudio.Wave.SampleProviders;

public class WavCombiner
{
    /// <summary>
    /// Combines multiple WAV files (even if they have different formats) into a single WAV file.
    /// Converts all input files to a common PCM 16-bit format before concatenation.
    /// </summary>
    /// <param name="inputFiles">List of WAV file paths to combine.</param>
    /// <param name="outputFile">Output WAV file path.</param>
    /// <param name="targetFormat">Optional: target WaveFormat to convert inputs to. If null, uses format of first input file.</param>
    public void CombineWavFiles(List<string> inputFiles, string outputFile, WaveFormat? targetFormat = null)
    {
        if (inputFiles == null || inputFiles.Count == 0)
            throw new ArgumentException("No input files specified.");

        WaveFormat finalFormat;

        // Determine the final output format
        using (var reader = new AudioFileReader(inputFiles[0]))
        {
            finalFormat = targetFormat ?? WaveFormat.CreateIeeeFloatWaveFormat(reader.WaveFormat.SampleRate, reader.WaveFormat.Channels);
        }

        // Create WaveFileWriter with 16-bit PCM based on finalFormat
        WaveFormat outputFormat = new WaveFormat(finalFormat.SampleRate, 16, finalFormat.Channels);

        using (var writer = new WaveFileWriter(outputFile, outputFormat))
        {
            foreach (string file in inputFiles)
            {
                using (var reader = new AudioFileReader(file))
                {
                    ISampleProvider sampleProvider = reader;

                    // Resample if sample rate differs
                    if (reader.WaveFormat.SampleRate != outputFormat.SampleRate)
                    {
                        sampleProvider = new WdlResamplingSampleProvider(sampleProvider, outputFormat.SampleRate);
                    }

                    // Adjust channels if needed
                    if (reader.WaveFormat.Channels != outputFormat.Channels)
                    {
                        if (outputFormat.Channels == 1 && reader.WaveFormat.Channels == 2)
                        {
                            sampleProvider = new StereoToMonoSampleProvider(sampleProvider);
                        }
                        else if (outputFormat.Channels == 2 && reader.WaveFormat.Channels == 1)
                        {
                            sampleProvider = new MonoToStereoSampleProvider(sampleProvider);
                        }
                        else
                        {
                            throw new InvalidOperationException($"Unsupported channel conversion: from {reader.WaveFormat.Channels} to {outputFormat.Channels}.");
                        }
                    }

                    // Buffer to hold converted samples as floats
                    float[] buffer = new float[outputFormat.SampleRate * outputFormat.Channels]; // 1 second buffer
                    int samplesRead;

                    // Read samples from sampleProvider, convert float samples to 16-bit PCM bytes on-the-fly
                    while ((samplesRead = sampleProvider.Read(buffer, 0, buffer.Length)) > 0)
                    {
                        // Convert float samples to 16-bit PCM
                        var bytes = new byte[samplesRead * 2]; // 2 bytes per sample
                        for (int i = 0; i < samplesRead; i++)
                        {
                            // Clamp and convert to Int16
                            var sample = buffer[i];
                            if (sample > 1.0f) sample = 1.0f;
                            if (sample < -1.0f) sample = -1.0f;
                            short intSample = (short)(sample * short.MaxValue);
                            bytes[i * 2] = (byte)(intSample & 0xff);
                            bytes[i * 2 + 1] = (byte)((intSample >> 8) & 0xff);
                        }
                        writer.Write(bytes, 0, bytes.Length);
                    }
                }
            }
        }
    }
}