// Copyright 2021 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

pri func decoder.filter_and_swizzle_tricky!(dst: ptr base.pixel_buffer, workbuf: slice base.u8) base.status {
	var dst_pixfmt          : base.pixel_format
	var dst_bits_per_pixel  : base.u32[..= 256]
	var dst_bytes_per_pixel : base.u64[..= 32]
	var dst_bytes_per_row1  : base.u64
	var dst_palette         : slice base.u8
	var tab                 : table base.u8

	var src_bytes_per_pixel : base.u64[..= 8]

	var x        : base.u32
	var y        : base.u32
	var i        : base.u64[..= 0x1FFF_FFC0]
	var dst      : slice base.u8
	var filter   : base.u8
	var s        : slice base.u8
	var curr_row : slice base.u8
	var prev_row : slice base.u8

	var bits_unpacked   : array[8] base.u8
	var bits_packed     : base.u8
	var packs_remaining : base.u8
	var multiplier      : base.u8
	var shift           : base.u8[..= 7]

	// 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) as base.u64
	dst_bytes_per_row1 = (this.frame_rect_x1 as base.u64) * dst_bytes_per_pixel
	dst_palette = args.dst.palette_or_else(fallback: this.dst_palette[..])
	tab = args.dst.plane(p: 0)

	src_bytes_per_pixel = 1
	if this.depth >= 8 {
		src_bytes_per_pixel = (NUM_CHANNELS[this.color_type] as base.u64) *
			((this.depth >> 3) as base.u64)
	}

	if (this.chunk_type_array[0] == 'I') {
		y = INTERLACING[this.interlace_pass][5] as base.u32
	} else {
		y = this.frame_rect_y0
	}
	while y < this.frame_rect_y1 {
		assert y < 0x00FF_FFFF via "a < b: a < c; c <= b"(c: this.frame_rect_y1)
		dst = tab.row_u32(y: y)
		if dst_bytes_per_row1 < dst.length() {
			dst = dst[.. dst_bytes_per_row1]
		}

		if 1 > args.workbuf.length() {
			return "#internal error: inconsistent workbuf length"
		}
		filter = args.workbuf[0]
		args.workbuf = args.workbuf[1 ..]
		if this.pass_bytes_per_row > args.workbuf.length() {
			return "#internal error: inconsistent workbuf length"
		}
		curr_row = args.workbuf[.. this.pass_bytes_per_row]
		args.workbuf = args.workbuf[this.pass_bytes_per_row ..]

		if filter == 0 {
			// No-op.
		} else if filter == 1 {
			this.filter_1!(curr: curr_row)
		} else if filter == 2 {
			this.filter_2!(curr: curr_row, prev: prev_row)
		} else if filter == 3 {
			this.filter_3!(curr: curr_row, prev: prev_row)
		} else if filter == 4 {
			this.filter_4!(curr: curr_row, prev: prev_row)
		} else {
			return "#bad filter"
		}

		s = curr_row
		if (this.chunk_type_array[0] == 'I') {
			x = INTERLACING[this.interlace_pass][2] as base.u32
		} else {
			x = this.frame_rect_x0
		}
		if this.depth == 8 {
			while x < this.frame_rect_x1,
				inv y < 0x00FF_FFFF,
			{
				assert x < 0x00FF_FFFF via "a < b: a < c; c <= b"(c: this.frame_rect_x1)
				i = (x as base.u64) * dst_bytes_per_pixel
				if i <= dst.length() {
					if this.color_type == 4 {
						if 2 <= s.length() {
							bits_unpacked[0] = s[0]
							bits_unpacked[1] = s[0]
							bits_unpacked[2] = s[0]
							bits_unpacked[3] = s[1]
							s = s[2 ..]
							this.swizzler.swizzle_interleaved_from_slice!(
								dst: dst[i ..],
								dst_palette: dst_palette,
								src: bits_unpacked[.. 4])
						}

					} else if ((this.remap_transparency & 0xFFFF_FFFF) as base.u32) <> 0 {
						if this.color_type == 0 {
							if 1 <= s.length() {
								bits_unpacked[0] = s[0]
								bits_unpacked[1] = s[0]
								bits_unpacked[2] = s[0]
								bits_unpacked[3] = 0xFF
								s = s[1 ..]
								if ((this.remap_transparency & 0xFFFF_FFFF) as base.u32) == (
									((bits_unpacked[0] as base.u32) << 0) |
									((bits_unpacked[1] as base.u32) << 8) |
									((bits_unpacked[2] as base.u32) << 16) |
									((bits_unpacked[3] as base.u32) << 24)) {
									bits_unpacked[0] = 0
									bits_unpacked[1] = 0
									bits_unpacked[2] = 0
									bits_unpacked[3] = 0
								}
								this.swizzler.swizzle_interleaved_from_slice!(
									dst: dst[i ..],
									dst_palette: dst_palette,
									src: bits_unpacked[.. 4])
							}
						} else {
							if 3 <= s.length() {
								bits_unpacked[0] = s[2]
								bits_unpacked[1] = s[1]
								bits_unpacked[2] = s[0]
								bits_unpacked[3] = 0xFF
								s = s[3 ..]
								if ((this.remap_transparency & 0xFFFF_FFFF) as base.u32) == (
									((bits_unpacked[0] as base.u32) << 0) |
									((bits_unpacked[1] as base.u32) << 8) |
									((bits_unpacked[2] as base.u32) << 16) |
									((bits_unpacked[3] as base.u32) << 24)) {
									bits_unpacked[0] = 0
									bits_unpacked[1] = 0
									bits_unpacked[2] = 0
									bits_unpacked[3] = 0
								}
								this.swizzler.swizzle_interleaved_from_slice!(
									dst: dst[i ..],
									dst_palette: dst_palette,
									src: bits_unpacked[.. 4])
							}
						}

					} else if src_bytes_per_pixel <= s.length() {
						this.swizzler.swizzle_interleaved_from_slice!(
							dst: dst[i ..],
							dst_palette: dst_palette,
							src: s[.. src_bytes_per_pixel])
						s = s[src_bytes_per_pixel ..]
					}
				}
				x += (1 as base.u32) << INTERLACING[this.interlace_pass][0]
			} endwhile

		} else if this.depth < 8 {
			multiplier = 1
			if this.color_type == 0 {  // Color type 0 means base.PIXEL_FORMAT__Y.
				multiplier = LOW_BIT_DEPTH_MULTIPLIERS[this.depth]
			}
			shift = (8 - this.depth) & 7
			packs_remaining = 0

			while x < this.frame_rect_x1,
				inv y < 0x00FF_FFFF,
				inv this.depth < 8,
			{
				assert x < 0x00FF_FFFF via "a < b: a < c; c <= b"(c: this.frame_rect_x1)
				i = (x as base.u64) * dst_bytes_per_pixel
				if i <= dst.length() {
					if (packs_remaining == 0) and (1 <= s.length()) {
						packs_remaining = LOW_BIT_DEPTH_NUM_PACKS[this.depth]
						bits_packed = s[0]
						s = s[1 ..]
					}
					bits_unpacked[0] = (bits_packed >> shift) ~mod* multiplier
					bits_packed = bits_packed ~mod<< this.depth
					packs_remaining = packs_remaining ~mod- 1

					if ((this.remap_transparency & 0xFFFF_FFFF) as base.u32) <> 0 {
						bits_unpacked[1] = bits_unpacked[0]
						bits_unpacked[2] = bits_unpacked[0]
						bits_unpacked[3] = 0xFF
						if ((this.remap_transparency & 0xFFFF_FFFF) as base.u32) == (
							((bits_unpacked[0] as base.u32) << 0) |
							((bits_unpacked[1] as base.u32) << 8) |
							((bits_unpacked[2] as base.u32) << 16) |
							((bits_unpacked[3] as base.u32) << 24)) {
							bits_unpacked[0] = 0
							bits_unpacked[1] = 0
							bits_unpacked[2] = 0
							bits_unpacked[3] = 0
						}
						this.swizzler.swizzle_interleaved_from_slice!(
							dst: dst[i ..],
							dst_palette: dst_palette,
							src: bits_unpacked[.. 4])

					} else {
						this.swizzler.swizzle_interleaved_from_slice!(
							dst: dst[i ..],
							dst_palette: dst_palette,
							src: bits_unpacked[.. 1])
					}
				}
				x += (1 as base.u32) << INTERLACING[this.interlace_pass][0]
			} endwhile

		} else {
			while x < this.frame_rect_x1,
				inv y < 0x00FF_FFFF,
			{
				assert x < 0x00FF_FFFF via "a < b: a < c; c <= b"(c: this.frame_rect_x1)
				i = (x as base.u64) * dst_bytes_per_pixel
				if i <= dst.length() {
					if this.color_type == 0 {
						if 2 <= s.length() {
							bits_unpacked[0] = s[1]
							bits_unpacked[1] = s[0]
							bits_unpacked[2] = s[1]
							bits_unpacked[3] = s[0]
							bits_unpacked[4] = s[1]
							bits_unpacked[5] = s[0]
							bits_unpacked[6] = 0xFF
							bits_unpacked[7] = 0xFF
							s = s[2 ..]
							if this.remap_transparency == (
								((bits_unpacked[0] as base.u64) << 0) |
								((bits_unpacked[1] as base.u64) << 8) |
								((bits_unpacked[2] as base.u64) << 16) |
								((bits_unpacked[3] as base.u64) << 24) |
								((bits_unpacked[4] as base.u64) << 32) |
								((bits_unpacked[5] as base.u64) << 40) |
								((bits_unpacked[6] as base.u64) << 48) |
								((bits_unpacked[7] as base.u64) << 56)) {
								bits_unpacked[0] = 0
								bits_unpacked[1] = 0
								bits_unpacked[2] = 0
								bits_unpacked[3] = 0
								bits_unpacked[4] = 0
								bits_unpacked[5] = 0
								bits_unpacked[6] = 0
								bits_unpacked[7] = 0
							}
						}

					} else if this.color_type == 2 {
						if 6 <= s.length() {
							bits_unpacked[0] = s[5]
							bits_unpacked[1] = s[4]
							bits_unpacked[2] = s[3]
							bits_unpacked[3] = s[2]
							bits_unpacked[4] = s[1]
							bits_unpacked[5] = s[0]
							bits_unpacked[6] = 0xFF
							bits_unpacked[7] = 0xFF
							s = s[6 ..]
							if this.remap_transparency == (
								((bits_unpacked[0] as base.u64) << 0) |
								((bits_unpacked[1] as base.u64) << 8) |
								((bits_unpacked[2] as base.u64) << 16) |
								((bits_unpacked[3] as base.u64) << 24) |
								((bits_unpacked[4] as base.u64) << 32) |
								((bits_unpacked[5] as base.u64) << 40) |
								((bits_unpacked[6] as base.u64) << 48) |
								((bits_unpacked[7] as base.u64) << 56)) {
								bits_unpacked[0] = 0
								bits_unpacked[1] = 0
								bits_unpacked[2] = 0
								bits_unpacked[3] = 0
								bits_unpacked[4] = 0
								bits_unpacked[5] = 0
								bits_unpacked[6] = 0
								bits_unpacked[7] = 0
							}
						}

					} else if this.color_type == 4 {
						if 4 <= s.length() {
							bits_unpacked[0] = s[1]
							bits_unpacked[1] = s[0]
							bits_unpacked[2] = s[1]
							bits_unpacked[3] = s[0]
							bits_unpacked[4] = s[1]
							bits_unpacked[5] = s[0]
							bits_unpacked[6] = s[3]
							bits_unpacked[7] = s[2]
							s = s[4 ..]
						}

					} else {
						if 8 <= s.length() {
							bits_unpacked[0] = s[5]
							bits_unpacked[1] = s[4]
							bits_unpacked[2] = s[3]
							bits_unpacked[3] = s[2]
							bits_unpacked[4] = s[1]
							bits_unpacked[5] = s[0]
							bits_unpacked[6] = s[7]
							bits_unpacked[7] = s[6]
							s = s[8 ..]
						}
					}

					this.swizzler.swizzle_interleaved_from_slice!(
						dst: dst[i ..],
						dst_palette: dst_palette,
						src: bits_unpacked[.. 8])
				}
				x += (1 as base.u32) << INTERLACING[this.interlace_pass][0]
			} endwhile
		}

		prev_row = curr_row
		y += (1 as base.u32) << INTERLACING[this.interlace_pass][3]
	} endwhile

	return ok
}