///|
/// Index value meaning "no frame" (`usize::MAX` upstream).
const NO_FRAME : Int32 = -1

///|
/// Frame with its index in the image (jxl-render `IndexedFrame`).
///
/// Upstream derefs to `Frame`; here the frame is the field `f` and the
/// commonly used `Frame` methods are forwarded.
pub struct IndexedFrame {
  f : @frame.Frame
  idx : Int32
}

///|
fn IndexedFrame::new(frame : @frame.Frame, index : Int32) -> IndexedFrame {
  { f: frame, idx: index, }
}

///|
/// Returns the frame index.
pub fn IndexedFrame::index(self : IndexedFrame) -> Int32 {
  self.idx
}

///|
/// Returns the underlying frame (upstream `Deref`).
pub fn IndexedFrame::frame(self : IndexedFrame) -> @frame.Frame {
  self.f
}

///|
pub fn IndexedFrame::header(self : IndexedFrame) -> @frame.FrameHeader {
  self.f.header()
}

///|
pub fn IndexedFrame::image_header(self : IndexedFrame) -> @image.ImageHeader {
  self.f.image_header()
}

///|
pub fn IndexedFrame::alloc_tracker(self : IndexedFrame) -> @grid.AllocTracker? {
  self.f.alloc_tracker()
}

///|
pub fn IndexedFrame::is_loading_done(self : IndexedFrame) -> Bool {
  self.f.is_loading_done()
}

///|
pub fn IndexedFrame::feed_bytes(
  self : IndexedFrame,
  buf : BytesView,
) -> BytesView raise @bitstream.JxlError {
  self.f.feed_bytes(buf)
}

///|
pub fn IndexedFrame::pass_shifts(
  self : IndexedFrame,
) -> @sorted_map.SortedMap[Int32, (Int32, Int32)] {
  self.f.pass_shifts()
}

///|
pub fn IndexedFrame::try_parse_lf_global(
  self : IndexedFrame,
) -> @frame.LfGlobal? raise @bitstream.JxlError {
  unwrap_opt_result(self.f.try_parse_lf_global())
}

///|
pub fn IndexedFrame::try_parse_lf_group(
  self : IndexedFrame,
  lf_global_vardct : @frame.LfGlobalVarDct?,
  global_ma_config : @modular.MaConfig?,
  mlf_group : @modular.TransformedModularSubimage?,
  lf_group_idx : Int32,
) -> @frame.LfGroup? raise @bitstream.JxlError {
  unwrap_opt_result(
    self.f.try_parse_lf_group(
      lf_global_vardct, global_ma_config, mlf_group, lf_group_idx,
    ),
  )
}

///|
/// `Option>` → `T? raise`.
fn[T] unwrap_opt_result(
  r : Result[T, @bitstream.JxlError]?,
) -> T? raise @bitstream.JxlError {
  match r {
    None => None
    Some(Ok(v)) => Some(v)
    Some(Err(e)) => raise e
  }
}

///|
pub fn IndexedFrame::try_parse_hf_global(
  self : IndexedFrame,
  cached_lf_global : @frame.LfGlobal?,
) -> @frame.HfGlobal? raise @bitstream.JxlError {
  unwrap_opt_result(self.f.try_parse_hf_global(cached_lf_global))
}

///|
pub fn IndexedFrame::pass_group_bitstream(
  self : IndexedFrame,
  pass_idx : Int32,
  group_idx : Int32,
) -> @frame.PassGroupBitstream? raise @bitstream.JxlError {
  unwrap_opt_result(self.f.pass_group_bitstream(pass_idx, group_idx))
}

///|
struct FrameDependence {
  lf : Int32
  ref_slots : FixedArray[Int32]
}

///|
/// LF frame and reference frames a frame depends on.
pub struct ReferenceFrames {
  lf : Reference?
  refs : FixedArray[Reference?]
}

///|
pub struct Reference {
  frame : IndexedFrame
  image : FrameRenderHandle
}

