package d2dcc

import (
	"log"

	"github.com/OpenDiablo2/OpenDiablo2/d2common/d2datautils"
	"github.com/OpenDiablo2/OpenDiablo2/d2common/d2geom"

	"github.com/OpenDiablo2/OpenDiablo2/d2common/d2math"
)

const (
	baseMinx = 100000
	baseMiny = 100000
	baseMaxx = -100000
	baseMaxy = -100000
)

const cellsPerRow = 4

// DCCDirection represents a DCCDirection file.
type DCCDirection struct {
	OutSizeCoded               int
	CompressionFlags           int
	Variable0Bits              int
	WidthBits                  int
	HeightBits                 int
	XOffsetBits                int
	YOffsetBits                int
	OptionalDataBits           int
	CodedBytesBits             int
	EqualCellsBitstreamSize    int
	PixelMaskBitstreamSize     int
	EncodingTypeBitsreamSize   int
	RawPixelCodesBitstreamSize int
	Frames                     []*DCCDirectionFrame
	PaletteEntries             [256]byte
	Box                        d2geom.Rectangle
	Cells                      []*DCCCell
	PixelData                  []byte
	HorizontalCellCount        int
	VerticalCellCount          int
	PixelBuffer                []DCCPixelBufferEntry
}

// CreateDCCDirection creates an instance of a DCCDirection.
// nolint:funlen // no need to reduce
func CreateDCCDirection(bm *d2datautils.BitMuncher, file *DCC) *DCCDirection {
	// nolint:gomnd // constant
	var crazyBitTable = []byte{0, 1, 2, 4, 6, 8, 10, 12, 14, 16, 20, 24, 26, 28, 30, 32}

	result := &DCCDirection{
		OutSizeCoded:     int(bm.GetUInt32()),
		CompressionFlags: int(bm.GetBits(2)),                //nolint:gomnd // binary data
		Variable0Bits:    int(crazyBitTable[bm.GetBits(4)]), //nolint:gomnd // binary data
		WidthBits:        int(crazyBitTable[bm.GetBits(4)]), //nolint:gomnd // binary data
		HeightBits:       int(crazyBitTable[bm.GetBits(4)]), //nolint:gomnd // binary data
		XOffsetBits:      int(crazyBitTable[bm.GetBits(4)]), //nolint:gomnd // binary data
		YOffsetBits:      int(crazyBitTable[bm.GetBits(4)]), //nolint:gomnd // binary data
		OptionalDataBits: int(crazyBitTable[bm.GetBits(4)]), //nolint:gomnd // binary data
		CodedBytesBits:   int(crazyBitTable[bm.GetBits(4)]), //nolint:gomnd // binary data
		Frames:           make([]*DCCDirectionFrame, file.FramesPerDirection),
	}

	minx := baseMinx
	miny := baseMiny
	maxx := baseMaxx
	maxy := baseMaxy

	// Load the frame headers
	for frameIdx := 0; frameIdx < file.FramesPerDirection; frameIdx++ {
		result.Frames[frameIdx] = CreateDCCDirectionFrame(bm, result)
		minx = int(d2math.MinInt32(int32(result.Frames[frameIdx].Box.Left), int32(minx)))
		miny = int(d2math.MinInt32(int32(result.Frames[frameIdx].Box.Top), int32(miny)))
		maxx = int(d2math.MaxInt32(int32(result.Frames[frameIdx].Box.Right()), int32(maxx)))
		maxy = int(d2math.MaxInt32(int32(result.Frames[frameIdx].Box.Bottom()), int32(maxy)))
	}

	result.Box = d2geom.Rectangle{Left: minx, Top: miny, Width: maxx - minx, Height: maxy - miny}

	if result.OptionalDataBits > 0 {
		log.Panic("Optional bits in DCC data is not currently supported.")
	}

	// nolint:gomnd // byte operation
	if (result.CompressionFlags & 0x2) > 0 {
		result.EqualCellsBitstreamSize = int(bm.GetBits(20)) //nolint:gomnd // binary data
	}

	result.PixelMaskBitstreamSize = int(bm.GetBits(20)) //nolint:gomnd // binary data

	// nolint:gomnd // byte operation
	if (result.CompressionFlags & 0x1) > 0 {
		result.EncodingTypeBitsreamSize = int(bm.GetBits(20))   //nolint:gomnd // binary data
		result.RawPixelCodesBitstreamSize = int(bm.GetBits(20)) //nolint:gomnd // binary data
	}

	for paletteEntryCount, i := 0, 0; i < 256; i++ {
		valid := bm.GetBit() != 0
		if valid {
			result.PaletteEntries[paletteEntryCount] = byte(i)
			paletteEntryCount++
		}
	}

	// HERE BE GIANTS:
	// Because of the way this thing mashes bits together, BIT offset matters
	// here. For example, if you are on byte offset 3, bit offset 6, and
	// the EqualCellsBitstreamSize is 20 bytes, then the next bit stream
	// will be located at byte 23, bit offset 6!
	equalCellsBitstream := d2datautils.CopyBitMuncher(bm)

	bm.SkipBits(result.EqualCellsBitstreamSize)

	pixelMaskBitstream := d2datautils.CopyBitMuncher(bm)

	bm.SkipBits(result.PixelMaskBitstreamSize)

	encodingTypeBitsream := d2datautils.CopyBitMuncher(bm)

	bm.SkipBits(result.EncodingTypeBitsreamSize)

	rawPixelCodesBitstream := d2datautils.CopyBitMuncher(bm)

	bm.SkipBits(result.RawPixelCodesBitstreamSize)

	pixelCodeandDisplacement := d2datautils.CopyBitMuncher(bm)

	// Calculate the cells for the direction
	result.calculateCells()

	// Calculate the cells for each of the frames
	for _, frame := range result.Frames {
		frame.recalculateCells(result)
	}

	// Fill in the pixel buffer
	result.fillPixelBuffer(pixelCodeandDisplacement, equalCellsBitstream, pixelMaskBitstream, encodingTypeBitsream, rawPixelCodesBitstream)

	// Generate the actual frame pixel data
	result.generateFrames(pixelCodeandDisplacement)

	result.PixelBuffer = nil

	// Verify that everything we expected to read was actually read (sanity check)...
	result.verify(equalCellsBitstream, pixelMaskBitstream, encodingTypeBitsream, rawPixelCodesBitstream)

	bm.SkipBits(pixelCodeandDisplacement.BitsRead())

	return result
}

