// Port of jxl-color/src/icc/decode.rs (`decode_icc` part; `read_icc` lives in
// icc_read.mbt since it needs the entropy decoder).

///|
/// `std::io::Cursor` over a byte slice.
priv struct Cursor {
  data : BytesView
  mut pos : Int32
}

///|
fn Cursor::new(data : BytesView) -> Cursor {
  { data, pos: 0, }
}

///|
/// `read_exact` of one byte.
fn Cursor::read_byte(self : Cursor) -> Byte? {
  if self.pos >= self.data.length() {
    None
  } else {
    let b = self.data[self.pos]
    self.pos += 1
    Some(b)
  }
}

///|
fn varint(stream : Cursor) -> UInt64 raise @bitstream.JxlError {
  let mut value = 0UL
  let mut shift = 0
  while shift < 63 {
    guard stream.read_byte() is Some(b) else {
      raise invalid_icc_stream("stream is too short")
    }
    value = value | ((b & 0x7f).to_uint64() << shift)
    if (b & 0x80) == 0 {
      break
    }
    shift += 7
  }
  value
}

///|
fn predict_header(
  idx : Int32,
  output_size : UInt32,
  header : BytesView,
) -> Byte {
  match idx {
    0..<=3 => (output_size >> (8 * (3 - idx))).to_byte()
    8 => 4
    12..<=23 => b"mntrRGB XYZ "[idx - 12]
    36..<=39 => b"acsp"[idx - 36]
    // APPL
    41 | 42 if header[40] == b'A' => b'P'
    43 if header[40] == b'A' => b'L'
    // MSFT
    41 if header[40] == b'M' => b'S'
    42 if header[40] == b'M' => b'F'
    43 if header[40] == b'M' => b'T'
    // SGI_
    42 if header[40] == b'S' && header[41] == b'G' => b'I'
    43 if header[40] == b'S' && header[41] == b'G' => b' '
    // SUNW
    42 if header[40] == b'S' && header[41] == b'U' => b'N'
    43 if header[40] == b'S' && header[41] == b'U' => b'W'
    70 => 246
    71 => 214
    73 => 1
    78 => 211
    79 => 45
    80..<=83 => header[4 + idx - 80]
    _ => 0
  }
}

