///|
/// Frame header.
#derive(Debug)
pub(all) struct FrameHeader {
  all_default : Bool
  frame_type : FrameType
  encoding : Encoding
  flags : FrameFlags
  do_ycbcr : Bool
  /// Use `encoded_color_channels()`.
  encoded_color_channels : Int32
  jpeg_upsampling : FixedArray[Int32]
  upsampling : Int32
  ec_upsampling : Array[Int32]
  group_size_shift : Int32
  x_qm_scale : Int32
  b_qm_scale : Int32
  passes : Passes
  lf_level : Int32
  have_crop : Bool
  x0 : Int32
  y0 : Int32
  width : Int32
  height : Int32
  blending_info : BlendingInfo
  ec_blending_info : Array[BlendingInfo]
  duration : UInt32
  timecode : UInt32
  is_last : Bool
  save_as_reference : Int32
  resets_canvas : Bool
  save_before_ct : Bool
  name : String
  restoration_filter : RestorationFilter
  extensions : @image.Extensions
  bit_depth : @image.BitDepth
}

///|
#derive(Debug)
pub(all) struct Passes {
  num_passes : Int32
  num_ds : Int32
  shift : Array[Int32]
  downsample : Array[Int32]
  last_pass : Array[Int32]
}

///|
#derive(Debug)
pub(all) struct BlendingInfo {
  mode : BlendMode
  alpha_channel : Int32
  clamp : Bool
  source : Int32
}

///|
#derive(Debug)
pub(all) struct RestorationFilter {
  all_default : Bool
  gab : Gabor
  epf : EdgePreservingFilter
  extensions : @image.Extensions
}

///|
priv struct CanvasSizeParams {
  have_crop : Bool
  x0 : Int32
  y0 : Int32
  width : Int32
  height : Int32
  size : @image.SizeHeader
}

///|
fn read_u32_int(
  bs : @bitstream.Bitstream,
  a : @bitstream.U32Spec,
  b : @bitstream.U32Spec,
  c : @bitstream.U32Spec,
  d : @bitstream.U32Spec,
) -> Int32 raise @bitstream.JxlError {
  bs.read_u32(a, b, c, d).reinterpret_as_int()
}

///|
fn read_upsampling(
  bs : @bitstream.Bitstream,
) -> Int32 raise @bitstream.JxlError {
  read_u32_int(
    bs,
    @bitstream.c(1),
    @bitstream.c(2),
    @bitstream.c(4),
    @bitstream.c(8),
  )
}

///|
fn read_crop_u32(bs : @bitstream.Bitstream) -> UInt32 raise @bitstream.JxlError {
  bs.read_u32(
    @bitstream.u(8),
    @bitstream.cu(256, 11),
    @bitstream.cu(2304, 14),
    @bitstream.cu(18688, 30),
  )
}

