hello this is the c# visual studio code for my audio editor and player we made, I really like it you did a good job but only one thing isn't right, the playback position line or seekbar whatever is always starting from the start of the waveform which is ok if I didn't make a selection but when I do make a selection it still starts the trackbar or seekbar whatever to the start of the waveform, this is undesired when a selection is made the playback seekbar or whatever should start at the selection start and end at the selection end when played. Please return the entire working code.

using System;
using System.Drawing;
using System.Windows.Forms;
using NAudio.Wave;
using NAudio.Wave.SampleProviders;
using Timer = System.Windows.Forms.Timer;

namespace ByteBreath
{
    // DoubleBufferedPanel to reduce flickering
    public class DoubleBufferedPanel : Panel
    {
        public DoubleBufferedPanel()
        {
            this.DoubleBuffered = true;
            this.SetStyle(ControlStyles.AllPaintingInWmPaint |
                          ControlStyles.UserPaint |
                          ControlStyles.OptimizedDoubleBuffer, true);
            this.UpdateStyles();
        }
    }

    public partial class AudioEditorForm : Form
    {
        private float[] audioSamples;      // normalized samples (-1 to 1)
        private WaveFormat waveFormat;
        private string currentFilePath;

        private bool isSelecting = false;
        private int selectionStart = -1;
        private int selectionEnd = -1;

        private int sampleRate;

        private Button btnLoad;
        private Button btnDelete;
        private Button btnSave;
        private Button btnPlayPause;
        private DoubleBufferedPanel waveformPanel;

        private WaveOutEvent waveOut;
        private AudioFileReader audioFileReader;
        private BufferedWaveProvider bufferedWaveProvider;

        private Timer playbackTimer;
        private long playStartSample = 0;
        private long playEndSample = 0;
        private bool isPlaying = false;

        public AudioEditorForm()
        {
            InitializeComponent();

            this.Text = "Simple Audio Editor";
            this.Width = 800;
            this.Height = 400;

            btnLoad = new Button()
            {
                Text = "Load WAV",
                Left = 10,
                Top = 10,
                Width = 100
            };
            btnLoad.Click += BtnLoad_Click;
            this.Controls.Add(btnLoad);

            btnDelete = new Button()
            {
                Text = "Delete Selection",
                Left = 120,
                Top = 10,
                Width = 120,
                Enabled = false
            };
            btnDelete.Click += BtnDelete_Click;
            this.Controls.Add(btnDelete);

            btnSave = new Button()
            {
                Text = "Save",
                Left = 250,
                Top = 10,
                Width = 100,
                Enabled = false
            };
            btnSave.Click += BtnSave_Click;
            this.Controls.Add(btnSave);

            btnPlayPause = new Button()
            {
                Text = "Play",
                Left = 360,
                Top = 10,
                Width = 100,
                Enabled = false
            };
            btnPlayPause.Click += BtnPlayPause_Click;
            this.Controls.Add(btnPlayPause);

            waveformPanel = new DoubleBufferedPanel()
            {
                Left = 10,
                Top = 50,
                Width = this.ClientSize.Width - 20,
                Height = this.ClientSize.Height - 60,
                BorderStyle = BorderStyle.FixedSingle,
                BackColor = Color.Black,
                Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right
            };
            waveformPanel.Paint += WaveformPanel_Paint;
            waveformPanel.MouseDown += WaveformPanel_MouseDown;
            waveformPanel.MouseMove += WaveformPanel_MouseMove;
            waveformPanel.MouseUp += WaveformPanel_MouseUp;
            this.Controls.Add(waveformPanel);

            playbackTimer = new Timer();
            playbackTimer.Interval = 30;
            playbackTimer.Tick += PlaybackTimer_Tick;
        }

        private void BtnLoad_Click(object sender, EventArgs e)
        {
            using (var ofd = new OpenFileDialog())
            {
                ofd.Filter = "WAV files (*.wav)|*.wav";
                if (ofd.ShowDialog() == DialogResult.OK)
                {
                    currentFilePath = ofd.FileName;
                    LoadWaveFile(currentFilePath);
                }
            }
        }

