/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.
 */

package utils

import (
	"container/list"
	"context"
	"encoding/binary"
	"fmt"
	"math/big"
	"strconv"

	"github.com/pkg/errors"
)

type WriteBufferBoxBased interface {
	WriteBuffer
	GetBox() AsciiBox
}

func NewWriteBufferBoxBased(opts ...func(buffer *boxedWriteBuffer)) WriteBufferBoxBased {
	wb := &boxedWriteBuffer{
		List:                list.New(),
		desiredWidth:        120,
		currentWidth:        118,
		asciiBoxWriter:      AsciiBoxWriterDefault,
		asciiBoxWriterLight: AsciiBoxWriterLight,
	}
	for _, opt := range opts {
		opt(wb)
	}
	return wb
}

func WithWriteBufferBoxBasedMergeSingleBoxes() func(*boxedWriteBuffer) {
	return func(wb *boxedWriteBuffer) {
		wb.mergeSingleBoxes = true
	}
}

func WithWriteBufferBoxBasedOmitEmptyBoxes() func(*boxedWriteBuffer) {
	return func(wb *boxedWriteBuffer) {
		wb.omitEmptyBoxes = true
	}
}

func WithWriteBufferBoxBasedPrintPosLengthFooter() func(*boxedWriteBuffer) {
	return func(wb *boxedWriteBuffer) {
		wb.printPosLengthFooter = true
	}
}

///////////////////////////////////////
///////////////////////////////////////
//
// Internal section
//

type boxedWriteBuffer struct {
	BufferCommons
	*list.List
	desiredWidth         int
	currentWidth         int
	mergeSingleBoxes     bool
	omitEmptyBoxes       bool
	printPosLengthFooter bool
	asciiBoxWriter       AsciiBoxWriter
	asciiBoxWriterLight  AsciiBoxWriter
	pos                  uint
}

var _ WriteBuffer = (*boxedWriteBuffer)(nil)

//
// Internal section
//
///////////////////////////////////////
///////////////////////////////////////

func (*boxedWriteBuffer) GetByteOrder() binary.ByteOrder {
	return binary.BigEndian
}

func (*boxedWriteBuffer) SetByteOrder(_ binary.ByteOrder) {
}

func (b *boxedWriteBuffer) GetBox() AsciiBox {
	back := b.Back()
	if back == nil {
		return AsciiBox{data: "<nil>"}
	}
	return back.Value.(AsciiBox)
}

func (b *boxedWriteBuffer) PushContext(_ string, _ ...WithWriterArgs) error {
	b.currentWidth -= boxLineOverheat
	b.PushBack(make([]AsciiBox, 0))
	return nil
}

func (b *boxedWriteBuffer) GetPos() uint16 {
	return uint16(b.pos / 8)
}

func (b *boxedWriteBuffer) WriteBit(logicalName string, value bool, writerArgs ...WithWriterArgs) error {
	additionalStringRepresentation := b.extractAdditionalStringRepresentation(UpcastWriterArgs(writerArgs...)...)
	asInt := 0
	if value {
		asInt = 1
	}
	stringValue := fmt.Sprintf("b%d %t%s", asInt, value, additionalStringRepresentation)
	box := b.asciiBoxWriter.BoxString(stringValue, WithAsciiBoxName(logicalName), WithAsciiBoxFooter(b.getPosFooter(1)))
	b.PushBack(box)
	b.move(1)
	return nil
}

func (b *boxedWriteBuffer) WriteByte(logicalName string, value byte, writerArgs ...WithWriterArgs) error {
	additionalStringRepresentation := b.extractAdditionalStringRepresentation(UpcastWriterArgs(writerArgs...)...)
	printSafeChar := value
	if value < 32 || value > 126 {
		printSafeChar = '.'
	}
	stringValue := fmt.Sprintf("%#02x '%c'%s", value, printSafeChar, additionalStringRepresentation)
	box := b.asciiBoxWriter.BoxString(stringValue, WithAsciiBoxName(logicalName), WithAsciiBoxFooter(b.getPosFooter(8)))
	b.PushBack(box)
	b.move(8)
	return nil
}

func (b *boxedWriteBuffer) WriteByteArray(logicalName string, data []byte, writerArgs ...WithWriterArgs) error {
	additionalStringRepresentation := b.extractAdditionalStringRepresentation(UpcastWriterArgs(writerArgs...)...)
	if additionalStringRepresentation != "" {
		additionalStringRepresentation += "\n"
	}
	stringValue := fmt.Sprintf("%s%s", additionalStringRepresentation, Dump(data))
	box := b.asciiBoxWriter.BoxString(stringValue, WithAsciiBoxName(logicalName), WithAsciiBoxFooter(b.getPosFooter(len(data)*8)))
	b.PushBack(box)
	b.move(uint(len(data) * 8))
	return nil
}