///|
fn shuffle2(bytes : BytesView) -> Array[Byte] {
  let len = bytes.length()
  let out = Array(capacity=len)
  let height = len / 2
  let odd = len % 2
  for idx in 0.. Array[Byte] {
  let len = bytes.length()
  let out = Array(capacity=len)
  let step = len / 4
  let wide_count = len % 4
  for idx in 0.. Unit {
  out.push((v >> 24).to_byte())
  out.push((v >> 16).to_byte())
  out.push((v >> 8).to_byte())
  out.push(v.to_byte())
}

///|
let common_tags : FixedArray[Bytes] = [
  b"rTRC", b"rXYZ", b"cprt", b"wtpt", b"bkpt", b"rXYZ", b"gXYZ", b"bXYZ", b"kXYZ",
  b"rTRC", b"gTRC", b"bTRC", b"kTRC", b"chad", b"desc", b"chrm", b"dmnd", b"dmdd",
  b"lumi",
]

///|
let common_data : FixedArray[Bytes] = [
  b"XYZ ", b"desc", b"text", b"mluc", b"para", b"curv", b"sf32", b"gbd ",
]

///|
/// Decodes the given ICC profile stream.
pub fn decode_icc(stream : Bytes) -> Bytes raise @bitstream.JxlError {
  let tmp_cursor = Cursor::new(stream[:])
  let output_size = varint(tmp_cursor)
  let commands_size = varint(tmp_cursor)
  let stream_offset = tmp_cursor.pos.to_uint64()
  // Rust: `stream_offset + commands_size > stream.len()` (no overflow for sane sizes)
  if commands_size > stream.length().to_uint64() ||
    stream_offset + commands_size > stream.length().to_uint64() {
    raise invalid_icc_stream("invalid commands_size")
  }
  if output_size > 1UL << 28 {
    raise @bitstream.ProfileConformance("ICC output_size too large")
  }
  let stream_offset = stream_offset.to_int()
  let commands_size = commands_size.to_int()
  let commands = stream[stream_offset:stream_offset + commands_size]
  let data = stream[stream_offset + commands_size:]
  let header_size = (if output_size < 128UL { output_size } else { 128UL }).to_int()
  if data.length() < header_size {
    raise invalid_icc_stream("invalid output_size")
  }
  let header_data = data[:header_size]
  let mut data = data[header_size:]
  let commands_stream = Cursor::new(commands)
  let out : Array[Byte] = Array(capacity=output_size.to_int())

  // Header
  for idx in 0.. break
        1 => {
          if data.length() < 4 {
            raise invalid_icc_stream("unexpected end of data stream")
          }
          let tag = data[:4]
          data = data[4:]
          tag
        }
        2..<=20 => common_tags[(tagcode - 2).to_int()][:]
        _ => raise invalid_icc_stream("invalid tagcode")
      }
      let tagstart = if (command & 64) == 0 {
        prev_tagstart + prev_tagsize
      } else {
        varint(commands_stream).to_uint()
      }
      let tagsize = if (command & 128) != 0 {
        varint(commands_stream).to_uint()
      } else if tag == b"rXYZ" ||
        tag == b"gXYZ" ||
        tag == b"bXYZ" ||
        tag == b"kXYZ" ||
        tag == b"wtpt" ||
        tag == b"bkpt" ||
        tag == b"lumi" {
        20
      } else {
        prev_tagsize
      }
      if tagstart.to_uint64() + tagsize.to_uint64() > output_size {
        raise invalid_icc_stream("ICC profile size mismatch")
      }
      prev_tagstart = tagstart
      prev_tagsize = tagsize
      out.push_iter(tag.iter())
      push_be32_u(out, tagstart)
      push_be32_u(out, tagsize)
      if tagcode == 2 {
        out.push_iter(b"gTRC".iter())
        push_be32_u(out, tagstart)
        push_be32_u(out, tagsize)
        out.push_iter(b"bTRC".iter())
        push_be32_u(out, tagstart)
        push_be32_u(out, tagsize)
      } else if tagcode == 3 {
        out.push_iter(b"gXYZ".iter())
        push_be32_u(out, tagstart + tagsize)
        push_be32_u(out, tagsize)
        out.push_iter(b"bXYZ".iter())
        push_be32_u(out, tagstart + tagsize * 2)
        push_be32_u(out, tagsize)
      }
    }
  }

  // Main
  while commands_stream.read_byte() is Some(command) {
    match command {
      1 => {
        let num = varint_usize(commands_stream)
        if num > data.length().to_uint64() {
          raise invalid_icc_stream("stream is too short")
        }
        let num = num.to_int()
        out.push_iter(data[:num].iter())
        data = data[num:]
      }
      2 | 3 => {
        let num = varint_usize(commands_stream)
        if num > data.length().to_uint64() {
          raise invalid_icc_stream("stream is too short")
        }
        let num = num.to_int()
        let bytes = data[:num]
        data = data[num:]
        let bytes = if command == 2 { shuffle2(bytes) } else { shuffle4(bytes) }
        out.push_iter(bytes.iter())
      }
      4 => {
        guard commands_stream.read_byte() is Some(flags) else {
          raise invalid_icc_stream("stream is too short")
        }
        let width = (flags & 3).to_int() + 1
        let order = ((flags >> 2) & 3).to_int()
        if width == 3 || order == 3 {
          raise invalid_icc_stream("width == 3 || order == 3")
        }
        let stride = if (flags & 16) == 0 {
          width.to_uint64()
        } else {
          let stride = varint_usize(commands_stream)
          if stride < width.to_uint64() {
            raise invalid_icc_stream("stride < width")
          }
          stride
        }
        // Rust: `stride.saturating_mul(4) >= out.len()`
        if stride >= 1UL << 60 || stride * 4 >= out.length().to_uint64() {
          raise invalid_icc_stream("stride * 4 >= out.len()")
        }
        let stride = stride.to_int()
        let num = varint_usize(commands_stream)
        if data.length().to_uint64() < num {
          raise invalid_icc_stream("stream is too short")
        }
        let num = num.to_int()
        let raw = data[:num]
        data = data[num:]
        let bytes : ArrayView[Byte] = match width {
          1 => raw.iter().collect()[:]
          2 => shuffle2(raw)[:]
          4 => shuffle4(raw)[:]
          _ => abort("unreachable")
        }
        let mut i = 0
        while i < num {
          let prev : FixedArray[UInt32] = [0, 0, 0]
          for j in 0..<=order {
            let offset = out.length() - stride * (j + 1)
            let mut v : UInt32 = 0
            for k in 0.. prev[0]
            1 => 2U * prev[0] - prev[1]
            2 => 3U * (prev[0] - prev[1]) + prev[2]
            _ => abort("unreachable")
          }
          let n = if width < num - i { width } else { num - i }
          for j in 0..> (8 * (width - 1 - j)))
            out.push(val.to_byte())
          }
          i += width
        }
      }
      10 => {
        if data.length() < 12 {
          raise invalid_icc_stream("stream is too short")
        }
        out.push_iter(b"XYZ \x00\x00\x00\x00".iter())
        out.push_iter(data[:12].iter())
        data = data[12:]
      }
      16..<=23 => {
        out.push_iter(common_data[command.to_int() - 16].iter())
        out.push_iter(b"\x00\x00\x00\x00".iter())
      }
      _ => raise invalid_icc_stream("invalid command")
    }
  }
  if out.length().to_uint64() != output_size {
    raise invalid_icc_stream("decoded ICC profile size mismatch")
  }
  Bytes::from_array(out)
}

///|
/// `varint(..) as usize`.
fn varint_usize(stream : Cursor) -> UInt64 raise @bitstream.JxlError {
  varint(stream)
}