///|
pub fn FrameHeader::parse(
  bs : @bitstream.Bitstream,
  headers : @image.ImageHeader,
) -> FrameHeader raise @bitstream.JxlError {
  let metadata = headers.metadata
  let num_ec = metadata.ec_info.length()
  let all_default = bs.read_bool()
  let frame_type = if !all_default {
    FrameType::parse(bs)
  } else {
    RegularFrame
  }
  let encoding = if !all_default { Encoding::parse(bs) } else { VarDct }
  let flags = if !all_default { FrameFlags::parse(bs) } else { FrameFlags(0) }
  let do_ycbcr = if !all_default && !metadata.xyb_encoded {
    bs.read_bool()
  } else {
    false
  }
  let encoded_color_channels = {
    let acutally_grayscale = encoding == Modular &&
      !do_ycbcr &&
      !metadata.xyb_encoded &&
      metadata.grayscale()
    if acutally_grayscale {
      1
    } else {
      3
    }
  }
  let jpeg_upsampling = FixedArray::make(3, 0)
  if do_ycbcr && !flags.use_lf_frame() {
    for i in 0..<3 {
      jpeg_upsampling[i] = bs.read_bits_int(2)
    }
  }
  let upsampling = if !all_default && !flags.use_lf_frame() {
    read_upsampling(bs)
  } else {
    1
  }
  let ec_upsampling = if !all_default && !flags.use_lf_frame() {
    let v = []
    for _ in 0.. a.have_timecodes
    None => false
  }
  let timecode = if !all_default &&
    frame_type.is_normal_frame() &&
    have_timecodes {
    bs.read_bits(32)
  } else {
    0
  }
  let is_last = if !all_default && frame_type.is_normal_frame() {
    bs.read_bool()
  } else {
    frame_type == RegularFrame
  }
  let save_as_reference = if !all_default && frame_type != LfFrame && !is_last {
    bs.read_bits_int(2)
  } else {
    0
  }
  let resets_canvas = FrameHeader::resets_canvas_(blending_info.mode, canvas)
  let save_before_ct = if !all_default &&
    (
      frame_type == ReferenceOnly ||
      (
        resets_canvas &&
        !is_last &&
        (duration == 0 || save_as_reference != 0) &&
        frame_type != LfFrame
      )
    ) {
    bs.read_bool()
  } else {
    !frame_type.is_normal_frame()
  }
  let name = if !all_default { @bitstream.read_name(bs) } else { "" }
  let restoration_filter = if !all_default {
    RestorationFilter::parse(bs, encoding)
  } else {
    RestorationFilter::default()
  }
  let extensions = if !all_default {
    @image.Extensions::parse(bs)
  } else {
    @image.Extensions::default()
  }
  let bit_depth = metadata.bit_depth
  {
    all_default,
    frame_type,
    encoding,
    flags,
    do_ycbcr,
    encoded_color_channels,
    jpeg_upsampling,
    upsampling,
    ec_upsampling,
    group_size_shift,
    x_qm_scale,
    b_qm_scale,
    passes,
    lf_level,
    have_crop,
    x0,
    y0,
    width,
    height,
    blending_info,
    ec_blending_info,
    duration,
    timecode,
    is_last,
    save_as_reference,
    resets_canvas,
    save_before_ct,
    name,
    restoration_filter,
    extensions,
    bit_depth,
  }
}

///|
/// `FrameHeader::default_with_context(headers)`: the header of an all-default frame.
pub fn FrameHeader::default(headers : @image.ImageHeader) -> FrameHeader {
  FrameHeader::parse(@bitstream.Bitstream::new(b"\xff"), headers) catch {
    _ => abort("all_default frame header cannot fail")
  }
}

///|
pub fn Passes::default() -> Passes {
  { num_passes: 1, num_ds: 0, shift: [], downsample: [], last_pass: [], }
}

