// Copyright 2026 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT

pri func decoder.do_decode_frame_vp8l?(dst: nptr base.pixel_buffer, src: base.io_reader, blend: base.pixel_blend, workbuf: slice base.u8, opts: nptr base.decode_frame_options) {
    var c8             : base.u8
    var has_more       : base.u32[..= 1]
    var width          : base.u32[..= 0x4000]
    var dst            : slice base.u8
    var tile_data      : roslice base.u8
    var status         : base.status
    var pix            : slice base.u8
    var which          : base.u32[..= 4]
    var transform_type : base.u32[..= 3]
    var ti             : base.u64
    var tj             : base.u64

    this.seen_transform[0] = false
    this.seen_transform[1] = false
    this.seen_transform[2] = false
    this.seen_transform[3] = false
    this.n_transforms = 0

    while true {
        if this.n_bits < 1 {
            c8 = args.src.read_u8?()
            this.bits = (c8 as base.u32)
            this.n_bits = 8
            assert this.n_bits >= 1
        }
        has_more = this.bits & 1
        this.bits >>= 1
        this.n_bits -= 1

        if has_more == 0 {
            break
        }
        this.decode_transform?(src: args.src, workbuf: args.workbuf)
    }

    width = this.width
    if this.seen_transform[3] {
        width = this.color_indexing_width
    }

    this.decode_color_cache_parameters?(src: args.src)
    this.overall_color_cache_bits = this.color_cache_bits
    this.decode_hg_table?(src: args.src, width: width, workbuf: args.workbuf)
    this.color_cache_bits = this.overall_color_cache_bits
    this.decode_huffman_groups?(src: args.src, n_huffman_groups: this.overall_n_huffman_groups)

    while true {
        if ((this.workbuf_offset_for_color_indexing as base.u64) > (this.workbuf_offset_for_transform[0] as base.u64)) or
                ((this.workbuf_offset_for_transform[0] as base.u64) > (this.workbuf_offset_for_transform[1] as base.u64)) or
                ((this.workbuf_offset_for_transform[1] as base.u64) > args.workbuf.length()) {
            return base."#bad workbuf length"
        }
        assert (this.workbuf_offset_for_transform[0] as base.u64) <= args.workbuf.length() via "a <= b: a <= c; c <= b"(c: this.workbuf_offset_for_transform[1] as base.u64)

        dst = args.workbuf[
                (this.workbuf_offset_for_color_indexing as base.u64) ..
                (this.workbuf_offset_for_transform[0] as base.u64)]
        tile_data = args.workbuf[
                (this.workbuf_offset_for_transform[0] as base.u64) ..
                (this.workbuf_offset_for_transform[1] as base.u64)]
        status =? this.decode_pixels?(
                dst: dst,
                src: args.src,
                width: width,
                height: this.height,
                tile_data: tile_data,
                tile_size_log2: this.overall_tile_size_log2)
        if status.is_ok() {
            break
        }
        yield? status
    }

    if (this.workbuf_offset_for_transform[0] as base.u64) > args.workbuf.length() {
        return base."#bad workbuf length"
    }
    pix = args.workbuf[.. (this.workbuf_offset_for_transform[0] as base.u64)]
    width = this.width
    if this.seen_transform[3] and
            ((this.workbuf_offset_for_color_indexing as base.u64) <= pix.length()) {
        pix = pix[this.workbuf_offset_for_color_indexing as base.u64 ..]
        width = this.color_indexing_width
    }

    which = this.n_transforms
    while which > 0 {
        which -= 1
        transform_type = this.transform_type[which] as base.u32

        tile_data = this.util.empty_slice_u8()
        if transform_type < 2 {
            ti = this.workbuf_offset_for_transform[transform_type + 1] as base.u64
            tj = this.workbuf_offset_for_transform[transform_type + 2] as base.u64
            if (ti <= tj) and (tj <= args.workbuf.length()) {
                tile_data = args.workbuf[ti .. tj]
            }
        }

        if transform_type == 0 {
            this.apply_transform_predictor!(pix: pix, width: width, tile_data: tile_data)
        } else if transform_type == 1 {
            this.apply_transform_cross_color!(pix: pix, width: width, tile_data: tile_data)
        } else if transform_type == 2 {
            this.apply_transform_subtract_green!(pix: pix)
        } else if (this.workbuf_offset_for_transform[0] as base.u64) <= args.workbuf.length() {
            pix = args.workbuf[.. (this.workbuf_offset_for_transform[0] as base.u64)]
            width = this.width
            this.apply_transform_color_indexing!(pix: pix, width: width)
        }
    }

    status = this.swizzle!(
            dst: args.dst,
            src: pix,
            blend: args.blend)
    if not status.is_ok() {
        return status
    }

    this.call_sequence = 0x60
}