func (v *DCCDirection) verify(
	equalCellsBitstream,
	pixelMaskBitstream,
	encodingTypeBitstream,
	rawPixelCodesBitstream *d2datautils.BitMuncher,
) {
	if equalCellsBitstream.BitsRead() != v.EqualCellsBitstreamSize {
		log.Panic("Did not read the correct number of bits!")
	}

	if pixelMaskBitstream.BitsRead() != v.PixelMaskBitstreamSize {
		log.Panic("Did not read the correct number of bits!")
	}

	if encodingTypeBitstream.BitsRead() != v.EncodingTypeBitsreamSize {
		log.Panic("Did not read the correct number of bits!")
	}

	if rawPixelCodesBitstream.BitsRead() != v.RawPixelCodesBitstreamSize {
		log.Panic("Did not read the correct number of bits!")
	}
}

// nolint:gocognit,gocyclo // Can't reduce
func (v *DCCDirection) generateFrames(pcd *d2datautils.BitMuncher) {
	pbIdx := 0

	for _, cell := range v.Cells {
		cell.LastWidth = -1
		cell.LastHeight = -1
	}

	v.PixelData = make([]byte, v.Box.Width*v.Box.Height)
	frameIndex := -1

	for _, frame := range v.Frames {
		frameIndex++

		frame.PixelData = make([]byte, v.Box.Width*v.Box.Height)
		c := -1

		for _, cell := range frame.Cells {
			c++

			cellX := cell.XOffset / cellsPerRow
			cellY := cell.YOffset / cellsPerRow
			cellIndex := cellX + (cellY * v.HorizontalCellCount)
			bufferCell := v.Cells[cellIndex]
			pbe := v.PixelBuffer[pbIdx]

			if (pbe.Frame != frameIndex) || (pbe.FrameCellIndex != c) {
				// This buffer cell has an EqualCell bit set to 1, so copy the frame cell or clear it
				if (cell.Width != bufferCell.LastWidth) || (cell.Height != bufferCell.LastHeight) {
					// Different sizes
					for y := 0; y < cell.Height; y++ {
						for x := 0; x < cell.Width; x++ {
							v.PixelData[x+cell.XOffset+((y+cell.YOffset)*v.Box.Width)] = 0
						}
					}
				} else {
					// Same sizes
					// Copy the old frame cell into the new position
					for fy := 0; fy < cell.Height; fy++ {
						for fx := 0; fx < cell.Width; fx++ {
							// Frame (buff.lastx, buff.lasty) -> Frame (cell.offx, cell.offy)
							// Cell (0, 0,) ->
							// blit(dir->bmp, dir->bmp, buff_cell->last_x0, buff_cell->last_y0, cell->x0, cell->y0, cell->w, cell->h );
							v.PixelData[fx+cell.XOffset+((fy+cell.YOffset)*v.Box.Width)] =
								v.PixelData[fx+bufferCell.LastXOffset+((fy+bufferCell.LastYOffset)*v.Box.Width)]
						}
					}
					// Copy it again into the final frame image
					for fy := 0; fy < cell.Height; fy++ {
						for fx := 0; fx < cell.Width; fx++ {
							// blit(cell->bmp, frm_bmp, 0, 0, cell->x0, cell->y0, cell->w, cell->h );
							frame.PixelData[fx+cell.XOffset+((fy+cell.YOffset)*v.Box.Width)] = v.PixelData[cell.XOffset+fx+((cell.YOffset+fy)*v.Box.Width)]
						}
					}
				}
			} else {
				if pbe.Value[0] == pbe.Value[1] {
					// Clear the frame
					for y := 0; y < cell.Height; y++ {
						for x := 0; x < cell.Width; x++ {
							v.PixelData[x+cell.XOffset+((y+cell.YOffset)*v.Box.Width)] = pbe.Value[0]
						}
					}
				} else {
					// Fill the frame cell with the pixels
					bitsToRead := 1
					if pbe.Value[1] != pbe.Value[2] {
						bitsToRead = 2
					}
					for y := 0; y < cell.Height; y++ {
						for x := 0; x < cell.Width; x++ {
							paletteIndex := pcd.GetBits(bitsToRead)
							v.PixelData[x+cell.XOffset+((y+cell.YOffset)*v.Box.Width)] = pbe.Value[paletteIndex]
						}
					}
				}

				// Copy the frame cell into the frame
				for fy := 0; fy < cell.Height; fy++ {
					for fx := 0; fx < cell.Width; fx++ {
						// blit(cell->bmp, frm_bmp, 0, 0, cell->x0, cell->y0, cell->w, cell->h );
						frame.PixelData[fx+cell.XOffset+((fy+cell.YOffset)*v.Box.Width)] = v.PixelData[fx+cell.XOffset+((fy+cell.YOffset)*v.Box.Width)]
					}
				}
				pbIdx++
			}

			bufferCell.LastWidth = cell.Width
			bufferCell.LastHeight = cell.Height
			bufferCell.LastXOffset = cell.XOffset
			bufferCell.LastYOffset = cell.YOffset
		}

		// Free up the stuff we no longer need
		frame.Cells = nil
	}

	v.Cells = nil
	v.PixelData = nil
	v.PixelBuffer = nil
}