///|
pub fn Passes::parse(
  bs : @bitstream.Bitstream,
) -> Passes raise @bitstream.JxlError {
  let num_passes = read_u32_int(
    bs,
    @bitstream.c(1),
    @bitstream.c(2),
    @bitstream.c(3),
    @bitstream.cu(4, 3),
  )
  let num_ds = if num_passes != 1 {
    read_u32_int(
      bs,
      @bitstream.c(0),
      @bitstream.c(1),
      @bitstream.c(2),
      @bitstream.cu(3, 1),
    )
  } else {
    0
  }
  let shift = []
  let downsample = []
  let last_pass = []
  if num_passes != 1 {
    for _ in 0..<(num_passes - 1) {
      shift.push(bs.read_bits_int(2))
    }
    for _ in 0.. BlendingInfo {
  { mode: Replace, alpha_channel: 0, clamp: false, source: 0, }
}

///|
fn BlendingInfo::parse(
  bs : @bitstream.Bitstream,
  has_ec : Bool,
  base_mode : BlendMode?,
  canvas : CanvasSizeParams,
) -> BlendingInfo raise @bitstream.JxlError {
  let mode = BlendMode::parse(bs)
  let alpha_channel = if has_ec && (mode == Blend || mode == MulAdd) {
    read_u32_int(
      bs,
      @bitstream.c(0),
      @bitstream.c(1),
      @bitstream.c(2),
      @bitstream.cu(3, 3),
    )
  } else {
    0
  }
  let clamp = if (has_ec && (mode == Blend || mode == MulAdd)) || mode == Mul {
    bs.read_bool()
  } else {
    false
  }
  let mode_for_reset = match base_mode {
    Some(m) => m
    None => mode
  }
  let source = if !FrameHeader::resets_canvas_(mode_for_reset, canvas) {
    bs.read_bits_int(2)
  } else {
    0
  }
  { mode, alpha_channel, clamp, source, }
}

///|
pub fn RestorationFilter::default() -> RestorationFilter {
  {
    all_default: true,
    gab: Gabor::default(),
    epf: EdgePreservingFilter::default(),
    extensions: @image.Extensions::default(),
  }
}

///|
pub fn RestorationFilter::parse(
  bs : @bitstream.Bitstream,
  encoding : Encoding,
) -> RestorationFilter raise @bitstream.JxlError {
  let all_default = bs.read_bool()
  let gab = if !all_default { Gabor::parse(bs) } else { Gabor::default() }
  let epf = if !all_default {
    EdgePreservingFilter::parse(bs, encoding)
  } else {
    EdgePreservingFilter::default()
  }
  let extensions = if !all_default {
    @image.Extensions::parse(bs)
  } else {
    @image.Extensions::default()
  }
  { all_default, gab, epf, extensions, }
}

///|
fn FrameHeader::test_full_image(canvas_size : CanvasSizeParams) -> Bool {
  let { x0, y0, width, height, size, .. } = canvas_size
  if x0 > 0 || y0 > 0 {
    return false
  }
  let right = x0.to_int64() + width.to_int64()
  let bottom = y0.to_int64() + height.to_int64()
  right >= size.width.to_int64() && bottom >= size.height.to_int64()
}

///|
fn FrameHeader::resets_canvas_(
  blending_mode : BlendMode,
  canvas_size : CanvasSizeParams,
) -> Bool {
  blending_mode == Replace &&
  (!canvas_size.have_crop || FrameHeader::test_full_image(canvas_size))
}

///|
fn FrameHeader::compute_default_xqms(
  encoding : Encoding,
  xyb_encoded : Bool,
) -> Int32 {
  if xyb_encoded && encoding == VarDct {
    3
  } else {
    2
  }
}

///|
/// Returns whether this frame is a keyframe that should be displayed.
pub fn FrameHeader::is_keyframe(self : FrameHeader) -> Bool {
  self.frame_type.is_normal_frame() && (self.is_last || self.duration != 0)
}

///|
pub fn FrameHeader::can_reference(self : FrameHeader) -> Bool {
  !self.is_last &&
  (self.duration == 0 || self.save_as_reference != 0) &&
  self.frame_type != LfFrame
}

///|
fn div_ceil(a : Int32, b : Int32) -> Int32 {
  // Unsigned semantics: operands are non-negative u32 values in upstream.
  ((a.reinterpret_as_uint() + b.reinterpret_as_uint() - 1) /
  b.reinterpret_as_uint()).reinterpret_as_int()
}

///|
pub fn FrameHeader::sample_width(
  self : FrameHeader,
  upsampling : Int32,
) -> Int32 {
  let mut width = self.width
  let lf_level = self.lf_level
  if upsampling > 1 {
    width = div_ceil(width, upsampling)
  }
  if lf_level > 0 {
    let div = 1 << (3 * lf_level)
    width = (width + div - 1) >> (3 * lf_level)
  }
  width
}

///|
pub fn FrameHeader::sample_height(
  self : FrameHeader,
  upsampling : Int32,
) -> Int32 {
  let mut height = self.height
  let lf_level = self.lf_level
  if upsampling > 1 {
    height = div_ceil(height, upsampling)
  }
  if lf_level > 0 {
    let div = 1 << (3 * lf_level)
    height = (height + div - 1) >> (3 * lf_level)
  }
  height
}

///|
pub fn FrameHeader::color_sample_width(self : FrameHeader) -> Int32 {
  self.sample_width(self.upsampling)
}

///|
pub fn FrameHeader::color_sample_height(self : FrameHeader) -> Int32 {
  self.sample_height(self.upsampling)
}

///|
/// Returns the number of channels actually encoded in the frame.
pub fn FrameHeader::encoded_color_channels(self : FrameHeader) -> Int32 {
  self.encoded_color_channels
}

///|
pub fn FrameHeader::num_groups(self : FrameHeader) -> Int32 {
  let width = self.color_sample_width()
  let height = self.color_sample_height()
  let group_dim = self.group_dim()
  let hgroups = div_ceil(width, group_dim)
  let vgroups = div_ceil(height, group_dim)
  hgroups * vgroups
}

///|
pub fn FrameHeader::num_lf_groups(self : FrameHeader) -> Int32 {
  let width = self.color_sample_width()
  let height = self.color_sample_height()
  let lf_group_dim = self.lf_group_dim()
  let hgroups = div_ceil(width, lf_group_dim)
  let vgroups = div_ceil(height, lf_group_dim)
  hgroups * vgroups
}

///|
pub fn FrameHeader::group_dim(self : FrameHeader) -> Int32 {
  128 << self.group_size_shift
}

///|
pub fn FrameHeader::groups_per_row(self : FrameHeader) -> Int32 {
  div_ceil(self.color_sample_width(), self.group_dim())
}

///|
pub fn FrameHeader::lf_group_dim(self : FrameHeader) -> Int32 {
  self.group_dim() * 8
}

///|
pub fn FrameHeader::lf_groups_per_row(self : FrameHeader) -> Int32 {
  div_ceil(self.color_sample_width(), self.lf_group_dim())
}

///|
pub fn FrameHeader::group_size_for(
  self : FrameHeader,
  group_idx : Int32,
) -> (Int32, Int32) {
  self.size_for(self.group_dim(), group_idx)
}

///|
pub fn FrameHeader::lf_group_size_for(
  self : FrameHeader,
  lf_group_idx : Int32,
) -> (Int32, Int32) {
  self.size_for(self.lf_group_dim(), lf_group_idx)
}

///|
fn FrameHeader::size_for(
  self : FrameHeader,
  group_dim : Int32,
  group_idx : Int32,
) -> (Int32, Int32) {
  let width = self.color_sample_width()
  let height = self.color_sample_height()
  let full_rows = height / group_dim
  let rows_remainder = height % group_dim
  let full_cols = width / group_dim
  let cols_remainder = width % group_dim
  let stride = full_cols + (if cols_remainder > 0 { 1 } else { 0 })
  let row = group_idx / stride
  let col = group_idx % stride
  let group_width = if col >= full_cols { cols_remainder } else { group_dim }
  let group_height = if row >= full_rows { rows_remainder } else { group_dim }
  (group_width, group_height)
}

///|
pub fn FrameHeader::lf_group_idx_from_group_idx(
  self : FrameHeader,
  group_idx : Int32,
) -> Int32 {
  let groups_per_row = self.groups_per_row()
  let lf_group_col = group_idx % groups_per_row / 8
  let lf_group_row = group_idx / groups_per_row / 8
  lf_group_col + lf_group_row * self.lf_groups_per_row()
}

///|
pub fn FrameHeader::group_idx_from_coord(
  self : FrameHeader,
  x : Int32,
  y : Int32,
) -> Int32? {
  let shift = 7 + self.group_size_shift
  let group_x = x.reinterpret_as_uint() >> shift
  let group_y = y.reinterpret_as_uint() >> shift
  let groups_per_row = self.groups_per_row().reinterpret_as_uint()
  let group_idx = group_y * groups_per_row + group_x
  if group_x >= groups_per_row ||
    group_idx >= self.num_groups().reinterpret_as_uint() {
    None
  } else {
    Some(group_idx.reinterpret_as_int())
  }
}

///|
pub fn FrameHeader::is_group_collides_region(
  self : FrameHeader,
  group_idx : Int32,
  region : (Int32, Int32, Int32, Int32),
) -> Bool {
  let group_dim = self.group_dim()
  let group_per_row = self.groups_per_row()
  let group_left = group_idx % group_per_row * group_dim
  let group_top = group_idx / group_per_row * group_dim
  is_aabb_collides(region, (group_left, group_top, group_dim, group_dim))
}

///|
pub fn FrameHeader::is_lf_group_collides_region(
  self : FrameHeader,
  lf_group_idx : Int32,
  region : (Int32, Int32, Int32, Int32),
) -> Bool {
  let lf_group_dim = self.lf_group_dim()
  let lf_group_per_row = self.lf_groups_per_row()
  let group_left = lf_group_idx % lf_group_per_row * lf_group_dim
  let group_top = lf_group_idx / lf_group_per_row * lf_group_dim
  is_aabb_collides(region, (group_left, group_top, lf_group_dim, lf_group_dim))
}

///|
#derive(Eq, Debug)
pub(all) enum FrameType {
  RegularFrame
  LfFrame
  ReferenceOnly
  SkipProgressive
}

///|
pub fn FrameType::default() -> FrameType {
  RegularFrame
}

///|
pub fn FrameType::parse(
  bs : @bitstream.Bitstream,
) -> FrameType raise @bitstream.JxlError {
  match bs.read_bits(2) {
    0 => RegularFrame
    1 => LfFrame
    2 => ReferenceOnly
    _ => SkipProgressive
  }
}

///|
pub fn FrameType::is_normal_frame(self : FrameType) -> Bool {
  self is (RegularFrame | SkipProgressive)
}

///|
pub fn FrameType::is_progressive_frame(self : FrameType) -> Bool {
  self is (RegularFrame | LfFrame)
}

///|
#derive(Eq, Debug)
pub(all) enum Encoding {
  VarDct
  Modular
}

///|
pub fn Encoding::default() -> Encoding {
  VarDct
}

///|
pub fn Encoding::parse(
  bs : @bitstream.Bitstream,
) -> Encoding raise @bitstream.JxlError {
  if bs.read_bits(1) == 0 {
    VarDct
  } else {
    Modular
  }
}

///|
#derive(Eq, Debug)
pub(all) struct FrameFlags(UInt64)

///|
let flag_noise : UInt64 = 0x1

///|
let flag_patches : UInt64 = 0x2

///|
let flag_splines : UInt64 = 0x10

///|
let flag_use_lf_frame : UInt64 = 0x20

///|
let flag_skip_adaptive_lf_smoothing : UInt64 = 0x80

///|
pub fn FrameFlags::noise(self : FrameFlags) -> Bool {
  (self.0 & flag_noise) != 0
}

///|
pub fn FrameFlags::patches(self : FrameFlags) -> Bool {
  (self.0 & flag_patches) != 0
}

///|
pub fn FrameFlags::splines(self : FrameFlags) -> Bool {
  (self.0 & flag_splines) != 0
}

///|
pub fn FrameFlags::use_lf_frame(self : FrameFlags) -> Bool {
  (self.0 & flag_use_lf_frame) != 0
}

///|
pub fn FrameFlags::skip_adaptive_lf_smoothing(self : FrameFlags) -> Bool {
  (self.0 & flag_skip_adaptive_lf_smoothing) != 0
}

///|
pub fn FrameFlags::parse(
  bs : @bitstream.Bitstream,
) -> FrameFlags raise @bitstream.JxlError {
  FrameFlags(bs.read_u64())
}

///|
#derive(Eq, Debug)
pub(all) enum BlendMode {
  Replace
  Add
  Blend
  MulAdd
  Mul
}

///|
pub fn BlendMode::default() -> BlendMode {
  Replace
}

///|
pub fn BlendMode::parse(
  bs : @bitstream.Bitstream,
) -> BlendMode raise @bitstream.JxlError {
  match
    bs.read_u32(
      @bitstream.c(0),
      @bitstream.c(1),
      @bitstream.c(2),
      @bitstream.cu(3, 2),
    ) {
    0 => Replace
    1 => Add
    2 => Blend
    3 => MulAdd
    4 => Mul
    value => raise InvalidEnum("BlendMode", value)
  }
}

///|
pub fn BlendMode::use_alpha(self : BlendMode) -> Bool {
  self is (Blend | MulAdd)
}

///|
fn is_aabb_collides(
  rect0 : (Int32, Int32, Int32, Int32),
  rect1 : (Int32, Int32, Int32, Int32),
) -> Bool {
  let (x0, y0, w0, h0) = rect0
  let (x1, y1, w1, h1) = rect1
  // u32 arithmetic in upstream.
  let x0 = x0.reinterpret_as_uint()
  let y0 = y0.reinterpret_as_uint()
  let w0 = w0.reinterpret_as_uint()
  let h0 = h0.reinterpret_as_uint()
  let x1 = x1.reinterpret_as_uint()
  let y1 = y1.reinterpret_as_uint()
  let w1 = w1.reinterpret_as_uint()
  let h1 = h1.reinterpret_as_uint()
  x0 < x1 + w1 && x0 + w0 > x1 && y0 < y1 + h1 && y0 + h0 > y1
}