package bs

import (
    "fmt"
    "image"
    "math"

    "bytex64.net/code/bitsmash/packet"
)

func (self *BitSmash) Size() image.Point {
    return image.Point{self.size, self.Length() / self.size}
}

func (self *BitSmash) Length() int {
    n := 0
    for _, p := range(self.packetList) {
        n += p.Length()
    }
    return n
}

func (self *BitSmash) ByteLength() int {
    n_pd := int(math.Ceil(float64(len(self.packetList)) / 4.0))
    total_len := n_pd + 3
    for _, p := range(self.packetList) {
        total_len += p.ByteLength()
    }
    return total_len
}

func (self *BitSmash) unpackRepeat() []packet.Packet {
    outlist := make([]packet.Packet, 1)
    outlist[0] = self.packetList[0]
    
    c := 1
    for _, p := range(self.packetList) {
        switch p.(type) {
        case *packet.RepeatPacket:
            rp := p.(*packet.RepeatPacket)
            outlist = rp.UnRepeat(outlist, c)
            c += rp.Count()
        default:
            outlist = append(outlist, p)
            c++
        }
    }

    return outlist
}

func (self *BitSmash) Dump() {
    self.unpackRepeat()
    size := self.Size()
    fmt.Printf("%d pixels, %dx%d\n", self.Length(), size.X, size.Y)
    fmt.Printf("Palette %d, palette map %b %04b %04b %04b %04b\n", self.palette,
                                                                   self.paletteMap & 0x10000 >> 16,
                                                                   self.paletteMap & 0xF000 >> 12,
                                                                   self.paletteMap & 0xF00 >> 8,
                                                                   self.paletteMap & 0xF0 >> 4,
                                                                   self.paletteMap & 0xF)
    fmt.Printf("%d packets:\n", len(self.packetList))

    c := 0

    for _, p := range(self.packetList) {
        switch p.(type) {
        case *packet.RepeatPacket:
            fmt.Printf("      %s\n", p)
            rp := p.(*packet.RepeatPacket)
            //d := c - rp.Distance()
            //tpl = rp.UnRepeat(tpl, c)
            for i := 0; i < rp.Count(); i++ {
                fmt.Printf("%-4d    %s\n", c + i, rp.Slice()[i])
            }
            c += rp.Count()
        default:
            fmt.Printf("%-4d  %s\n", c, p)
            c++
        }
    }

    fmt.Printf("%d total bytes\n", self.ByteLength())
}

func (self *BitSmash) RawDump() {
    for i, p := range(self.packetList) {
        fmt.Printf("%-4d  %s\n", i, p)
    }
}