func (b *boxedWriteBuffer) WriteUint8(logicalName string, bitLength uint8, value uint8, writerArgs ...WithWriterArgs) error {
	additionalStringRepresentation := b.extractAdditionalStringRepresentation(UpcastWriterArgs(writerArgs...)...)
	stringValue := fmt.Sprintf("%#0*x %d%s", bitLength/4, value, value, additionalStringRepresentation)
	box := b.asciiBoxWriter.BoxString(stringValue, WithAsciiBoxName(logicalName), WithAsciiBoxFooter(b.getPosFooter(int(bitLength))))
	b.PushBack(box)
	b.move(uint(bitLength))
	return nil
}

func (b *boxedWriteBuffer) WriteUint16(logicalName string, bitLength uint8, value uint16, writerArgs ...WithWriterArgs) error {
	additionalStringRepresentation := b.extractAdditionalStringRepresentation(UpcastWriterArgs(writerArgs...)...)
	stringValue := fmt.Sprintf("%#0*x %d%s", bitLength/4, value, value, additionalStringRepresentation)
	box := b.asciiBoxWriter.BoxString(stringValue, WithAsciiBoxName(logicalName), WithAsciiBoxFooter(b.getPosFooter(int(bitLength))))
	b.PushBack(box)
	b.move(uint(bitLength))
	return nil
}

func (b *boxedWriteBuffer) WriteUint32(logicalName string, bitLength uint8, value uint32, writerArgs ...WithWriterArgs) error {
	additionalStringRepresentation := b.extractAdditionalStringRepresentation(UpcastWriterArgs(writerArgs...)...)
	stringValue := fmt.Sprintf("%#0*x %d%s", bitLength/4, value, value, additionalStringRepresentation)
	box := b.asciiBoxWriter.BoxString(stringValue, WithAsciiBoxName(logicalName), WithAsciiBoxFooter(b.getPosFooter(int(bitLength))))
	b.PushBack(box)
	b.move(uint(bitLength))
	return nil
}

func (b *boxedWriteBuffer) WriteUint64(logicalName string, bitLength uint8, value uint64, writerArgs ...WithWriterArgs) error {
	additionalStringRepresentation := b.extractAdditionalStringRepresentation(UpcastWriterArgs(writerArgs...)...)
	stringValue := fmt.Sprintf("%#0*x %d%s", bitLength/4, value, value, additionalStringRepresentation)
	box := b.asciiBoxWriter.BoxString(stringValue, WithAsciiBoxName(logicalName), WithAsciiBoxFooter(b.getPosFooter(int(bitLength))))
	b.PushBack(box)
	b.move(uint(bitLength))
	return nil
}

func (b *boxedWriteBuffer) WriteInt8(logicalName string, bitLength uint8, value int8, writerArgs ...WithWriterArgs) error {
	additionalStringRepresentation := b.extractAdditionalStringRepresentation(UpcastWriterArgs(writerArgs...)...)
	stringValue := fmt.Sprintf("%#0*x %d%s", bitLength/4, value, value, additionalStringRepresentation)
	box := b.asciiBoxWriter.BoxString(stringValue, WithAsciiBoxName(logicalName), WithAsciiBoxFooter(b.getPosFooter(int(bitLength))))
	b.PushBack(box)
	b.move(uint(bitLength))
	return nil
}

func (b *boxedWriteBuffer) WriteInt16(logicalName string, bitLength uint8, value int16, writerArgs ...WithWriterArgs) error {
	additionalStringRepresentation := b.extractAdditionalStringRepresentation(UpcastWriterArgs(writerArgs...)...)
	stringValue := fmt.Sprintf("%#0*x %d%s", bitLength/4, value, value, additionalStringRepresentation)
	box := b.asciiBoxWriter.BoxString(stringValue, WithAsciiBoxName(logicalName), WithAsciiBoxFooter(b.getPosFooter(int(bitLength))))
	b.PushBack(box)
	b.move(uint(bitLength))
	return nil
}

func (b *boxedWriteBuffer) WriteInt32(logicalName string, bitLength uint8, value int32, writerArgs ...WithWriterArgs) error {
	additionalStringRepresentation := b.extractAdditionalStringRepresentation(UpcastWriterArgs(writerArgs...)...)
	stringValue := fmt.Sprintf("%#0*x %d%s", bitLength/4, value, value, additionalStringRepresentation)
	box := b.asciiBoxWriter.BoxString(stringValue, WithAsciiBoxName(logicalName), WithAsciiBoxFooter(b.getPosFooter(int(bitLength))))
	b.PushBack(box)
	b.move(uint(bitLength))
	return nil
}

