MixerRouting.tish

// Actor lanes for mixer grouping + routing: track → actor bus → master.

import { ensureCoDjMeta } from '../codj/CoDjMeta.tish'

export fn channelActorLane(ch, project) {
  if (ch.actorLane && String(ch.actorLane) !== "") {
    return String(ch.actorLane)
  }
  ensureCoDjMeta(project)
  let meta = project.coDjMeta.tracks[ch.id]
  let owner = meta && meta.ownerActorId ? String(meta.ownerActorId) : "human"
  // Deck A = "local" = the ROOM HOST's tracks (the source of truth), so every viewer sees the real
  // host on Deck A; Deck B = every other contributor (you-as-follower + agents). When solo or when
  // YOU are the host, your locally-authored ("human") tracks are the host lane.
  let host = project.coDjHostActorId ? String(project.coDjHostActorId) : null
  if (host === null) {
    return owner === "human" ? "local" : owner
  }
  if (owner === host) {
    return "local"
  }
  if (owner === "human") {
    return project.coDjIsHost === true ? "local" : "self"
  }
  return owner
}

export fn collectActorLanes(project) {
  let out = []
  let seen = {}
  let i = 0
  while (i < project.channels.length) {
    let lane = channelActorLane(project.channels[i], project)
    if (!seen[lane]) {
      seen[lane] = true
      out.push(lane)
    }
    i = i + 1
  }
  if (out.length === 0) {
    out.push("local")
  }
  return out
}

fn defaultActorMixEntry() {
  return {
    gain: 1,
    mute: false,
    solo: false,
    eqLo: 0,
    eqMid: 0,
    eqHi: 0
  }
}

export fn ensureActorMixerEntries(project) {
  if (!project.actorMixer) {
    project.actorMixer = {}
  }
  let lanes = collectActorLanes(project)
  let li = 0
  while (li < lanes.length) {
    let L = lanes[li]
    if (!project.actorMixer[L]) {
      project.actorMixer[L] = defaultActorMixEntry()
    } else {
      let a = project.actorMixer[L]
      if (a.gain === null) {
        a.gain = 1
      }
      if (a.mute === null) {
        a.mute = false
      }
      if (a.solo === null) {
        a.solo = false
      }
      if (a.eqLo === null) {
        a.eqLo = 0
      }
      if (a.eqMid === null) {
        a.eqMid = 0
      }
      if (a.eqHi === null) {
        a.eqHi = 0
      }
    }
    li = li + 1
  }
}

export fn ensureMasterMixer(project) {
  if (!project.masterMixer) {
    project.masterMixer = { eqLo: 0, eqMid: 0, eqHi: 0, compEnabled: true, reverbEnabled: true }
  } else {
    let m = project.masterMixer
    if (m.eqLo === null) {
      m.eqLo = 0
    }
    if (m.eqMid === null) {
      m.eqMid = 0
    }
    if (m.eqHi === null) {
      m.eqHi = 0
    }
    // Master glue compressor + shared reverb send bus are on by default; these toggle them.
    if (m.compEnabled === null) {
      m.compEnabled = true
    }
    if (m.reverbEnabled === null) {
      m.reverbEnabled = true
    }
  }
}

export fn anyActorSolo(project) {
  if (!project.actorMixer) {
    return false
  }
  let keys = Object.keys(project.actorMixer)
  let i = 0
  while (i < keys.length) {
    let row = project.actorMixer[keys[i]]
    if (row && row.solo) {
      return true
    }
    i = i + 1
  }
  return false
}

export fn actorLaneAudible(project, lane) {
  if (!project.actorMixer || !project.actorMixer[lane]) {
    return true
  }
  let am = project.actorMixer[lane]
  if (am.mute) {
    return false
  }
  if (anyActorSolo(project)) {
    return am.solo
  }
  return true
}