///|
/// Mutable-style builder that returns a fresh builder for every operation.
pub(all) struct DispositionBuilder {
  kind : DispositionKind
  params : Array[Parameter]
  diagnostics : Array[Diagnostic]
} derive(Eq, Debug)

///|
pub fn DispositionBuilder::new(kind : DispositionKind) -> DispositionBuilder {
  { kind, params: [], diagnostics: [] }
}

///|
pub fn DispositionBuilder::attachment() -> DispositionBuilder {
  DispositionBuilder::new(Attachment)
}

///|
pub fn DispositionBuilder::inline() -> DispositionBuilder {
  DispositionBuilder::new(Inline)
}

///|
pub fn DispositionBuilder::form_data() -> DispositionBuilder {
  DispositionBuilder::new(FormData)
}

///|
pub fn DispositionBuilder::with_kind(
  self : DispositionBuilder,
  kind : DispositionKind,
) -> DispositionBuilder {
  {
    kind,
    params: clone_params(self.params),
    diagnostics: clone_diagnostics(self.diagnostics),
  }
}

///|
pub fn DispositionBuilder::with_param(
  self : DispositionBuilder,
  name : String,
  value : String,
) -> DispositionBuilder {
  let next = clone_params(self.params)
  next.push(Parameter::plain(name, value))
  {
    kind: self.kind,
    params: next,
    diagnostics: clone_diagnostics(self.diagnostics),
  }
}

///|
pub fn DispositionBuilder::with_extended_param(
  self : DispositionBuilder,
  name : String,
  value : String,
  charset? : String = "UTF-8",
  language? : String = "",
) -> DispositionBuilder {
  let next = clone_params(self.params)
  next.push(Parameter::extended(name, value, charset~, language~))
  {
    kind: self.kind,
    params: next,
    diagnostics: clone_diagnostics(self.diagnostics),
  }
}

///|
pub fn DispositionBuilder::with_filename(
  self : DispositionBuilder,
  filename : String,
) -> DispositionBuilder {
  self.with_filename_policy(filename, FilenamePolicy::default())
}

///|
pub fn DispositionBuilder::with_filename_policy(
  self : DispositionBuilder,
  filename : String,
  policy : FilenamePolicy,
) -> DispositionBuilder {
  let report = sanitize_filename_with_policy(filename, policy)
  let next = clone_params(self.params)
  next.push(Parameter::plain("filename", report.value))
  if needs_extended_filename(filename) {
    next.push(
      Parameter::extended("filename", filename, charset="UTF-8", language=""),
    )
  }
  let diagnostics = clone_diagnostics(self.diagnostics)
  append_diagnostics(diagnostics, report.diagnostics)
  { kind: self.kind, params: next, diagnostics }
}

///|
pub fn DispositionBuilder::with_form_name(
  self : DispositionBuilder,
  name : String,
) -> DispositionBuilder {
  self.with_param("name", name)
}

///|
pub fn DispositionBuilder::without_param(
  self : DispositionBuilder,
  name : String,
) -> DispositionBuilder {
  let wanted = normalize_param_name(name)
  let next : Array[Parameter] = []
  for p in self.params {
    if p.name != wanted {
      next.push(p)
    }
  }
  {
    kind: self.kind,
    params: next,
    diagnostics: clone_diagnostics(self.diagnostics),
  }
}

///|
pub fn DispositionBuilder::build(self : DispositionBuilder) -> Disposition {
  {
    kind: self.kind,
    params: clone_params(self.params),
    diagnostics: clone_diagnostics(self.diagnostics),
  }
}

///|
pub fn DispositionBuilder::to_header(self : DispositionBuilder) -> String {
  self.build().to_header()
}

///|
pub fn Disposition::to_builder(self : Disposition) -> DispositionBuilder {
  {
    kind: self.kind,
    params: clone_params(self.params),
    diagnostics: clone_diagnostics(self.diagnostics),
  }
}

///|
pub fn Disposition::with_param(
  self : Disposition,
  name : String,
  value : String,
) -> Disposition {
  self.to_builder().with_param(name, value).build()
}

///|
pub fn Disposition::without_param(
  self : Disposition,
  name : String,
) -> Disposition {
  self.to_builder().without_param(name).build()
}

///|
fn clone_params(params : Array[Parameter]) -> Array[Parameter] {
  let out : Array[Parameter] = []
  for p in params {
    out.push(p)
  }
  out
}

///|
fn clone_diagnostics(diagnostics : Array[Diagnostic]) -> Array[Diagnostic] {
  let out : Array[Diagnostic] = []
  for d in diagnostics {
    out.push(d)
  }
  out
}

///|
fn append_diagnostics(
  target : Array[Diagnostic],
  source : Array[Diagnostic],
) -> Unit {
  for d in source {
    target.push(d)
  }
}