///|
/// Render context that tracks loaded and rendered frames.
pub struct RenderContext {
  image_header : @image.ImageHeader
  tracker : @grid.AllocTracker?
  frames : Array[IndexedFrame]
  renders_wide : Array[FrameRenderHandle]
  keyframes : Array[Int32]
  mut keyframe_in_progress : Int32?
  refcounts : Array[Int32]
  frame_deps : Array[FrameDependence]
  lf_frame : FixedArray[Int32]
  reference : FixedArray[Int32]
  mut loading_frame : IndexedFrame?
  mut loading_render_cache_wide : RenderCache?
  mut loading_region : Region?
  mut requested_image_region : Region
  embedded_icc : Bytes
  mut requested_color_encoding : @color.ColorEncodingWithProfile
  mut cms : &@color.ColorManagementSystem
  mut cached_transform : @color.ColorTransform?
  force_wide_buffers : Bool
}

///|
pub fn RenderContext::builder() -> RenderContextBuilder {
  RenderContextBuilder::default()
}

///|
pub struct RenderContextBuilder {
  mut embedded_icc : Bytes
  mut tracker : @grid.AllocTracker?
  mut force_wide_buffers : Bool
}

///|
pub fn RenderContextBuilder::default() -> RenderContextBuilder {
  { embedded_icc: b"", tracker: None, force_wide_buffers: false, }
}

///|
pub fn RenderContextBuilder::embedded_icc(
  self : RenderContextBuilder,
  icc : Bytes,
) -> RenderContextBuilder {
  self.embedded_icc = icc
  self
}

///|
pub fn RenderContextBuilder::alloc_tracker(
  self : RenderContextBuilder,
  tracker : @grid.AllocTracker,
) -> RenderContextBuilder {
  self.tracker = Some(tracker)
  self
}

///|
/// Kept for API parity; buffers are always wide (32-bit) in this port.
pub fn RenderContextBuilder::force_wide_buffers(
  self : RenderContextBuilder,
  force_wide_buffers : Bool,
) -> RenderContextBuilder {
  self.force_wide_buffers = force_wide_buffers
  self
}

///|
pub fn RenderContextBuilder::build(
  self : RenderContextBuilder,
  image_header : @image.ImageHeader,
) -> RenderContext raise @bitstream.JxlError {
  let requested_color_encoding = match image_header.metadata.colour_encoding {
    Enum(encoding) => @color.ColorEncodingWithProfile::new(encoding)
    IccProfile(color_space) => {
      let header_is_gray = color_space is Grey
      let parsed_icc = try
        @color.ColorEncodingWithProfile::with_icc(self.embedded_icc)
      catch {
        _ => None // Malformed embedded ICC profile
      } noraise {
        parsed_icc => {
          let icc_is_gray = parsed_icc.is_grayscale()
          if header_is_gray != icc_is_gray {
            raise @bitstream.ValidationFailed(
              "Color channel mismatch between header and ICC profile",
            )
          }
          let is_supported_icc = parsed_icc.icc_profile().length() == 0
          let allow_parsed_icc = !image_header.metadata.xyb_encoded ||
            is_supported_icc
          if allow_parsed_icc {
            Some(parsed_icc)
          } else {
            None
          }
        }
      }
      match parsed_icc {
        Some(profile) => profile
        None =>
          if header_is_gray {
            @color.ColorEncodingWithProfile::new(
              @color.EnumColourEncoding::gray_srgb(
                @color.RenderingIntent::Relative,
              ),
            )
          } else {
            @color.ColorEncodingWithProfile::new(
              @color.EnumColourEncoding::srgb(@color.RenderingIntent::Relative),
            )
          }
      }
    }
  }
  let full_image_region = Region::with_size(
    image_header.width_with_orientation(),
    image_header.height_with_orientation(),
  )
  {
    image_header,
    tracker: self.tracker,
    frames: [],
    renders_wide: [],
    keyframes: [],
    keyframe_in_progress: None,
    refcounts: [],
    frame_deps: [],
    lf_frame: FixedArray::make(4, NO_FRAME),
    reference: FixedArray::make(4, NO_FRAME),
    loading_frame: None,
    loading_render_cache_wide: None,
    loading_region: None,
    requested_image_region: full_image_region,
    embedded_icc: self.embedded_icc,
    requested_color_encoding,
    cms: (@color.NullCms::{ } : &@color.ColorManagementSystem),
    cached_transform: None,
    force_wide_buffers: self.force_wide_buffers,
  }
}

///|
pub fn RenderContext::alloc_tracker(
  self : RenderContext,
) -> @grid.AllocTracker? {
  self.tracker
}