        private void LoadWaveFile(string path)
        {
            try
            {
                waveOut?.Stop();
                waveOut?.Dispose();
                waveOut = null;
                audioFileReader?.Dispose();
                audioFileReader = null;
                bufferedWaveProvider = null;
                isPlaying = false;
                btnPlayPause.Text = "Play";

                audioFileReader = new AudioFileReader(path);
                waveFormat = audioFileReader.WaveFormat;
                sampleRate = waveFormat.SampleRate;

                var wholeFile = new float[audioFileReader.Length / 4];
                audioFileReader.Position = 0;
                int offset = 0;
                int samplesRead;
                var buffer = new float[1024];
                while ((samplesRead = audioFileReader.Read(buffer, 0, buffer.Length)) > 0)
                {
                    Array.Copy(buffer, 0, wholeFile, offset, samplesRead);
                    offset += samplesRead;
                }

                audioSamples = wholeFile;

                audioFileReader.Position = 0;

                selectionStart = -1;
                selectionEnd = -1;

                btnDelete.Enabled = false;
                btnSave.Enabled = true;
                btnPlayPause.Enabled = true;

                playStartSample = 0;
                playEndSample = audioSamples.Length - 1;

                waveOut = new WaveOutEvent();
                waveOut.PlaybackStopped += WaveOut_PlaybackStopped;

                bufferedWaveProvider = new BufferedWaveProvider(waveFormat);
                bufferedWaveProvider.BufferLength = audioSamples.Length * waveFormat.BlockAlign;
                bufferedWaveProvider.ClearBuffer();
                byte[] byteBuffer = new byte[audioSamples.Length * 4];
                Buffer.BlockCopy(audioSamples, 0, byteBuffer, 0, byteBuffer.Length);
                bufferedWaveProvider.AddSamples(byteBuffer, 0, byteBuffer.Length);

                waveformPanel.Invalidate();
            }
            catch (Exception ex)
            {
                MessageBox.Show("Failed to load WAV: " + ex.Message);
            }
        }

        private void WaveformPanel_Paint(object sender, PaintEventArgs e)
        {
            e.Graphics.Clear(Color.Black);
            if (audioSamples == null || audioSamples.Length == 0)
            {
                using (var brush = new SolidBrush(Color.White))
                {
                    e.Graphics.DrawString("No audio loaded", this.Font, brush, new PointF(10, 10));
                }
                return;
            }

            int w = waveformPanel.ClientSize.Width;
            int h = waveformPanel.ClientSize.Height;

            using (var pen = new Pen(Color.White))
            {
                int samplesPerPixel = Math.Max(1, audioSamples.Length / w);

                for (int x = 0; x < w; x++)
                {
                    int startSample = x * samplesPerPixel;
                    int endSample = Math.Min(audioSamples.Length, startSample + samplesPerPixel);

                    float min = 1f;
                    float max = -1f;
                    for (int s = startSample; s < endSample; s++)
                    {
                        float val = audioSamples[s];
                        if (val < min) min = val;
                        if (val > max) max = val;
                    }

                    int yMax = (int)((1 - (max + 1) / 2) * h);
                    int yMin = (int)((1 - (min + 1) / 2) * h);

                    e.Graphics.DrawLine(pen, x, yMin, x, yMax);
                }
            }

            if (selectionStart >= 0 && selectionEnd >= 0 && selectionEnd != selectionStart)
            {
                int wSamples = audioSamples.Length;
                int x1 = (int)((double)selectionStart / wSamples * w);
                int x2 = (int)((double)selectionEnd / wSamples * w);

                int rectX = Math.Min(x1, x2);
                int rectW = Math.Abs(x2 - x1);

                if (rectW > 0)
                {
                    using (var selectionBrush = new SolidBrush(Color.FromArgb(100, Color.Blue)))
                    {
                        e.Graphics.FillRectangle(selectionBrush, rectX, 0, rectW, h);
                    }

                    using (var pen = new Pen(Color.Blue, 2))
                    {
                        e.Graphics.DrawRectangle(pen, rectX, 0, rectW, h - 1);
                    }
                }
            }

            if (isPlaying && audioSamples != null && waveOut != null)
            {
                long bytesPerSample = waveFormat.BitsPerSample / 8 * waveFormat.Channels;
                long currentSample = 0;

                if (bufferedWaveProvider != null)
                {
                    long playedBytes = bufferedWaveProvider.BufferedBytes - waveOut.GetPosition();
                    currentSample = (bufferedWaveProvider.BufferedBytes - playedBytes) / bytesPerSample;
                }
                else if (audioFileReader != null)
                {
                    currentSample = audioFileReader.Position / bytesPerSample;
                }

                double positionRatio = (double)(currentSample) / audioSamples.Length;
                int x = (int)(positionRatio * w);
                if (x >= 0 && x < w)
                {
                    using (var pen = new Pen(Color.Red, 2))
                    {
                        e.Graphics.DrawLine(pen, x, 0, x, h);
                    }
                }
            }
        }