func (b *boxedWriteBuffer) WriteInt64(logicalName string, bitLength uint8, value int64, writerArgs ...WithWriterArgs) error {
	additionalStringRepresentation := b.extractAdditionalStringRepresentation(UpcastWriterArgs(writerArgs...)...)
	stringValue := fmt.Sprintf("%#0*x %d%s", bitLength/4, value, value, additionalStringRepresentation)
	box := b.asciiBoxWriter.BoxString(stringValue, WithAsciiBoxName(logicalName), WithAsciiBoxFooter(b.getPosFooter(int(bitLength))))
	b.PushBack(box)
	b.move(uint(bitLength))
	return nil
}

func (b *boxedWriteBuffer) WriteBigInt(logicalName string, bitLength uint8, value *big.Int, writerArgs ...WithWriterArgs) error {
	additionalStringRepresentation := b.extractAdditionalStringRepresentation(UpcastWriterArgs(writerArgs...)...)
	stringValue := fmt.Sprintf("%#0*x %d%s", bitLength/4, value, value, additionalStringRepresentation)
	box := b.asciiBoxWriter.BoxString(stringValue, WithAsciiBoxName(logicalName), WithAsciiBoxFooter(b.getPosFooter(int(bitLength))))
	b.PushBack(box)
	b.move(uint(bitLength))
	return nil
}

func (b *boxedWriteBuffer) WriteFloat32(logicalName string, bitLength uint8, value float32, writerArgs ...WithWriterArgs) error {
	additionalStringRepresentation := b.extractAdditionalStringRepresentation(UpcastWriterArgs(writerArgs...)...)
	stringValue := fmt.Sprintf("%#0*x %f%s", bitLength/4, value, value, additionalStringRepresentation)
	box := b.asciiBoxWriter.BoxString(stringValue, WithAsciiBoxName(logicalName), WithAsciiBoxFooter(b.getPosFooter(int(bitLength))))
	b.PushBack(box)
	b.move(uint(bitLength))
	return nil
}

func (b *boxedWriteBuffer) WriteFloat64(logicalName string, bitLength uint8, value float64, writerArgs ...WithWriterArgs) error {
	additionalStringRepresentation := b.extractAdditionalStringRepresentation(UpcastWriterArgs(writerArgs...)...)
	stringValue := fmt.Sprintf("%#0*x %f%s", bitLength/4, value, value, additionalStringRepresentation)
	box := b.asciiBoxWriter.BoxString(stringValue, WithAsciiBoxName(logicalName), WithAsciiBoxFooter(b.getPosFooter(int(bitLength))))
	b.PushBack(box)
	b.move(uint(bitLength))
	return nil
}

func (b *boxedWriteBuffer) WriteBigFloat(logicalName string, bitLength uint8, value *big.Float, writerArgs ...WithWriterArgs) error {
	additionalStringRepresentation := b.extractAdditionalStringRepresentation(UpcastWriterArgs(writerArgs...)...)
	stringValue := fmt.Sprintf("%#0*x %f%s", bitLength/4, value, value, additionalStringRepresentation)
	box := b.asciiBoxWriter.BoxString(stringValue, WithAsciiBoxName(logicalName), WithAsciiBoxFooter(b.getPosFooter(int(bitLength))))
	b.PushBack(box)
	b.move(uint(bitLength))
	return nil
}

func (b *boxedWriteBuffer) WriteString(logicalName string, bitLength uint32, value string, writerArgs ...WithWriterArgs) error {
	additionalStringRepresentation := b.extractAdditionalStringRepresentation(UpcastWriterArgs(writerArgs...)...)
	stringValue := fmt.Sprintf("%s%s", value, additionalStringRepresentation)
	box := b.asciiBoxWriter.BoxString(stringValue, WithAsciiBoxName(logicalName), WithAsciiBoxFooter(b.getPosFooter(int(bitLength))))
	b.PushBack(box)
	b.move(uint(bitLength))
	return nil
}