///|
pub fn RenderContext::set_cms(
  self : RenderContext,
  cms : &@color.ColorManagementSystem,
) -> Unit {
  self.cached_transform = None
  self.cms = cms
}

///|
pub fn RenderContext::suggested_hdr_tf(
  self : RenderContext,
) -> @color.TransferFunction? {
  let tf = match self.image_header.metadata.colour_encoding {
    Enum(e) => e.tf
    IccProfile(_) => {
      let icc = self.embedded_icc().unwrap()
      match @color.icc_tf(icc) {
        Some(tf) => tf
        None => return None
      }
    }
  }
  match tf {
    Pq | Hlg => Some(tf)
    _ => None
  }
}

///|
pub fn RenderContext::request_color_encoding(
  self : RenderContext,
  encoding : @color.ColorEncodingWithProfile,
) -> Unit {
  self.cached_transform = None
  self.requested_color_encoding = encoding
}

///|
pub fn RenderContext::requested_color_encoding(
  self : RenderContext,
) -> @color.ColorEncodingWithProfile {
  self.requested_color_encoding
}

///|
pub fn RenderContext::request_image_region(
  self : RenderContext,
  image_region : Region,
) -> Unit {
  self.requested_image_region = image_region
  self.reset_cache()
}

///|
pub fn RenderContext::image_region(self : RenderContext) -> Region {
  self.requested_image_region
}

///|
/// Returns the image width.
pub fn RenderContext::width(self : RenderContext) -> Int32 {
  self.image_header.size.width
}

///|
/// Returns the image height.
pub fn RenderContext::height(self : RenderContext) -> Int32 {
  self.image_header.size.height
}

///|
pub fn RenderContext::embedded_icc(self : RenderContext) -> Bytes? {
  if self.embedded_icc.length() == 0 {
    None
  } else {
    Some(self.embedded_icc)
  }
}

///|
/// Returns the number of loaded keyframes in the context.
pub fn RenderContext::loaded_keyframes(self : RenderContext) -> Int32 {
  self.keyframes.length()
}

///|
/// Returns the number of loaded frames in the context, including frames that
/// are not shown directly.
pub fn RenderContext::loaded_frames(self : RenderContext) -> Int32 {
  self.frames.length()
}

///|
fn RenderContext::reference_frames(
  self : RenderContext,
  lf : Int32,
  ref_slots : FixedArray[Int32],
) -> ReferenceFrames {
  {
    lf: if lf != NO_FRAME {
      Some({ frame: self.frames[lf], image: self.renders_wide[lf], })
    } else {
      None
    },
    refs: FixedArray::makei(4, i => {
      let r = ref_slots[i]
      if r != NO_FRAME {
        Some({ frame: self.frames[r], image: self.renders_wide[r], })
      } else {
        None
      }
    }),
  }
}

///|
fn RenderContext::preserve_current_frame(self : RenderContext) -> Unit {
  guard self.loading_frame is Some(frame) else { return }
  self.loading_frame = None
  let header = frame.header()
  let idx = self.frames.length()
  self.refcounts.push(0)
  let lf = if header.flags.use_lf_frame() {
    let lf = self.lf_frame[header.lf_level]
    self.refcounts[lf] += 1
    lf
  } else {
    NO_FRAME
  }
  for ref_idx in self.reference {
    if ref_idx != NO_FRAME {
      self.refcounts[ref_idx] += 1
    }
  }
  let deps : FrameDependence = { lf, ref_slots: self.reference.copy(), }
  if header.can_reference() {
    let ref_idx = header.save_as_reference
    self.reference[ref_idx] = idx
  }
  if header.lf_level != 0 {
    let lf_idx = header.lf_level - 1
    self.lf_frame[lf_idx] = idx
  }
  if header.is_keyframe() {
    self.refcounts[idx] += 1
    self.keyframes.push(idx)
    self.keyframe_in_progress = None
  } else if header.frame_type.is_normal_frame() {
    self.keyframe_in_progress = Some(idx)
  }
  let image_region = self.requested_image_region
  let reference_frames = self.reference_frames(deps.lf, deps.ref_slots)
  let refs = reference_frames.refs
  let render_op = self.render_op(frame, reference_frames)
  let handle = match self.loading_render_cache_wide {
    Some(cache) => {
      self.loading_render_cache_wide = None
      FrameRenderHandle::from_cache(frame, image_region, cache, render_op, refs)
    }
    None => FrameRenderHandle::new(frame, image_region, render_op, refs)
  }
  self.renders_wide.push(handle)
  self.frames.push(frame)
  self.frame_deps.push(deps)
}

