#let contact(text: "", link: none) = {
  (text: text, link: link)
}
#let subSection(title: "", titleEnd: none, subTitle: none, subTitleEnd: none, content: []) = {
  (title: title, titleEnd: titleEnd, subTitle: subTitle, subTitleEnd: subTitleEnd, content: content)
}
#let section(title: "", content: subSection()) = {
  (title: title, content: content)
}
#let project(
  theme: rgb("#4273B0"),
  name: "",
  email: none,
  title: none,
  contact: ((text: [], link: "")),
  skills: (
    languages: ()
  ),
  main: (
    (title: "", content: [])
  ),
  philosophy: (),
  projects: (),
  sidebar: (),
  body) = {
  let backgroundTitle(content) = {
    align(center, box(fill: theme, text(white, size: 1.25em, weight: "bold", upper(content)), width: 1fr, inset: 0.3em))
  }
  let secondaryTitle(content) = {
    text(weight: "bold", size: 1.125em, upper(content))
  }
  let italicColorTitle(content) = {
    text(weight: "bold", style: "italic", size: 1.125em, theme, content)
  }
  let formattedName = block(upper(text(2.5em, weight: "bold", theme, name)))
  let formattedTitle = block(upper(text(2.25em, gray.darken(50%), title)))
  let titleColumn = align(center)[
    #formattedName
    #formattedTitle
  ]
  let contactColumn = align(center)[#contact.map(c => {
    if c.link == none [
      #c.text\
    ] else [
      #underline(link(c.link, text(theme, c.text)))\
    ]
  }).join()]
  grid(
    columns: (1fr, 2fr),
    column-gutter: 2em,
    contactColumn,
    titleColumn,
  )
  
  set par(justify: true)
  let formattedLanguageSkills = [
    #text(skills.languages.join(" • "))
  ]
  let createLeftRight(left: [], right: none) = {
    if (right == none) { 
      align(start, text(left))
    } else {
      grid(
        columns: (1fr, 1fr),
        align(start, text(left)),
        align(end, right),
      )
    } 
  }
//  let parseContentList(contentList) = {
//    if contentList.format == "bulletJoin" [
//      #text(contentList.content.join(" • "))
//    ] else if contentList.format == "bulletList" [
//      #contentList.content.map(c => list(c)).join()
//    ]
//  }
  let parseSubSections(subSections) = {
    subSections.map(s => {
      [
        #createLeftRight(
          left: secondaryTitle(s.title),
          right: if s.titleEnd != none { 
            italicColorTitle(s.titleEnd)
          }
        )
        #if s.subTitle != none or s.subTitleEnd != none [
          #text(
            top-edge: 0.2em,
            createLeftRight(
              left: italicColorTitle(s.subTitle),
              right: s.subTitleEnd
            ),
          )
        ]
        #s.content
      ]
    }).join()
  }
  let parseSection(section) = {
    section.map(m => {
      [
        #backgroundTitle(m.title)
        #parseSubSections(m.content)
      ]
    }).join()
  }
  let mainSection = parseSection(main)
  let sidebarSection = parseSection(sidebar)
  backgroundTitle("Philosophy")
  text(philosophy)
  grid(
    columns: (1fr, 2fr),
    column-gutter: 1em,
    sidebarSection,
    mainSection,
  )
  backgroundTitle("Projects")
  parseSubSections(projects)
  // Main body.
  set par(justify: true)
  show: columns.with(3, gutter: 1.3em)
  // body
}