        private void WaveformPanel_MouseDown(object sender, MouseEventArgs e)
        {
            if (audioSamples == null) return;

            isSelecting = true;
            int w = waveformPanel.ClientSize.Width;
            int sampleIndex = (int)((double)e.X / w * audioSamples.Length);
            sampleIndex = Math.Max(0, Math.Min(sampleIndex, audioSamples.Length - 1));

            selectionStart = sampleIndex;
            selectionEnd = sampleIndex;
            waveformPanel.Invalidate();
        }

        private void WaveformPanel_MouseMove(object sender, MouseEventArgs e)
        {
            if (audioSamples == null || !isSelecting) return;

            int w = waveformPanel.ClientSize.Width;
            int sampleIndex = (int)((double)e.X / w * audioSamples.Length);
            sampleIndex = Math.Max(0, Math.Min(sampleIndex, audioSamples.Length - 1));

            selectionEnd = sampleIndex;
            waveformPanel.Invalidate();

            btnDelete.Enabled = Math.Abs(selectionEnd - selectionStart) > 0;
        }

        private void WaveformPanel_MouseUp(object sender, MouseEventArgs e)
        {
            if (audioSamples == null) return;

            isSelecting = false;

            if (Math.Abs(selectionEnd - selectionStart) == 0)
            {
                selectionStart = -1;
                selectionEnd = -1;
                btnDelete.Enabled = false;
            }
            else
            {
                btnDelete.Enabled = true;
            }
            waveformPanel.Invalidate();
        }

        private void BtnDelete_Click(object sender, EventArgs e)
        {
            if (audioSamples == null) return;
            if (selectionStart < 0 || selectionEnd < 0) return;

            int start = Math.Min(selectionStart, selectionEnd);
            int end = Math.Max(selectionStart, selectionEnd);

            if (end == start) return;

            int newLength = audioSamples.Length - (end - start);
            float[] newSamples = new float[newLength];

            Array.Copy(audioSamples, 0, newSamples, 0, start);
            Array.Copy(audioSamples, end, newSamples, start, audioSamples.Length - end);

            audioSamples = newSamples;

            selectionStart = -1;
            selectionEnd = -1;
            btnDelete.Enabled = false;

            waveOut?.Stop();

            bufferedWaveProvider = new BufferedWaveProvider(waveFormat);
            bufferedWaveProvider.BufferLength = audioSamples.Length * waveFormat.BlockAlign;
            bufferedWaveProvider.ClearBuffer();

            byte[] byteBuffer = new byte[audioSamples.Length * 4];
            Buffer.BlockCopy(audioSamples, 0, byteBuffer, 0, byteBuffer.Length);
            bufferedWaveProvider.AddSamples(byteBuffer, 0, byteBuffer.Length);

            waveOut?.Init(bufferedWaveProvider);

            playStartSample = 0;
            playEndSample = audioSamples.Length - 1;

            btnPlayPause.Enabled = true;
            btnPlayPause.Text = "Play";
            isPlaying = false;

            waveformPanel.Invalidate();
        }