func (b *boxedWriteBuffer) WriteVirtual(ctx context.Context, logicalName string, value any, writerArgs ...WithWriterArgs) error {
	additionalStringRepresentation := b.extractAdditionalStringRepresentation(UpcastWriterArgs(writerArgs...)...)
	if value == nil {
		return nil
	}
	var asciiBox AsciiBox
	switch value.(type) {
	case bool:
		stringValue := fmt.Sprintf("%t", value)
		asciiBox = b.asciiBoxWriterLight.BoxString(stringValue, WithAsciiBoxName(logicalName))
	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64:
		stringValue := fmt.Sprintf("%#x %d%s", value, value, additionalStringRepresentation)
		asciiBox = b.asciiBoxWriterLight.BoxString(stringValue, WithAsciiBoxName(logicalName))
	case float32, float64:
		stringValue := fmt.Sprintf("%x %f%s", value, value, additionalStringRepresentation)
		asciiBox = b.asciiBoxWriterLight.BoxString(stringValue, WithAsciiBoxName(logicalName))
	case Serializable:
		virtualBoxedWriteBuffer := NewWriteBufferBoxBased().(*boxedWriteBuffer)
		virtualBoxedWriteBuffer.mergeSingleBoxes = b.mergeSingleBoxes
		virtualBoxedWriteBuffer.omitEmptyBoxes = b.omitEmptyBoxes
		virtualBoxedWriteBuffer.printPosLengthFooter = b.printPosLengthFooter
		if err := value.(Serializable).SerializeWithWriteBuffer(ctx, virtualBoxedWriteBuffer); err == nil {
			asciiBox = b.asciiBoxWriterLight.BoxBox(virtualBoxedWriteBuffer.GetBox(), WithAsciiBoxName(logicalName))
		} else {
			b.asciiBoxWriterLight.BoxString(err.Error(), WithAsciiBoxName(logicalName))
		}
	default:
		asciiBox = b.asciiBoxWriterLight.BoxString(fmt.Sprintf("%v%s", value, additionalStringRepresentation), WithAsciiBoxName(logicalName))
	}
	b.PushBack(asciiBox)
	return nil
}

func (b *boxedWriteBuffer) WriteSerializable(ctx context.Context, serializable Serializable) error {
	if serializable == nil {
		return nil
	}
	currentPos := int(b.pos) // used for footer so we remember that before we advance
	if err := serializable.SerializeWithWriteBuffer(ctx, b); err != nil {
		return err
	}
	back := b.Back()
	if back == nil {
		return nil
	}
	if ab, ok := back.Value.(AsciiBox); ok {
		if la, ok := serializable.(LengthAware); ok {
			bitLength := int(la.GetLengthInBits(ctx))
			back.Value = ab.ChangeBoxFooter(b.getPosFooterWithCurrentPost(currentPos, bitLength))
		}
	}
	return nil
}

func (b *boxedWriteBuffer) PopContext(logicalName string, _ ...WithWriterArgs) error {
	b.currentWidth += boxLineOverheat
	finalBoxes := make([]AsciiBox, 0)
findTheBox:
	for back := b.Back(); back != nil; back = b.Back() {
		switch back.Value.(type) {
		case AsciiBox:
			asciiBox := b.Remove(back).(AsciiBox)
			if b.omitEmptyBoxes && asciiBox.IsEmpty() {
				continue
			}
			finalBoxes = append([]AsciiBox{asciiBox}, finalBoxes...)
		case []AsciiBox:
			b.Remove(back)
			asciiBoxes := b.Remove(back).([]AsciiBox)
			finalBoxes = append(asciiBoxes, finalBoxes...)
			break findTheBox
		default:
			return errors.New("We should never reach this point")
		}
	}
	if b.mergeSingleBoxes && len(finalBoxes) == 1 {
		onlyChild := finalBoxes[0]
		childName := onlyChild.GetBoxName()
		onlyChild = onlyChild.ChangeBoxName(logicalName + "/" + childName)
		if b.omitEmptyBoxes && onlyChild.IsEmpty() {
			return nil
		}
		b.PushBack(onlyChild)
		return nil
	}
	asciiBox := b.asciiBoxWriter.BoxBox(b.asciiBoxWriter.AlignBoxes(finalBoxes, b.currentWidth), WithAsciiBoxName(logicalName))
	if b.omitEmptyBoxes && asciiBox.IsEmpty() {
		return nil
	}
	b.PushBack(asciiBox)
	return nil
}

func (b *boxedWriteBuffer) extractAdditionalStringRepresentation(readerWriterArgs ...WithReaderWriterArgs) string {
	representation := b.BufferCommons.ExtractAdditionalStringRepresentation(readerWriterArgs...)
	if representation != "" {
		return " " + representation
	}
	return ""
}

func (b *boxedWriteBuffer) move(bits uint) {
	b.pos += bits
}

func (b *boxedWriteBuffer) getPosFooter(bitLength int) string {
	return b.getPosFooterWithCurrentPost(int(b.pos), bitLength)
}

func (b *boxedWriteBuffer) getPosFooterWithCurrentPost(currentPos, bitLength int) string {
	if !b.printPosLengthFooter {
		return ""
	}
	bytePos := currentPos / 8
	bitRemainder := currentPos % 8
	pos := strconv.Itoa(bytePos)
	if bitRemainder != 0 {
		pos += "." + strconv.Itoa(bitRemainder)
	}
	byteLength := bitLength / 8
	bitLengthRemainder := bitLength % 8
	length := strconv.Itoa(byteLength)
	if bitLengthRemainder != 0 {
		length += "." + strconv.Itoa(bitLengthRemainder)
	}
	return fmt.Sprintf("%s/%s", pos, length)
}