script.js

let array = [];
let isSorting = false;
let stopSorting = false;

/* ---------------- AUDIO ---------------- */
const completeSound = new Audio("complete.mp3");

// unlock audio on first click (fixes browser blocking)
document.addEventListener("click", () => {
  completeSound.play().then(() => {
    completeSound.pause();
    completeSound.currentTime = 0;
  }).catch(() => {});
}, { once: true });

function playSound() {
  completeSound.currentTime = 0;
  completeSound.play().catch(() => {});
}

/* ---------------- ARRAY ---------------- */
function generateArray() {
  if (isSorting) return;

  array = [];

  for (let i = 0; i < 50; i++) {
    array.push(Math.floor(Math.random() * 300) + 10);
  }

  playSound(); // sound on generate
  render();
}

/* ---------------- RENDER ---------------- */
function render() {
  const bars = document.getElementById("bars");
  bars.innerHTML = "";

  for (let i = 0; i < array.length; i++) {
    const bar = document.createElement("div");
    bar.classList.add("bar");
    bar.style.height = array[i] + "px";
    bars.appendChild(bar);
  }
}

/* ---------------- DELAY ---------------- */
function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

/* ---------------- BUBBLE SORT ---------------- */
async function bubbleSort() {
  if (isSorting) return;

  isSorting = true;
  stopSorting = false;

  for (let i = 0; i < array.length; i++) {
    for (let j = 0; j < array.length - i - 1; j++) {

      if (stopSorting) return;

      if (array[j] > array[j + 1]) {
        [array[j], array[j + 1]] = [array[j + 1], array[j]];
        render();
        playSound(); // 🔊 sound on swap
        await sleep(50);
      }
    }
  }

  playSound(); // 🔊 finish sound
  isSorting = false;
}

/* ---------------- SELECTION SORT ---------------- */
async function selectionSort() {
  if (isSorting) return;

  isSorting = true;
  stopSorting = false;

  for (let i = 0; i < array.length; i++) {
    if (stopSorting) return;

    let minIndex = i;

    for (let j = i + 1; j < array.length; j++) {
      if (array[j] < array[minIndex]) {
        minIndex = j;
      }
    }

    [array[i], array[minIndex]] = [array[minIndex], array[i]];
    render();
    playSound();
    await sleep(50);
  }

  playSound(); // 🔊 finish
  isSorting = false;
}

/* ---------------- INSERTION SORT ---------------- */
async function insertionSort() {
  if (isSorting) return;

  isSorting = true;
  stopSorting = false;

  for (let i = 1; i < array.length; i++) {
    if (stopSorting) return;

    let key = array[i];
    let j = i - 1;

    while (j >= 0 && array[j] > key) {
      if (stopSorting) return;

      array[j + 1] = array[j];
      j--;

      render();
      playSound();
      await sleep(50);
    }

    array[j + 1] = key;
    render();
    await sleep(50);
  }

  playSound(); // 🔊 finish
  isSorting = false;
}

/* ---------------- MERGE SORT ---------------- */
async function mergeSortWrapper() {
  if (isSorting) return;

  isSorting = true;
  stopSorting = false;

  await mergeSort(0, array.length - 1);

  playSound(); // 🔊 finish
  isSorting = false;
}

async function mergeSort(left, right) {
  if (left >= right || stopSorting) return;

  let mid = Math.floor((left + right) / 2);

  await mergeSort(left, mid);
  await mergeSort(mid + 1, right);

  await merge(left, mid, right);
}

async function merge(left, mid, right) {
  let temp = [];
  let i = left;
  let j = mid + 1;

  while (i <= mid && j <= right) {
    if (array[i] <= array[j]) {
      temp.push(array[i++]);
    } else {
      temp.push(array[j++]);
    }
  }

  while (i <= mid) temp.push(array[i++]);
  while (j <= right) temp.push(array[j++]);

  for (let k = 0; k < temp.length; k++) {
    array[left + k] = temp[k];
    render();
    await sleep(30);
  }
}

/* ---------------- QUICK SORT ---------------- */
async function quickSortWrapper() {
  if (isSorting) return;

  isSorting = true;
  stopSorting = false;

  await quickSort(0, array.length - 1);

  playSound(); // 🔊 finish
  isSorting = false;
}

async function quickSort(low, high) {
  if (low < high && !stopSorting) {
    let pi = await partition(low, high);

    await quickSort(low, pi - 1);
    await quickSort(pi + 1, high);
  }
}

async function partition(low, high) {
  let pivot = array[high];
  let i = low - 1;

  for (let j = low; j < high; j++) {
    if (array[j] < pivot) {
      i++;
      [array[i], array[j]] = [array[j], array[i]];
      render();
      playSound();
      await sleep(30);
    }
  }

  [array[i + 1], array[high]] = [array[high], array[i + 1]];
  render();

  return i + 1;
}

/* ---------------- STALIN SORT ---------------- */
function stalinSort() {
  if (isSorting) return;

  let newArray = [array[0]];

  for (let i = 1; i < array.length; i++) {
    if (array[i] >= newArray[newArray.length - 1]) {
      newArray.push(array[i]);
    }
  }

  array = newArray;
  render();
  playSound(); // 🔊 finish
}

function testSound() {
  completeSound.currentTime = 0;
  completeSound.play();
}

/* ---------------- EXPORT ---------------- */
window.generateArray = generateArray;
window.bubbleSort = bubbleSort;
window.selectionSort = selectionSort;
window.insertionSort = insertionSort;
window.mergeSortWrapper = mergeSortWrapper;
window.quickSortWrapper = quickSortWrapper;
window.stalinSort = stalinSort;