pri func decoder.decode_transform?(src: base.io_reader, workbuf: slice base.u8) {
    var status         : base.status
    var c8             : base.u8
    var transform_type : base.u32[..= 3]
    var tile_size_log2 : base.u32[..= 9]
    var width          : base.u32[..= 0x4000]
    var p              : slice base.u8

    if this.n_bits < 2 {
        c8 = args.src.read_u8?()
        if this.n_bits >= 2 {
            return "#internal error: inconsistent n_bits"
        }
        this.bits |= (c8 as base.u32) << this.n_bits
        this.n_bits += 8
        assert this.n_bits >= 2
    }
    transform_type = this.bits & 3
    this.bits >>= 2
    this.n_bits -= 2

    if this.seen_transform[transform_type] or (this.n_transforms >= 4) {
        return "#bad transform"
    }
    this.seen_transform[transform_type] = true
    this.transform_type[this.n_transforms] = transform_type as base.u8
    this.n_transforms += 1

    if transform_type < 2 {  // Predictor, Cross Color transform.
        if this.n_bits < 3 {
            c8 = args.src.read_u8?()
            if this.n_bits >= 3 {
                return "#internal error: inconsistent n_bits"
            }
            this.bits |= (c8 as base.u32) << this.n_bits
            this.n_bits += 8
            assert this.n_bits >= 3
        }
        tile_size_log2 = (this.bits & 7) + 2
        this.transform_tile_size_log2[transform_type] = tile_size_log2 as base.u8
        this.bits >>= 3
        this.n_bits -= 3

        this.decode_color_cache_parameters?(src: args.src)
        this.decode_huffman_groups?(src: args.src, n_huffman_groups: 1)

        while true,
                inv transform_type < 2,
                inv tile_size_log2 >= 2,
        {
            width = this.width
            if this.seen_transform[3] {
                width = this.color_indexing_width
            }

            if ((this.workbuf_offset_for_transform[transform_type + 1] as base.u64) > (this.workbuf_offset_for_transform[transform_type + 2] as base.u64)) or
                    ((this.workbuf_offset_for_transform[transform_type + 2] as base.u64) > args.workbuf.length()) {
                return base."#bad workbuf length"
            }
            status =? this.decode_pixels?(
                    dst: args.workbuf[
                    (this.workbuf_offset_for_transform[transform_type + 1] as base.u64) ..
                    (this.workbuf_offset_for_transform[transform_type + 2] as base.u64)],
                    src: args.src,
                    width: (width + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2,
                    height: (this.height + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2,
                    tile_data: this.util.empty_slice_u8(),
                    tile_size_log2: 0)
            if status.is_ok() {
                break
            }
            yield? status
        }

    } else if transform_type == 2 {  // Subtract Green transform.
        // No-op.

    } else {  // Color Indexing transform.
        if this.n_bits < 8 {
            c8 = args.src.read_u8?()
            if this.n_bits >= 8 {
                return "#internal error: inconsistent n_bits"
            }
            this.bits |= (c8 as base.u32) << this.n_bits
            this.n_bits += 8
            assert this.n_bits >= 8
        }
        this.color_indexing_palette_size = (this.bits & 0xFF) + 1
        this.bits >>= 8
        this.n_bits -= 8

        if this.color_indexing_palette_size <= 2 {
            this.color_indexing_width = (this.width + 7) / 8
            this.transform_tile_size_log2[3] = 3
        } else if this.color_indexing_palette_size <= 4 {
            this.color_indexing_width = (this.width + 3) / 4
            this.transform_tile_size_log2[3] = 2
        } else if this.color_indexing_palette_size <= 16 {
            this.color_indexing_width = (this.width + 1) / 2
            this.transform_tile_size_log2[3] = 1
        } else {
            this.color_indexing_width = this.width
            this.transform_tile_size_log2[3] = 0
        }

        if this.width >= this.color_indexing_width {
            this.workbuf_offset_for_color_indexing = 4 * (this.width - this.color_indexing_width) * this.height
        }

        this.decode_color_cache_parameters?(src: args.src)
        this.decode_huffman_groups?(src: args.src, n_huffman_groups: 1)

        this.decode_pixels?(
                dst: this.palette[.. 4 * this.color_indexing_palette_size],
                src: args.src,
                width: this.color_indexing_palette_size,
                height: 1,
                tile_data: this.util.empty_slice_u8(),
                tile_size_log2: 0)
        this.palette[4 * this.color_indexing_palette_size .. 1024].bulk_memset!(byte_value: 0)

        p = this.palette[.. 4 * this.color_indexing_palette_size]
        while p.length() >= 8 {
            p[4] ~mod+= p[0]
            p[5] ~mod+= p[1]
            p[6] ~mod+= p[2]
            p[7] ~mod+= p[3]
            p = p[4 ..]
        }
    }
}

pri func decoder.decode_color_cache_parameters?(src: base.io_reader) {
    var c8               : base.u8
    var use_color_cache  : base.u32[..= 1]
    var color_cache_bits : base.u32[..= 15]

    if this.n_bits < 1 {
        c8 = args.src.read_u8?()
        this.bits = (c8 as base.u32)
        this.n_bits = 8
        assert this.n_bits >= 1
    }
    use_color_cache = this.bits & 1
    this.bits >>= 1
    this.n_bits -= 1

    this.color_cache_bits = 0
    if use_color_cache <> 0 {
        if this.n_bits < 4 {
            c8 = args.src.read_u8?()
            if this.n_bits >= 4 {
                return "#internal error: inconsistent n_bits"
            }
            this.bits |= (c8 as base.u32) << this.n_bits
            this.n_bits += 8
            assert this.n_bits >= 4
        }
        color_cache_bits = this.bits & 15
        this.bits >>= 4
        this.n_bits -= 4

        if (color_cache_bits < 1) or (11 < color_cache_bits) {
            return "#bad color cache"
        }
        this.color_cache_bits = color_cache_bits
    }
}

pri func decoder.decode_hg_table?(src: base.io_reader, width: base.u32[..= 0x4000], workbuf: slice base.u8) {
    var status         : base.status
    var c8             : base.u8
    var use_hg_table   : base.u32[..= 1]
    var tile_size_log2 : base.u32[..= 9]
    var hg_pixels      : slice base.u8
    var n              : base.u64
    var p              : roslice base.u8
    var hg_plus_1      : base.u32[..= 256]

    if this.n_bits < 1 {
        c8 = args.src.read_u8?()
        this.bits = (c8 as base.u32)
        this.n_bits = 8
        assert this.n_bits >= 1
    }
    use_hg_table = this.bits & 1
    this.bits >>= 1
    this.n_bits -= 1

    if use_hg_table == 0 {
        this.overall_n_huffman_groups = 1
        this.overall_tile_size_log2 = 0
        if ((this.workbuf_offset_for_transform[0] as base.u64) > (this.workbuf_offset_for_transform[1] as base.u64)) or
                ((this.workbuf_offset_for_transform[1] as base.u64) > args.workbuf.length()) {
            return base."#bad workbuf length"
        }
        hg_pixels = args.workbuf[
                this.workbuf_offset_for_transform[0] as base.u64 ..
                this.workbuf_offset_for_transform[1] as base.u64]
        if hg_pixels.length() >= 4 {
            hg_pixels[0] = 0x00
            hg_pixels[1] = 0x00
            hg_pixels[2] = 0x00
            hg_pixels[3] = 0x00
        }
        return ok
    }

    if this.n_bits < 3 {
        c8 = args.src.read_u8?()
        if this.n_bits >= 3 {
            return "#internal error: inconsistent n_bits"
        }
        this.bits |= (c8 as base.u32) << this.n_bits
        this.n_bits += 8
        assert this.n_bits >= 3
    }
    tile_size_log2 = (this.bits & 7) + 2
    this.bits >>= 3
    this.n_bits -= 3

    this.overall_tile_size_log2 = tile_size_log2

    this.decode_color_cache_parameters?(src: args.src)
    this.decode_huffman_groups?(src: args.src, n_huffman_groups: 1)
    while true,
            inv tile_size_log2 >= 2,
    {
        if ((this.workbuf_offset_for_transform[0] as base.u64) > (this.workbuf_offset_for_transform[1] as base.u64)) or
                ((this.workbuf_offset_for_transform[1] as base.u64) > args.workbuf.length()) {
            return base."#bad workbuf length"
        }
        status =? this.decode_pixels?(
                dst: args.workbuf[
                (this.workbuf_offset_for_transform[0] as base.u64) ..
                (this.workbuf_offset_for_transform[1] as base.u64)],
                src: args.src,
                width: (args.width + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2,
                height: (this.height + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2,
                tile_data: this.util.empty_slice_u8(),
                tile_size_log2: 0)
        if status.is_ok() {
            break
        }
        yield? status
    }

    this.overall_n_huffman_groups = 1
    if ((this.workbuf_offset_for_transform[0] as base.u64) > (this.workbuf_offset_for_transform[1] as base.u64)) or
            ((this.workbuf_offset_for_transform[1] as base.u64) > args.workbuf.length()) {
        return base."#bad workbuf length"
    }
    hg_pixels = args.workbuf[
            this.workbuf_offset_for_transform[0] as base.u64 ..
            this.workbuf_offset_for_transform[1] as base.u64]
    n = (((args.width + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2) *
            ((this.height + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2) *
            4) as base.u64
    if n > hg_pixels.length() {
        return base."#bad workbuf length"
    }
    p = hg_pixels[.. n]
    while p.length() >= 4 {
        if p[2] <> 0 {
            return "#unsupported number of Huffman groups"
        }
        hg_plus_1 = (p[1] as base.u32) + 1
        if this.overall_n_huffman_groups < hg_plus_1 {
            this.overall_n_huffman_groups = hg_plus_1
        }
        p = p[4 ..]
    }
}

pri func decoder.decode_pixels?(dst: slice base.u8, src: base.io_reader, width: base.u32[..= 0x4000], height: base.u32[..= 0x4000], tile_data: roslice base.u8, tile_size_log2: base.u32[..= 9]) {
    var i : base.u32
    var n : base.u32[..= 2048]

    i = 0
    n = (1 as base.u32) << this.color_cache_bits
    while i < n {
        assert i < 2048 via "a < b: a < c; c <= b"(c: n)
        this.color_cache[i] = 0
        i += 1
    }

    this.decode_pixels_slow?(
            dst: args.dst,
            src: args.src,
            width: args.width,
            height: args.height,
            tile_data: args.tile_data,
            tile_size_log2: args.tile_size_log2)
}

pri func decoder.swizzle!(dst: nptr base.pixel_buffer, src: roslice base.u8, blend: base.pixel_blend) base.status {
    var status              : base.status
    var dst_pixfmt          : base.pixel_format
    var dst_bits_per_pixel  : base.u32[..= 256]
    var dst_bytes_per_pixel : base.u32[..= 32]
    var dst_bytes_per_row   : base.u64
    var dst_palette         : slice base.u8
    var tab                 : table base.u8
    var src_bytes_per_row   : base.u64
    var dst                 : slice base.u8
    var y                   : base.u32

    if args.dst == nullptr {
        return ok
    }

    status = this.swizzler.prepare!(
            dst_pixfmt: args.dst.pixel_format(),
            dst_palette: args.dst.palette_or_else(fallback: this.palette[..]),
            src_pixfmt: this.util.make_pixel_format(repr: base.PIXEL_FORMAT__BGRA_NONPREMUL),
            src_palette: this.util.empty_slice_u8(),
            blend: args.blend)
    if not status.is_ok() {
        return status
    }

    // TODO: the dst_pixfmt variable shouldn't be necessary. We should be able
    // to chain the two calls: "args.dst.pixel_format().bits_per_pixel()".
    dst_pixfmt = args.dst.pixel_format()
    dst_bits_per_pixel = dst_pixfmt.bits_per_pixel()
    if (dst_bits_per_pixel & 7) <> 0 {
        return base."#unsupported option"
    }
    dst_bytes_per_pixel = dst_bits_per_pixel / 8
    dst_bytes_per_row = (this.width * dst_bytes_per_pixel) as base.u64
    dst_palette = args.dst.palette_or_else(fallback: this.palette[..])
    tab = args.dst.plane(p: 0)
    src_bytes_per_row = (this.width * 4) as base.u64

    while src_bytes_per_row <= args.src.length() {
        dst = tab.row_u32(y: y)
        if dst_bytes_per_row < dst.length() {
            dst = dst[.. dst_bytes_per_row]
        }

        this.swizzler.swizzle_interleaved_from_slice!(
                dst: dst,
                dst_palette: dst_palette,
                src: args.src[.. src_bytes_per_row])

        args.src = args.src[src_bytes_per_row ..]
        y ~mod+= 1
    }

    return ok
}