// Copyright 2025 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

// ----------------

//go:build ignore
// +build ignore

package main

import (
	"bytes"
	"fmt"
	"os"
)

func main() {
	if err := main1(); err != nil {
		os.Stderr.WriteString(err.Error() + "\n")
		os.Exit(1)
	}
}

func main1() error {
	w := &bytes.Buffer{}
	w.WriteString(header)

	genUpsampleFrom(w)
	w.WriteString("\n")
	genHardCodedDHTSegments(w)
	w.WriteString("\n")
	genHuffmanBitWriters(w)

	return os.WriteFile("data.go", w.Bytes(), 0644)
}

func genUpsampleFrom(w *bytes.Buffer) {
	w.WriteString("// UpsampleFrom produces one 16×16 quad-block from one 8×8 block.\n")
	w.WriteString("//\n")
	w.WriteString("// It uses a triangle filter.\n")
	w.WriteString("func (dst *QuadBlockU8) UpsampleFrom(src *BlockU8) {\n")
	w.WriteString("\tif dst == nil {\n\t\treturn\n\t} else if src == nil {\n\t\tdst.SetToNeutral()\n\t\treturn\n\t}\n")
	for y := 0; y < 16; y++ {
		for x := 0; x < 16; x++ {
			d := (y << 4) | x

			s0 := ((y >> 1) << 3) | (x >> 1)
			sx := ((x & 1) * 2) - 1
			sy := ((y & 1) * 16) - 8

			// Handle corners.
			if ((x == 0x00) || (x == 0x0F)) && ((y == 0x00) || (y == 0x0F)) {
				fmt.Fprintf(w, "\tdst[0x%02X] = src[0x%02X]\n", d, s0)
				continue
			}

			// Handle top and bottom edges.
			if (y == 0x00) || (y == 0x0F) {
				fmt.Fprintf(w, "\tdst[0x%02X] = uint8(((3 * uint32(src[0x%02X])) + uint32(src[0x%02X]) + 2) / 4)\n", d, s0, s0+sx)
				continue
			}

			// Handle left and right edges.
			if (x == 0x00) || (x == 0x0F) {
				fmt.Fprintf(w, "\tdst[0x%02X] = uint8(((3 * uint32(src[0x%02X])) + uint32(src[0x%02X]) + 2) / 4)\n", d, s0, s0+sy)
				continue
			}

			fmt.Fprintf(w, "\tdst[0x%02X] = uint8(("+
				"(9 * uint32(src[0x%02X])) + "+
				"(3 * uint32(src[0x%02X])) + "+
				"(3 * uint32(src[0x%02X])) + "+
				"uint32(src[0x%02X]) + 8) / 16)\n", d, s0, s0+sx, s0+sy, s0+sx+sy)
		}
	}
	w.WriteString("}\n")
}

func fillInPlaceholderPayloadLength(payload []byte) {
	n := len(payload) - 2 // Minus 2 for the JPEG marker.
	payload[2] = uint8(n >> 8)
	payload[3] = uint8(n >> 0)
}

func genConstStringData(w *bytes.Buffer, contents []byte) {
	for {
		prefix := contents
		if len(prefix) > 16 {
			prefix, contents = contents[:16], contents[16:]
		} else {
			contents = nil
		}

		w.WriteString("\t\"")
		for _, v := range prefix {
			fmt.Fprintf(w, "\\x%02X", v)
		}
		w.WriteString("\"")

		if len(contents) == 0 {
			break
		}
		w.WriteString(" +\n")
	}
}

func genHardCodedDHTSegments(w *bytes.Buffer) {
	w.WriteString("const hardCodedDHTSegments = \"\" +\n")

	for i := 0; i < 2; i++ {
		contents := append([]byte(nil),
			0xFF, 0xC4, // DHT marker.
			0x00, 0x00, // Placeholder payload length.
		)

		if i == 0 {
			w.WriteString("\t// 212 bytes for the first DHT segment.\n")
		} else {
			w.WriteString(" +\n\t// 212 bytes for the second DHT segment.\n")
		}

		contents = append(contents, 0x00|uint8(i)) // 0x00 means DC.
		contents = append(contents, theHuffmanSpec[(2*i)+0].counts[:]...)
		contents = append(contents, theHuffmanSpec[(2*i)+0].values...)
		contents = append(contents, 0x10|uint8(i)) // 0x10 means AC.
		contents = append(contents, theHuffmanSpec[(2*i)+1].counts[:]...)
		contents = append(contents, theHuffmanSpec[(2*i)+1].values...)

		fillInPlaceholderPayloadLength(contents)
		genConstStringData(w, contents)
	}
	w.WriteString("\n")
}