#import "template.typ": *
#set page(
  margin: (
    left: 10mm,
    right: 10mm,
    top: 15mm,
    bottom: 15mm
  ),
)
#set text(font: "Mulish")
#show: project.with(
  theme: rgb("#0F83C0"),
  name: "Mayeul d'Avezac",
  title: "Senior Software Engineer",
  contact: (
    contact(
      text: "+44 777 520 2510"
    ),
    contact(
      text: "mdavezac@cart.aleeas.com", 
      link: "mailto:mdavezac@cart.aleeas.com"
    ),
    contact(
      text: "gitHub.com/mdavezac",
      link: "https://www.github.com/mdavezac"
    ),
    contact(
      text: "linkedin", 
      link: "https://www.linkedin.com/in/mayeul-davezac"
    )
  ),
  philosophy: "I am a sofware developer at heart. I believe that an efficient and sustainable code-base is one that is created by combining deep understanding of the practicalities of the underlying domain science, while keeping sight of the realities of the business lifecycle, and taking a rigorous approach to testing and monitoring.",
  main: (
    section(
      title: "Work Experience",
      content: (
        subSection(
          title: "Roke Manor Research",
          titleEnd: "Woking, UK",
          subTitle: "Senior Consultant Engineer",
          subTitleEnd: "(1.5 years -- present)",
          content: list(
            [Algorithmic developments for ecosystem surrounding the defense sensor communication protocol SAPIENT],
            [Lead developer for validation utility of SAPIENT messaging life-cycle (c++20)],
            [Main architect for routing-middleware for SAPIENT (rust)],
            [Point-person for development and maintenance of data fusion, tracking and tasking algorithms for SAPIENT fusion node (c++17)],
          ),
        ),
        subSection(
          title: "Kagenova",
          titleEnd: "London, UK",
          subTitle: "Co-Founder",
          subTitleEnd: "(3-year part-time, 1 year full-time)",
          content: list(
            [Numerical Transforms for Tensorflow (python)],
            [Infrastructure as code deployment of AI pipeline and web application across Google cloud and AWS (pulumi)],
            [Web Application with Flask and FastAPI (python)]
          ),
        ),
        subSection(
          title: "Imperial College London",
          titleEnd: "London, UK",
          subTitle: "Senior Research Software Developer",
          subTitleEnd: "3 years",
          content: list(
            [Embedded Software Engineer in research groups across university, with many applications from small scripts to HPC Simulations, using different tech stacks],
        [Teaching Software Development Best Practices to Researchers and Post-graduate students]
          ),
        ),
        subSection(
          title: "Cryptalabs",
          titleEnd: "London, UK",
          subTitle: "Main Programmer and Physicist",
          subTitleEnd: "1 year",
          content: list(
            [Implementation of a quantum random number on Android, using flash and camera to generate quantum noise],
          ),
        ),
        subSection(
          title: "UCL",
          titleEnd: "London, UK",
          subTitle: "Research Software Developer",
          subTitleEnd: "5 years",
        ),
        subSection(
          title: "NREL",
          titleEnd: "Golden, Co, USA",
          subTitle: "Post-Graduate Student and Junior Staff Scientist",
          subTitleEnd: "7 years",
        ),
      ),
    ),
  ),
  projects: (
    subSection(
      title: "AI Pipeline and Web-app Devops",
      content: ("As a co-founder at Kagenova, I wore many hats. Under the guise of one those hats, I became a devops engineer and fully automated our infrastructure using Pulumi, an infrastructure-as-code library. The app consisted of a REST interface (using flask) on google cloud that would take images as input and send them to AWS step function. The step function would stanitize the input and then run an AI model. The results were then sent back to google cloud for storage, where it would trigger various housekeeping functions (e.g. keep count of credits in Postgres) before being routed back to the user.  ")
    ),
    subSection(
      title: "Rust Middleware for the SAPIENT protocol",
      content: ("Roke is a leader within the SAPIENT ecosystem, a Defense protocol designed for sensors (fixed cameras, cameras on drones, radars, lidars, etc) to work together towards searching, identifying and tracking threats. I am the main architect of a middleware to route messages between sensors, fusion nodes, and tasking nodes. Using async Rust, as part of a team of 6 engineers, I am creating a lean, modular, reliable code designed to grow with the protocol and to keep the cost of future feature-adds low.")
    ),
    subSection(
      title: "Quantum random number generator",
      content: ("When joining Cryptalabs, I joined a team of entrepeneurs to become the lead physicist - of one - and the lead programmer - of one. Such are startups. There I learned the domain science, the physics behind quantum random numbers and the math required to condense partially random streams into fully random numbers, as well as new language and stack, Kotlin on Android. Whithin a year I developed a quantum random number generator that third parties could and did integrate into their own security apps using a single line of code.")
    ),
  ),
  sidebar: (
    section(
      title: "Skills",
      content: (
        subSection(
          title: "Languages",
          content: (
            "C++20",
            "Python",
            "Rust",
            "Julia",
            "nix"
          ).join(" • "),
        ),
        subSection(
          title: "Technologies",
          content: (
            "numpy",
            "pandas",
            "xarray",
            "tensorflow",
            "tokio",
            "trio",
            "fastapi",
            "flask",
            "pulumi",
          ).join(" • "),
        ),
        subSection(
          title: "concepts",
          content: (
            "Object-oriented programming",
            "Test-driven development",
            "Functional Programming",
            "Data Pipelines",
            "Agile Methodology",
          ).join(" • "),
        ),
      ),
    ),
    section(
      title: "Education",
      content: (
        subSection(
          title: [
            #set par(justify: false)
            La Sorbonne
          ],
          subTitle: "Ph.D. Condensed Matter Physics",
          content: [
            Graduated: Sept 2005\
            Paris, France
          ],
        ),
      ),
    ),
    section(
      title: "Other",
      content: (
        subSection(
          title: "Languages",
          content: (
            "Fluent English",
            "Fluent French",
            "Fair Spanish",
            "Beginner Cantonese"
          ).join(" • "),
        ),
        subSection(
          title: "Background",
          content: (
            "Startups",
            "Developer in Academia",
            "Academic",
            "Computational Material Science",
          ).join(" • "),
        ),
      ),
    ),
  ),
)