///|
fn RenderContext::loading_frame_(self : RenderContext) -> IndexedFrame? {
  let search_from = match self.keyframe_in_progress {
    Some(x) => x
    None =>
      match self.keyframes.last() {
        Some(x) => x + 1
        None => 0
      }
  }
  if self.loading_frame is Some(f) &&
    f.header().frame_type.is_progressive_frame() {
    return Some(f)
  }
  let mut i = self.frames.length() - 1
  while i >= search_from {
    let f = self.frames[i]
    if f.header().frame_type.is_progressive_frame() {
      return Some(f)
    }
    i -= 1
  }
  None
}

///|
/// Loads a frame header from `bitstream` and starts loading the frame.
///
/// On error the bitstream position is unchanged.
pub fn RenderContext::load_frame_header(
  self : RenderContext,
  bitstream : @bitstream.Bitstream,
) -> IndexedFrame raise @bitstream.JxlError {
  if self.loading_frame is Some(_) && !self.try_finalize_current_frame() {
    abort("another frame is still loading")
  }
  // Parse from a copy so that `bitstream` is untouched on error.
  let bs = bitstream.clone()
  let frame = @frame.Frame::parse(bs, self.image_header, tracker=self.tracker)
  bitstream.skip_bits(bs.num_read_bits() - bitstream.num_read_bits())
  let header = frame.header()
  // Check if LF frame exists
  if header.flags.use_lf_frame() && self.lf_frame[header.lf_level] == NO_FRAME {
    raise uninitialized_lf_frame(header.lf_level)
  }
  let f = IndexedFrame::new(frame, self.frames.length())
  self.loading_frame = Some(f)
  f
}

///|
pub fn RenderContext::current_loading_frame(
  self : RenderContext,
) -> IndexedFrame? {
  ignore(self.try_finalize_current_frame())
  self.loading_frame
}

///|
pub fn RenderContext::finalize_current_frame(self : RenderContext) -> Unit {
  if !self.try_finalize_current_frame() {
    abort("frame is not fully loaded")
  }
}

///|
fn RenderContext::try_finalize_current_frame(self : RenderContext) -> Bool {
  if self.loading_frame is Some(loading_frame) &&
    loading_frame.is_loading_done() {
    self.preserve_current_frame()
    return true
  }
  false
}

///|
/// Returns the frame with the keyframe index, or `None` if the keyframe does
/// not exist.
pub fn RenderContext::keyframe(
  self : RenderContext,
  keyframe_idx : Int32,
) -> IndexedFrame? {
  if keyframe_idx == self.keyframes.length() {
    self.loading_frame_()
  } else if keyframe_idx >= 0 && keyframe_idx < self.keyframes.length() {
    Some(self.frames[self.keyframes[keyframe_idx]])
  } else {
    None
  }
}

///|
pub fn RenderContext::frame(
  self : RenderContext,
  frame_idx : Int32,
) -> IndexedFrame? {
  if self.frames.length() == frame_idx {
    self.loading_frame
  } else if frame_idx >= 0 && frame_idx < self.frames.length() {
    Some(self.frames[frame_idx])
  } else {
    None
  }
}

///|
fn do_render(
  frame : IndexedFrame,
  reference_frames : ReferenceFrames,
  state : FrameRender,
  image_region : Region,
  prev_frame_visibility : (Int32, Int32),
) -> FrameRender {
  // Upstream spawns these on the thread pool; without threads the pool runs
  // them immediately.
  if reference_frames.lf is Some(lf) {
    lf.image.run(image_region)
  }
  for grid in reference_frames.refs {
    if grid is Some(grid) {
      grid.image.run(image_region)
    }
  }
  let cache = match state {
    InProgress(cache) => cache
    _ => RenderCache::new(frame)
  }
  try
    render_frame(
      frame, reference_frames, cache, image_region, prev_frame_visibility,
    )
  catch {
    e =>
      if e.unexpected_eof() || is_incomplete_frame(e) {
        if frame.is_loading_done() {
          Failed(e)
        } else {
          InProgress(cache)
        }
      } else {
        Failed(e)
      }
  } noraise {
    grid => Done(grid)
  }
}