//nolint:funlen,gocognit,gocyclo // can't reduce
func (v *DCCDirection) fillPixelBuffer(pcd, ec, pm, et, rp *d2datautils.BitMuncher) {
	var pixelMaskLookup = []int{0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4}

	lastPixel := uint32(0)
	maxCellX := 0
	maxCellY := 0

	for _, frame := range v.Frames {
		if frame == nil {
			continue
		}

		maxCellX += frame.HorizontalCellCount
		maxCellY += frame.VerticalCellCount
	}

	v.PixelBuffer = make([]DCCPixelBufferEntry, maxCellX*maxCellY)

	for i := 0; i < maxCellX*maxCellY; i++ {
		v.PixelBuffer[i].Frame = -1
		v.PixelBuffer[i].FrameCellIndex = -1
	}

	cellBuffer := make([]*DCCPixelBufferEntry, v.HorizontalCellCount*v.VerticalCellCount)
	frameIndex := -1
	pbIndex := -1

	var pixelMask uint32

	for _, frame := range v.Frames {
		frameIndex++

		originCellX := (frame.Box.Left - v.Box.Left) / cellsPerRow
		originCellY := (frame.Box.Top - v.Box.Top) / cellsPerRow

		for cellY := 0; cellY < frame.VerticalCellCount; cellY++ {
			currentCellY := cellY + originCellY

			for cellX := 0; cellX < frame.HorizontalCellCount; cellX++ {
				currentCell := originCellX + cellX + (currentCellY * v.HorizontalCellCount)
				nextCell := false
				tmp := 0

				if cellBuffer[currentCell] != nil {
					if v.EqualCellsBitstreamSize > 0 {
						tmp = int(ec.GetBit())
					} else {
						tmp = 0
					}

					if tmp == 0 {
						pixelMask = pm.GetBits(4) //nolint:gomnd // binary data
					} else {
						nextCell = true
					}
				} else {
					pixelMask = 0x0F
				}

				if nextCell {
					continue
				}

				// Decode the pixels
				var pixelStack [4]uint32

				lastPixel = 0
				numberOfPixelBits := pixelMaskLookup[pixelMask]
				encodingType := 0

				if (numberOfPixelBits != 0) && (v.EncodingTypeBitsreamSize > 0) {
					encodingType = int(et.GetBit())
				} else {
					encodingType = 0
				}

				decodedPixel := 0

				for i := 0; i < numberOfPixelBits; i++ {
					if encodingType != 0 {
						pixelStack[i] = rp.GetBits(8) //nolint:gomnd // binary data
					} else {
						pixelStack[i] = lastPixel
						pixelDisplacement := pcd.GetBits(4) //nolint:gomnd // binary data
						pixelStack[i] += pixelDisplacement
						for pixelDisplacement == 15 {
							pixelDisplacement = pcd.GetBits(4) //nolint:gomnd // binary data
							pixelStack[i] += pixelDisplacement
						}
					}

					if pixelStack[i] == lastPixel {
						pixelStack[i] = 0
						break
					} else {
						lastPixel = pixelStack[i]
						decodedPixel++
					}
				}

				oldEntry := cellBuffer[currentCell]

				pbIndex++

				curIdx := decodedPixel - 1

				for i := 0; i < 4; i++ {
					if (pixelMask & (1 << uint(i))) != 0 {
						if curIdx >= 0 {
							v.PixelBuffer[pbIndex].Value[i] = byte(pixelStack[curIdx])
							curIdx--
						} else {
							v.PixelBuffer[pbIndex].Value[i] = 0
						}
					} else {
						v.PixelBuffer[pbIndex].Value[i] = oldEntry.Value[i]
					}
				}

				cellBuffer[currentCell] = &v.PixelBuffer[pbIndex]
				v.PixelBuffer[pbIndex].Frame = frameIndex
				v.PixelBuffer[pbIndex].FrameCellIndex = cellX + (cellY * frame.HorizontalCellCount)
			}
		}
	}

	// Convert the palette entry index into actual palette entries
	for i := 0; i <= pbIndex; i++ {
		for x := 0; x < 4; x++ {
			v.PixelBuffer[i].Value[x] = v.PaletteEntries[v.PixelBuffer[i].Value[x]]
		}
	}
}

