#import "/metadata.typ": *
#pagebreak()
#let base-url = "https://github.com/PI-E2EEDA/Plein-de-eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee-project/issues/"
#let github-link(id) = {
  link(base-url+str(id))[\##str(id)]
}
#let github-link-name(id, name) = {
  link(base-url+str(id))[#name]
}
#let issue(
  id,
  name,
  sp: 0,
  link: (),
  description: none,
) = {
  (
    github-link(id),
    github-link-name(id, name),
    for l in link [\##l ],
    if description == none [] else {description},
    sp
)}

#let display(workload) = {
  let task = ()
  for w in workload {
    task.push(w.at(0))
    task.push(w.at(1))
    task.push(w.at(2))
    task.push(w.at(3))
    task.push(str(w.at(4)))
  }
  task
}


= Planned tasks <sec:spec:planned_tasks>

Below are listed the general tasks to execute during this project.
Each tasks may be subdivided into smaller ones in the #link(base-url)[*GitHub board*].

#let workload = {(
  issue(1, [Sample Zephyr], description: [Getting to know with BLE secure advertising and Zephyr], sp: 1),
  issue(2, link: (2,), [Node firmware definition], description: [Defining each nodes software (and potential bootloader)], sp: 1),
  issue(3, link: (2, 4), [Node implementation], description: [Implementation of the nodes, including low-power care], sp: 8),
  issue(4, [Gateway firmware definition], description: [Definition of the gateway software, including communication with the nodes], sp: 1),
  issue(5, link: (4,), [Gateway implementation], description: [Implementation of the gateway software], sp: 6),
  issue(6, [Database setup], description: [Setup of the temporal data storage, including a service to add new values], sp: 3),
  issue(7, [DB data retrieval], link: (6,), description: [Implementation of an API allowing to retrieve data from the DB], sp: 4),
  issue(8, [2D map GUI], link: (7,), description: [Implementation of a service displaying the sensor data at a given time], sp: 6),
  issue(9, [MeteoSwiss API grasping], description: [Retrieve MeteoSwiss data to get the outside environmental data], sp: 3),
  issue(10, [Windows opening forecasting], description: [Training of a model telling the optimal windows opening time], sp: 8),
  issue(11, [Notification setup], link: (10,), description: [Considering the window opening recommendation, sends a notification to the room users], sp: 3),
  issue(12, [Analysis of the room data evolution], description: [Analysis of the temperature and CO2 level evolution regarding window opening status over time], sp: 7),
  issue(13, [Documentation], description: [Report and code comments], sp: 9),
)}

#let sum-sp = 0
#for w in workload {
  sum-sp += w.at(4)
}

// #show table.cell.where(y: 0): strong
// #set table(
//   stroke: (x, y) => if y == 0 {
//     (bottom: 0.7pt + black)
//   },
//   align: (x, y) => (
//     if x == 4 { right }
//     else { left }
//   )
// )

#set par(justify: false)
#table(
  columns:(
    // 2.5em,
    2fr,
    // 3.5em,
    5fr,
    2em
  ),
  align: left,
  table.header(
    // "ID",
    "Name",
    // "Linked",
    "Description",
    "SP"
  ),
  ..{
    let task = ()
    for w in workload {
      // task.push(w.at(0))
      task.push(w.at(1))
      // task.push(w.at(2))
      task.push(w.at(3))
      task.push(align(center)[#str(w.at(4))])
    }
    task
  },
  table.cell(stroke: none)[],
  table.cell(stroke: none)[#align(right)[Total:]],
  table.cell(stroke: none)[#sum-sp],
)

The various fields are assigned considering @tab:repartition.
#figure(
  table(
    columns: (auto, auto),
    align: center,
    table.header("Field", "Assigned to"),
    [Team lead | Administrative elements],[Adrien],
    [Embedded Software],[Adrien, Rémi],
    [Communication between components],[Rémi, Djelal],
    [Database interfacing],[Ibrahima],
    [Machine learning | Data exploitation],[Ibrahima, Dimitri],
    [Physic Modelling],[Alison]
  )
)<tab:repartition>

#let dispatch(id, sp) = {
  let task = workload.at(id - 1)
  ([#link(task.at(0).dest)[#task.at(0).body - #task.at(1)] (#sp/#task.at(4))], sp)
}

#let display-dispatching(person) = {
  let total = 0.0
  for d in person {
    d.at(0)
    linebreak()
    total = total + d.at(1) 
  }
  underline[Total SP: #str(total)]
  
}

#let Djelal = [
  #underline[A. Djelal]\
  #display-dispatching((
    dispatch(1, 0.5),
    dispatch(3, 1),
    dispatch(4, 1),
    dispatch(5, 6),
    dispatch(13, 1.5),  
  ))
]

#let Adrien = [
  #underline[B. Adrien]\
  #display-dispatching((
    dispatch(1, 0.5),
    dispatch(2, 1),
    dispatch(3, 7),
    dispatch(13, 1.5),  
  ))
]

#let Rémi = [
  #underline[H. Rémi]\
  #display-dispatching((
    dispatch(6, 3),
    dispatch(7, 4),
    dispatch(9, 1.5),
    dispatch(13, 1.5), 
  ))
]

#let Dimitri = [
  #underline[I. Dimitri]\
  #display-dispatching((
    dispatch(9, 1.5),
    dispatch(10, 7),
    dispatch(13, 1.5),  
  ))
]

#let Alison = [
  #underline[L. Alison]\
  #display-dispatching((
    dispatch(8, 0.5),
    dispatch(10, 1),
    dispatch(12, 7),
    dispatch(13, 1.5),  
  ))
]

#let Ibrahima = [
  #underline[S. Ibrahima]\
  #display-dispatching((
    dispatch(8, 5.5),
    dispatch(11, 3),
    dispatch(13, 1.5),  
  ))
]

#set text(size: 0.8em)
#grid(
  columns: (1fr, 1fr),
  column-gutter: 1em,
  row-gutter: 2em,
  Djelal,
  Adrien,
  Rémi,
  Dimitri,
  Alison,
  Ibrahima,
)