///|
fn RenderContext::render_op(
  self : RenderContext,
  frame : IndexedFrame,
  reference_frames : ReferenceFrames,
) -> RenderOp {
  let prev_frame_visibility = self.get_previous_frames_visibility(frame)
  fn(state, image_region) {
    do_render(
      frame, reference_frames, state, image_region, prev_frame_visibility,
    )
  }
}

///|
fn RenderContext::get_previous_frames_visibility(
  self : RenderContext,
  frame : IndexedFrame,
) -> (Int32, Int32) {
  let frame_idx = frame.index()
  let (is_keyframe, keyframe_idx) = match
    self.keyframes.binary_search(frame_idx) {
    Ok(val) => (true, val)
    // Handle partial rendering. If val != self.keyframes.len(), is_keyframe()
    // should be false, since if not the index should exist in self.keyframes.
    Err(val) => (frame.header().is_keyframe(), val)
  }
  let visible_frames_num = keyframe_idx + (if is_keyframe { 1 } else { 0 })
  let invisible_frames_num = if is_keyframe {
    0
  } else if keyframe_idx == 0 {
    1 + frame_idx
  } else {
    let last_visible_frame = self.keyframes[keyframe_idx - 1]
    frame_idx - last_visible_frame
  }
  (visible_frames_num, invisible_frames_num)
}

///|
fn RenderContext::render_by_index(
  self : RenderContext,
  index : Int32,
) -> ImageWithRegion raise @bitstream.JxlError {
  self.renders_wide[index].run_with_image().blend(None)
}

///|
/// Renders the first keyframe.
///
/// The keyframe should be loaded in prior to rendering, with one of the
/// loading methods.
pub fn RenderContext::render(
  self : RenderContext,
) -> ImageWithRegion raise @bitstream.JxlError {
  self.render_keyframe(0)
}

///|
/// Renders the keyframe.
///
/// The keyframe should be loaded in prior to rendering, with one of the
/// loading methods.
pub fn RenderContext::render_keyframe(
  self : RenderContext,
  keyframe_idx : Int32,
) -> ImageWithRegion raise @bitstream.JxlError {
  guard keyframe_idx >= 0 && keyframe_idx < self.keyframes.length() else {
    raise incomplete_frame()
  }
  let idx = self.keyframes[keyframe_idx]
  let grid = self.render_by_index(idx)
  let frame = self.frames[idx]
  self.postprocess_keyframe(frame, grid)
}

///|
/// Renders the keyframe currently being loaded, or the last keyframe in
/// progress.
pub fn RenderContext::render_loading_keyframe(
  self : RenderContext,
) -> (IndexedFrame, ImageWithRegion) raise @bitstream.JxlError {
  let mut current_frame_grid = None
  if self.loading_frame_() is Some(_) {
    try self.render_loading_frame() catch {
      e => if !is_incomplete_frame(e) { raise e }
    } noraise {
      grid => current_frame_grid = Some(grid)
    }
  }
  let (frame, grid) = match current_frame_grid {
    Some(grid) => (self.loading_frame_().unwrap(), grid)
    None =>
      match self.keyframe_in_progress {
        Some(idx) => {
          let grid = self.render_by_index(idx)
          (self.frames[idx], grid)
        }
        None => raise incomplete_frame()
      }
  }
  let grid = self.postprocess_keyframe(frame, grid)
  (frame, grid)
}

///|
pub fn RenderContext::reset_cache(self : RenderContext) -> Unit {
  let image_region = self.requested_image_region
  self.loading_region = None
  self.loading_render_cache_wide = None
  for idx, frame in self.frames {
    if frame.header().frame_type is ReferenceOnly {
      continue
    }
    let deps = self.frame_deps[idx]
    let reference_frames = self.reference_frames(deps.lf, deps.ref_slots)
    let refs = reference_frames.refs
    let render_op = self.render_op(frame, reference_frames)
    self.renders_wide[idx] = FrameRenderHandle::new(
      frame, image_region, render_op, refs,
    )
  }
}