func (v *DCCDirection) calculateCells() {
	// Calculate the number of vertical and horizontal cells we need
	v.HorizontalCellCount = 1 + (v.Box.Width-1)/cellsPerRow
	v.VerticalCellCount = 1 + (v.Box.Height-1)/cellsPerRow
	// Calculate the cell widths
	cellWidths := make([]int, v.HorizontalCellCount)
	if v.HorizontalCellCount == 1 {
		cellWidths[0] = v.Box.Width
	} else {
		for i := 0; i < v.HorizontalCellCount-1; i++ {
			cellWidths[i] = 4
		}

		// nolint:gomnd // constant
		cellWidths[v.HorizontalCellCount-1] = v.Box.Width - (4 * (v.HorizontalCellCount - 1))
	}
	// Calculate the cell heights
	// nolint:gomnd // constant
	cellHeights := make([]int, v.VerticalCellCount)
	if v.VerticalCellCount == 1 {
		cellHeights[0] = v.Box.Height
	} else {
		for i := 0; i < v.VerticalCellCount-1; i++ {
			cellHeights[i] = 4
		}

		// nolint:gomnd // constant
		cellHeights[v.VerticalCellCount-1] = v.Box.Height - (4 * (v.VerticalCellCount - 1))
	}
	// Set the cell widths and heights in the cell buffer
	v.Cells = make([]*DCCCell, v.VerticalCellCount*v.HorizontalCellCount)
	yOffset := 0

	for y := 0; y < v.VerticalCellCount; y++ {
		xOffset := 0

		for x := 0; x < v.HorizontalCellCount; x++ {
			v.Cells[x+(y*v.HorizontalCellCount)] = &DCCCell{
				Width:   cellWidths[x],
				Height:  cellHeights[y],
				XOffset: xOffset,
				YOffset: yOffset,
			}

			xOffset += 4
		}

		yOffset += 4
	}
}