        private void BtnSave_Click(object sender, EventArgs e)
        {
            if (audioSamples == null || string.IsNullOrEmpty(currentFilePath)) return;

            try
            {
                using (var writer = new WaveFileWriter(currentFilePath, waveFormat))
                {
                    if (waveFormat.Encoding == WaveFormatEncoding.IeeeFloat)
                    {
                        writer.WriteSamples(audioSamples, 0, audioSamples.Length);
                    }
                    else if (waveFormat.BitsPerSample == 16)
                    {
                        short[] int16Samples = new short[audioSamples.Length];
                        for (int i = 0; i < audioSamples.Length; i++)
                        {
                            float sample = audioSamples[i];
                            sample = Math.Max(-1f, Math.Min(1f, sample));
                            int16Samples[i] = (short)(sample * short.MaxValue);
                        }
                        byte[] bytes = new byte[int16Samples.Length * 2];
                        Buffer.BlockCopy(int16Samples, 0, bytes, 0, bytes.Length);
                        writer.Write(bytes, 0, bytes.Length);
                    }
                    else
                    {
                        MessageBox.Show("Unsupported bit depth: " + waveFormat.BitsPerSample);
                        return;
                    }
                }
                MessageBox.Show("File saved to " + currentFilePath);
            }
            catch (Exception ex)
            {
                MessageBox.Show("Failed to save WAV: " + ex.Message);
            }
        }

        private void BtnPlayPause_Click(object sender, EventArgs e)
        {
            if (audioSamples == null || waveOut == null) return;

            if (!isPlaying)
            {
                if (selectionStart >= 0 && selectionEnd >= 0 && selectionEnd != selectionStart)
                {
                    playStartSample = Math.Min(selectionStart, selectionEnd);
                    playEndSample = Math.Max(selectionStart, selectionEnd);
                }
                else
                {
                    playStartSample = 0;
                    playEndSample = audioSamples.Length - 1;
                }

                waveOut.Stop();

                if (bufferedWaveProvider != null)
                {
                    waveOut.Init(bufferedWaveProvider);

                    long bytesPerSample = (waveFormat.BitsPerSample / 8) * waveFormat.Channels;
                    long startPosLong = playStartSample * bytesPerSample;
                    long lengthLong = (playEndSample - playStartSample + 1) * bytesPerSample;

                    // Sanity check, avoid overflow by limiting to int.MaxValue
                    if (startPosLong > int.MaxValue || lengthLong > int.MaxValue)
                    {
                        MessageBox.Show("Selection too large for playback.");
                        return;
                    }

                    int startPos = (int)startPosLong;
                    int length = (int)lengthLong;

                    bufferedWaveProvider.ClearBuffer();
                    byte[] byteBuffer = new byte[length];

                    // audioSamples is float[] (4 bytes each)
                    // Copy from audioSamples starting at playStartSample * sizeof(float)
                    Buffer.BlockCopy(audioSamples, (int)(playStartSample * 4), byteBuffer, 0, length);
                    bufferedWaveProvider.AddSamples(byteBuffer, 0, length);
                }

                waveOut.Play();
                isPlaying = true;
                btnPlayPause.Text = "Pause";
                playbackTimer.Start();
            }
            else
            {
                waveOut.Pause();
                isPlaying = false;
                btnPlayPause.Text = "Play";
                playbackTimer.Stop();
            }
        }

        private void PlaybackTimer_Tick(object sender, EventArgs e)
        {
            if (!isPlaying) return;

            long bytesPerSample = waveFormat.BitsPerSample / 8 * waveFormat.Channels;
            long currentSample = 0;

            try
            {
                if (bufferedWaveProvider != null && waveOut != null)
                {
                    currentSample = waveOut.GetPosition() / bytesPerSample + playStartSample;
                }
                else if (audioFileReader != null)
                {
                    currentSample = audioFileReader.Position / bytesPerSample;
                }
            }
            catch
            {
                currentSample = 0;
            }

            if (currentSample > playEndSample)
            {
                waveOut.Stop();
                return;
            }

            waveformPanel.Invalidate();
        }

        private void WaveOut_PlaybackStopped(object sender, StoppedEventArgs e)
        {
            isPlaying = false;
            btnPlayPause.Text = "Play";
            playbackTimer.Stop();
            waveformPanel.Invalidate();
        }
    }
}