///|
fn RenderContext::render_loading_frame(
  self : RenderContext,
) -> ImageWithRegion raise @bitstream.JxlError {
  let frame = self.loading_frame_().unwrap()
  if !frame.header().frame_type.is_progressive_frame() {
    raise incomplete_frame()
  }
  let image_region = self.requested_image_region
  let frame_region = image_region_to_frame(frame, image_region, false)
  self.loading_region = Some(frame_region)
  let header = frame.header()
  let lf_global_failed = try frame.try_parse_lf_global() catch {
    _ => true
  } noraise {
    lf_global => lf_global is None
  }
  if lf_global_failed {
    raise incomplete_frame()
  }
  let lf_frame_idx = self.lf_frame[header.lf_level]
  // spawn_renderer is a no-op without a thread pool.
  let state = match self.loading_render_cache_wide {
    Some(cache) => {
      self.loading_render_cache_wide = None
      InProgress(cache)
    }
    None => Empty
  }
  let reference_frames = self.reference_frames(lf_frame_idx, self.reference)
  let prev_frame_visibility = self.get_previous_frames_visibility(frame)
  let state = do_render(
    frame, reference_frames, state, image_region, prev_frame_visibility,
  )
  let image = match state {
    InProgress(cache) => {
      self.loading_render_cache_wide = Some(cache)
      raise incomplete_frame()
    }
    Failed(e) => raise e
    Done(image) => {
      let skip_composition = composite_preprocess(frame, image)
      if !skip_composition {
        let oriented_image_region = apply_orientation_to_image_region(
          self.image_header,
          image_region,
        )
        composite(frame, image, reference_frames.refs, oriented_image_region)
      } else {
        image
      }
    }
    _ => abort("todo")
  }
  if frame.header().lf_level > 0 {
    let render = image.upsample_lf(frame.header().lf_level)
    render.fill_opaque_alpha(self.image_header.metadata.ec_info)
    render
  } else {
    image
  }
}

///|
fn RenderContext::cache_color_transform(
  self : RenderContext,
) -> Unit raise @bitstream.JxlError {
  if self.cached_transform is Some(_) {
    return
  }
  let metadata = self.image_header.metadata
  let frame_color_encoding = if metadata.xyb_encoded {
    @color.ColorEncodingWithProfile::new(
      @color.EnumColourEncoding::xyb(@color.RenderingIntent::Perceptual),
    )
  } else {
    match metadata.colour_encoding {
      Enum(encoding) => @color.ColorEncodingWithProfile::new(encoding)
      _ => @color.ColorEncodingWithProfile::with_icc(self.embedded_icc)
    }
  }
  let transform = @color.ColorTransform::builder()
    .set_srgb_icc(!self.cms.supports_linear_tf())
    .from_pq(self.suggested_hdr_tf() is Some(Pq))
    .build(
      frame_color_encoding,
      self.requested_color_encoding,
      metadata.opsin_inverse_matrix,
      metadata.tone_mapping,
      self.cms,
    )
  self.cached_transform = Some(transform)
}

///|
fn RenderContext::postprocess_keyframe(
  self : RenderContext,
  frame : IndexedFrame,
  grid : ImageWithRegion,
) -> ImageWithRegion raise @bitstream.JxlError {
  let frame_header = frame.header()
  let metadata = self.image_header.metadata
  // Transform to requested color encoding
  if grid.ct_done() {
    return grid
  }
  self.cache_color_transform()
  let transform = self.cached_transform.unwrap()
  if transform.is_noop() && !frame_header.do_ycbcr {
    return grid
  }
  let grid = grid.try_clone()
  if frame_header.do_ycbcr {
    grid.convert_modular_color(metadata.bit_depth)
    let cby = grid.as_color_floats_mut()
    @color.ycbcr_to_rgb(cby[0].buf(), cby[1].buf(), cby[2].buf())
  }
  if transform.is_noop() {
    let output_channels = transform.output_channels()
    grid.remove_color_channels(output_channels)
    return grid
  }
  let encoded_color_channels = frame_header.encoded_color_channels()
  if encoded_color_channels < 3 {
    grid.clone_gray()
  }
  grid.convert_modular_color(metadata.bit_depth)
  let channels : Array[FixedArray[Float]] = []
  for i in 0..<3 {
    channels.push(grid.buffer[i].float().buf())
  }
  let mut has_black = false
  let num_ec = grid.buffer.length() - 3
  for i in 0..