func genHuffmanBitWriters(w *bytes.Buffer) {
	w.WriteString("// huffmanBitWriter is a Huffman code LUT (Look-Up Table) for encoding.\n")
	w.WriteString("//\n")
	w.WriteString("// huffmanBitWriter[i] is the Huffman encoding for the value i: two uint16\n")
	w.WriteString("// halves packed as a uint32. The low half holds the bitstring bits. The high\n")
	w.WriteString("// half holds the bitstring length. Bitstrings are also known as code words.\n")
	w.WriteString("//\n")
	w.WriteString("// For example, huffmanBitWriters[0][5] being 0x00030006 means the Luma DC\n")
	w.WriteString("// value 5 has the bitstring \"110\".\n")
	w.WriteString("type huffmanBitWriter [256]uint32\n\n")

	w.WriteString("var huffmanBitWriters = [4]huffmanBitWriter{{\n")

	for i := range theHuffmanSpec {
		if i != 0 {
			w.WriteString("}, {\n")
		}

		hbw := huffmanBitWriter{}
		hbw.initialize(&theHuffmanSpec[i])

		for i, v := range hbw {
			if (i & 7) == 0 {
				w.WriteString("\t")
			}
			fmt.Fprintf(w, "0x%08X,", v)
			if (i & 7) == 7 {
				w.WriteString("\n")
			} else {
				w.WriteString(" ")
			}
		}
	}

	w.WriteString("}}\n")
}

// huffmanSpec specifies a Huffman encoding.
type huffmanSpec struct {
	// counts[i] is the number of code words of length i+1 bits.
	counts [16]byte
	// values[i] is the decoded value of the i'th code word.
	values []byte
}

// theHuffmanSpec corresponds to Section K.3 "Typical Huffman tables for 8-bit
// precision luminance and chrominance" of the JPEG spec.
//
// Each Huffman code is deliberately incomplete. No code word (also known as a
// bitstring) is all-1-bits, since that would interact poorly with JPEG's byte
// stuffing.
//
// See the JPEG spec (https://www.w3.org/Graphics/JPEG/itu-t81.pdf) Section C:
// "the codes shall be generated such that the all-1-bits code word of any
// length is reserved".
var theHuffmanSpec = [4]huffmanSpec{{
	// Luma DC. 12 elements.
	//
	// See the JPEG spec, Table K.3.
	//
	// value : bitstring : len(bitstring)
	// 0x00  : 00        : 2
	// 0x01  : 010       : 3
	// 0x02  : 011       : 3
	// 0x03  : 100       : 3
	// 0x04  : 101       : 3
	// 0x05  : 110       : 3
	// 0x06  : 1110      : 4
	// 0x07  : 11110     : 5
	// 0x08  : 111110    : 6
	// 0x09  : 1111110   : 7
	// 0x0A  : 11111110  : 8
	// 0x0B  : 111111110 : 9
	[16]byte{0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0},
	[]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
}, {

	// Luma AC. 162 elements.
	//
	// See the JPEG spec, Table K.5.
	//
	// value : bitstring : len(bitstring)
	// 0x01  : 00        : 2
	// 0x02  : 01        : 2
	// 0x03  : 100       : 3
	// 0x00  : 1010      : 4
	// 0x04  : 1011      : 4
	// 0x11  : 1100      : 4
	// 0x05  : 11010     : 5
	// etc   : etc       : etc
	[16]byte{0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 125},
	[]byte{
		0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
		0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
		0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1, 0x08,
		0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0,
		0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0A, 0x16,
		0x17, 0x18, 0x19, 0x1A, 0x25, 0x26, 0x27, 0x28,
		0x29, 0x2A, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
		0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
		0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
		0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
		0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
		0x7A, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
		0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
		0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7,
		0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6,
		0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5,
		0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4,
		0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE1, 0xE2,
		0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA,
		0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8,
		0xF9, 0xFA,
	},
}, {

	// Chroma DC. 12 elements.
	//
	// See the JPEG spec, Table K.4.
	[16]byte{0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0},
	[]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
}, {

	// Chroma AC. 162 elements.
	//
	// See the JPEG spec, Table K.6.
	[16]byte{0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 119},
	[]byte{
		0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
		0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
		0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
		0xA1, 0xB1, 0xC1, 0x09, 0x23, 0x33, 0x52, 0xF0,
		0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16, 0x24, 0x34,
		0xE1, 0x25, 0xF1, 0x17, 0x18, 0x19, 0x1A, 0x26,
		0x27, 0x28, 0x29, 0x2A, 0x35, 0x36, 0x37, 0x38,
		0x39, 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
		0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
		0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
		0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
		0x79, 0x7A, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
		0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96,
		0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5,
		0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4,
		0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3,
		0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2,
		0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA,
		0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9,
		0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8,
		0xF9, 0xFA,
	},
}}

// huffmanBitWriter is a Huffman code LUT (Look-Up Table) for encoding.
//
// huffmanBitWriter[i] is the Huffman encoding for the value i: two uint16
// halves packed as a uint32. The low half holds the bitstring bits. The high
// half holds the bitstring length. Bitstrings are also known as code words.
type huffmanBitWriter [256]uint32

func (b *huffmanBitWriter) initialize(s *huffmanSpec) {
	bits, k := uint32(0), 0
	for i, count := range s.counts {
		length16 := uint32(i+1) << 16
		for j := uint8(0); j < count; j++ {
			if bits > 0xFFFF {
				panic("bits overflowed")
			}
			b[s.values[k]] = length16 | bits
			bits++
			k++
		}
		bits <<= 1
	}
}

const header = `// Code generated by running "go generate". DO NOT EDIT.

// Copyright 2025 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

package lowleveljpeg

`