Edits.tish

// Pure edit helpers — safe transforms for agents.

import { makeStep, clonePianoNote } from './Project.tish'

/// Grow a channel to `bars`-bar storage so each bar can be edited independently (tiling the existing
/// single-bar pattern across the new bars so it keeps sounding the same until you change a bar).
export fn promoteChannelToBars(ch, bars) {
  let want = Math.max(1, Math.floor(Number(bars)))
  let cur = (ch.patternBars !== null && Math.floor(ch.patternBars) >= 1) ? Math.floor(ch.patternBars) : 1
  let target = cur > want ? cur : want
  let targetSteps = target * 16
  // Tile piano notes from the current span across the new bars (if it grows by a whole multiple).
  if (target > cur && ch.pianoNotes && ch.pianoNotes.length > 0) {
    let reps = Math.floor(target / cur)
    if (reps * cur === target && reps > 1) {
      let orig = ch.pianoNotes
      let origLen = orig.length
      let span = cur * 4
      let rep = 1
      while (rep < reps) {
        let k = 0
        while (k < origLen) {
          let n = orig[k]
          let cn = clonePianoNote(n)
          cn.startBeat = n.startBeat + rep * span
          ch.pianoNotes.push(cn)
          k = k + 1
        }
        rep = rep + 1
      }
    }
  }
  // Ensure the step array spans the target bars (tile the current single bar).
  if (ch.steps.length < targetSteps) {
    let curLen = ch.steps.length < 1 ? 1 : ch.steps.length
    let out = []
    let i = 0
    while (i < targetSteps) {
      let st = ch.steps[i % curLen]
      out.push(makeStep(st.on, st.vel !== null ? st.vel : 100))
      i = i + 1
    }
    ch.steps = out
  }
  ch.patternBars = target
}

export fn clearAllSteps(ch) {
  let si = 0
  while (si < 16) {
    ch.steps[si].on = false
    si = si + 1
  }
}

export fn toggleStep(ch, stepIdx) {
  let st = ch.steps[stepIdx]
  st.on = !st.on
}

export fn clearStep(ch, stepIdx) {
  ch.steps[stepIdx].on = false
}

fn setStepVel(ch, stepIdx, vel) {
  ch.steps[stepIdx].vel = vel
}

export fn setChannelGain(ch, g) {
  ch.gain = g
}

export fn setChannelPan(ch, p) {
  ch.pan = p
}

// 3-band track EQ (dB). band = "eqLo" | "eqMid" | "eqHi".
export fn setChannelEq(ch, band, v) {
  if (band === "eqLo") {
    ch.eqLo = v
  } else if (band === "eqMid") {
    ch.eqMid = v
  } else if (band === "eqHi") {
    ch.eqHi = v
  }
}

export fn setChannelMute(ch, on) {
  ch.mute = on
}

export fn setChannelSolo(ch, on) {
  ch.solo = on
}

// ADSR lives on generatorParams (basicOsc / fmTone / noiseBurst attack).
fn setGeneratorAdsr(ch, a, d, s, r) {
  if (!ch.generatorParams) {
    return
  }
  ch.generatorParams.attack = a
  ch.generatorParams.decay = d
  ch.generatorParams.sustain = s
  ch.generatorParams.release = r
}

export fn clampPianoNoteToFirstBar(n, minDur) {
  let bar = 4
  let md = minDur
  if ((md === null) || md <= 0) {
    md = 0.0078125
  }
  if (n.startBeat < 0) {
    n.startBeat = 0
  }
  if (n.startBeat >= bar) {
    n.startBeat = bar - md
  }
  if (n.startBeat < 0) {
    n.startBeat = 0
  }
  if (n.startBeat + n.durBeats > bar) {
    n.durBeats = bar - n.startBeat
  }
  if (n.durBeats < md) {
    n.durBeats = md
    if (n.startBeat + n.durBeats > bar) {
      n.startBeat = bar - md
      if (n.startBeat < 0) {
        n.startBeat = 0
      }
    }
  }
}

export fn clampChannelPianoNotesToFirstBar(ch, minDur) {
  if (!ch.pianoNotes) {
    return
  }
  let i = 0
  while (i < ch.pianoNotes.length) {
    clampPianoNoteToFirstBar(ch.pianoNotes[i], minDur)
    i = i + 1
  }
}

/// Clamp a note into the channel's full pattern (bars*4 beats), not just the first bar — so notes can
/// live on any bar of a multi-bar pattern.
export fn clampPianoNoteToPattern(ch, n, minDur) {
  let bars = (ch.patternBars !== null && Math.floor(ch.patternBars) >= 1) ? Math.floor(ch.patternBars) : 1
  let lim = bars * 4
  let md = minDur
  if ((md === null) || md <= 0) {
    md = 0.0078125
  }
  if (n.startBeat < 0) {
    n.startBeat = 0
  }
  if (n.startBeat >= lim) {
    n.startBeat = lim - md
  }
  if (n.startBeat < 0) {
    n.startBeat = 0
  }
  if (n.startBeat + n.durBeats > lim) {
    n.durBeats = lim - n.startBeat
  }
  if (n.durBeats < md) {
    n.durBeats = md
    if (n.startBeat + n.durBeats > lim) {
      n.startBeat = lim - md
      if (n.startBeat < 0) {
        n.startBeat = 0
      }
    }
  }
}

export fn addPianoNote(ch, startBeat, durBeats, pitch, vel) {
  let n = { startBeat: startBeat, durBeats: durBeats, pitch: pitch, vel: vel, prob: 1, ratchet: 1, nudge: 0 }
  clampPianoNoteToPattern(ch, n, 0.0078125)
  ch.pianoNotes.push(n)
}

export fn removePianoNoteAt(ch, idx) {
  ch.pianoNotes.splice(idx, 1)
}

fn quantizeNoteToStep(note, stepFrac) {
  let q = Math.round(note.startBeat / stepFrac) * stepFrac
  note.startBeat = q
}