#import "utils.typ": get-group-span
#import "renderer.typ": render
#import "participant.typ" as participant: _par, PAR-SPECIALS

#let _gap(size: 20) = {
  return ((
    type: "gap",
    size: size
  ),)
}

#let _evt(participant, event) = {
  return ((
    type: "evt",
    participant: participant,
    event: event,
    lifeline-style: auto
  ),)
}

#let diagram(elements) = {
  if elements == none {
    return
  }
  
  let participants = ()
  let elmts = elements
  let i = 0

  // Flatten groups
  while i < elmts.len() {
    let elmt = elmts.at(i)
    if elmt.type == "grp" {
      let grp-elmts = elmt.elmts
      elmt.elmts = elmt.elmts.map(e => {
        if e.type == "seq" {
          if e.p1 == "?" {
            e.p1 = "?" + e.p2
          } else if e.p2 == "?" {
            e.p2 = e.p1 + "?"
          }
        }
        e
      })
      elmts.at(i) = elmt
      elmts = (
        elmts.slice(0, i + 1) +
        grp-elmts +
        ((
          type: "grp-end"
        ),) +
        elmts.slice(i+1)
      )
    }
    i += 1
  }

  // List participants
  let linked = ()
  for elmt in elmts {
    if elmt.type == "par" {
      participants.push(elmt)
    } else if elmt.type == "seq" {
      if not participant._exists(participants, elmt.p1) {
        participants.push(_par(elmt.p1).first())
      }
      if not participant._exists(participants, elmt.p2) {
        let par = _par(elmt.p2, from-start: not elmt.create-dst).first()
        participants.push(par)
      
      } else if elmt.create-dst {
        let i = participants.position(p => p.name == elmt.p2)
        participants.at(i).from-start = false
      }

      if elmt.p1 == "?" {
        linked.push("?" + elmt.p2)
      } else {
        linked.push(elmt.p1)
      }
      if elmt.p2 == "?" {
        linked.push(elmt.p1 + "?")
      } else {
        linked.push(elmt.p2)
      }
    }
  }
  linked = linked.dedup()

  let pars = participants
  participants = ()
  
  if "[" in linked {
    participants.push(_par("[", invisible: true).first())
  }
  
  for (i, p) in pars.enumerate() {
    let before = _par("?" + p.name, invisible: true).first()
    let after = _par(p.name + "?", invisible: true).first()
    
    if before.name in linked {
      if participants.len() == 0 or not participants.last().name.ends-with("?") {
        participants.push(before)
      } else {
        participants.insert(-1, before)
      }
    }

    participants.push(p)

    if after.name in linked {
      participants.push(after)
    }
  }
  if "]" in linked {
    participants.push(_par("]", invisible: true).first())
  }

  // Add index to participant
  for (i, p) in participants.enumerate() {
    p.insert("i", i)
    participants.at(i) = p
  }

  // Compute groups spans (horizontal)
  for (i, elmt) in elmts.enumerate() {
    if elmt.type == "grp" {
      let (min-i, max-i) = get-group-span(participants, elmt)
      elmts.at(i).insert("min-i", min-i)
      elmts.at(i).insert("max-i", max-i)
    } else if elmt.type == "seq" {
      if elmt.p1 == "?" {
        elmts.at(i).p1 = "?" + elmt.p2
      } else if elmt.p2 == "?" {
        elmts.at(i).p2 = elmt.p1 + "?"
      }
    }
  }

  render(participants, elmts)
}

#let from-plantuml(code) = {
  let code = code.text
}