package plist

import (
	"bytes"
	"encoding/binary"
	"errors"
	"fmt"
	"io"
	"io/ioutil"
	"math"
	"runtime"
	"time"
	"unicode/utf16"
)

type offset uint64

type bplistParser struct {
	buffer []byte

	reader        io.ReadSeeker
	version       int
	objects       []cfValue // object ID to object
	trailer       bplistTrailer
	trailerOffset uint64

	containerStack []offset // slice of object offsets; manipulated during container deserialization
}

func (p *bplistParser) validateDocumentTrailer() {
	if p.trailer.OffsetTableOffset >= p.trailerOffset {
		panic(fmt.Errorf("offset table beyond beginning of trailer (0x%x, trailer@0x%x)", p.trailer.OffsetTableOffset, p.trailerOffset))
	}

	if p.trailer.OffsetTableOffset < 9 {
		panic(fmt.Errorf("offset table begins inside header (0x%x)", p.trailer.OffsetTableOffset))
	}

	if p.trailerOffset > (p.trailer.NumObjects*uint64(p.trailer.OffsetIntSize))+p.trailer.OffsetTableOffset {
		panic(errors.New("garbage between offset table and trailer"))
	}

	if p.trailer.OffsetTableOffset+(uint64(p.trailer.OffsetIntSize)*p.trailer.NumObjects) > p.trailerOffset {
		panic(errors.New("offset table isn't long enough to address every object"))
	}

	maxObjectRef := uint64(1) << (8 * p.trailer.ObjectRefSize)
	if p.trailer.NumObjects > maxObjectRef {
		panic(fmt.Errorf("more objects (%v) than object ref size (%v bytes) can support", p.trailer.NumObjects, p.trailer.ObjectRefSize))
	}

	if p.trailer.OffsetIntSize < uint8(8) && (uint64(1)<<(8*p.trailer.OffsetIntSize)) <= p.trailer.OffsetTableOffset {
		panic(errors.New("offset size isn't big enough to address entire file"))
	}

	if p.trailer.TopObject >= p.trailer.NumObjects {
		panic(fmt.Errorf("top object #%d is out of range (only %d exist)", p.trailer.TopObject, p.trailer.NumObjects))
	}
}

func (p *bplistParser) parseDocument() (pval cfValue, parseError error) {
	defer func() {
		if r := recover(); r != nil {
			if _, ok := r.(runtime.Error); ok {
				panic(r)
			}

			parseError = plistParseError{"binary", r.(error)}
		}
	}()

	p.buffer, _ = ioutil.ReadAll(p.reader)

	l := len(p.buffer)
	if l < 40 {
		panic(errors.New("not enough data"))
	}

	if !bytes.Equal(p.buffer[0:6], []byte{'b', 'p', 'l', 'i', 's', 't'}) {
		panic(errors.New("incomprehensible magic"))
	}

	p.version = int(((p.buffer[6] - '0') * 10) + (p.buffer[7] - '0'))

	if p.version > 1 {
		panic(fmt.Errorf("unexpected version %d", p.version))
	}

	p.trailerOffset = uint64(l - 32)
	p.trailer = bplistTrailer{
		SortVersion:       p.buffer[p.trailerOffset+5],
		OffsetIntSize:     p.buffer[p.trailerOffset+6],
		ObjectRefSize:     p.buffer[p.trailerOffset+7],
		NumObjects:        binary.BigEndian.Uint64(p.buffer[p.trailerOffset+8:]),
		TopObject:         binary.BigEndian.Uint64(p.buffer[p.trailerOffset+16:]),
		OffsetTableOffset: binary.BigEndian.Uint64(p.buffer[p.trailerOffset+24:]),
	}

	p.validateDocumentTrailer()

	// INVARIANTS:
	// - Entire offset table is before trailer
	// - Offset table begins after header
	// - Offset table can address entire document
	// - Object IDs are big enough to support the number of objects in this plist
	// - Top object is in range

	p.objects = make([]cfValue, p.trailer.NumObjects)

	pval = p.objectAtIndex(p.trailer.TopObject)
	return
}

// parseSizedInteger returns a 128-bit integer as low64, high64
func (p *bplistParser) parseSizedInteger(off offset, nbytes int) (uint64, uint64, offset) {
	switch nbytes {
	case 1:
		return uint64(p.buffer[off]), 0, off + offset(nbytes)
	case 2:
		return uint64(binary.BigEndian.Uint16(p.buffer[off:])), 0, off + offset(nbytes)
	case 4:
		return uint64(binary.BigEndian.Uint32(p.buffer[off:])), 0, off + offset(nbytes)
	case 8:
		return binary.BigEndian.Uint64(p.buffer[off:]), 0, off + offset(nbytes)
	case 16:
		return binary.BigEndian.Uint64(p.buffer[off+8:]), binary.BigEndian.Uint64(p.buffer[off:]), off + offset(nbytes)
	}
	panic(errors.New("illegal integer size"))
}

func (p *bplistParser) parseObjectRefAtOffset(off offset) (uint64, offset) {
	oid, _, next := p.parseSizedInteger(off, int(p.trailer.ObjectRefSize))
	return oid, next
}

func (p *bplistParser) parseOffsetAtOffset(off offset) (offset, offset) {
	parsedOffset, _, next := p.parseSizedInteger(off, int(p.trailer.OffsetIntSize))
	return offset(parsedOffset), next
}

func (p *bplistParser) objectAtIndex(index uint64) cfValue {
	if index >= p.trailer.NumObjects {
		panic(fmt.Errorf("invalid object#%d (max %d)", index, p.trailer.NumObjects))
	}

	if pval := p.objects[index]; pval != nil {
		return pval
	}

	off, _ := p.parseOffsetAtOffset(offset(p.trailer.OffsetTableOffset + (index * uint64(p.trailer.OffsetIntSize))))
	if off > offset(p.trailer.OffsetTableOffset-1) {
		panic(fmt.Errorf("object#%d starts beyond beginning of object table (0x%x, table@0x%x)", index, off, p.trailer.OffsetTableOffset))
	}

	pval := p.parseTagAtOffset(off)
	p.objects[index] = pval
	return pval

}

func (p *bplistParser) pushNestedObject(off offset) {
	for _, v := range p.containerStack {
		if v == off {
			p.panicNestedObject(off)
		}
	}
	p.containerStack = append(p.containerStack, off)
}

func (p *bplistParser) panicNestedObject(off offset) {
	ids := ""
	for _, v := range p.containerStack {
		ids += fmt.Sprintf("0x%x > ", v)
	}

	// %s0x%d: ids above ends with " > "
	panic(fmt.Errorf("self-referential collection@0x%x (%s0x%x) cannot be deserialized", off, ids, off))
}

func (p *bplistParser) popNestedObject() {
	p.containerStack = p.containerStack[:len(p.containerStack)-1]
}

func (p *bplistParser) parseTagAtOffset(off offset) cfValue {
	tag := p.buffer[off]

	switch tag & 0xF0 {
	case bpTagNull:
		switch tag & 0x0F {
		case bpTagBoolTrue, bpTagBoolFalse:
			return cfBoolean(tag == bpTagBoolTrue)
		}
	case bpTagInteger:
		lo, hi, _ := p.parseIntegerAtOffset(off)
		return &cfNumber{
			signed: hi == 0xFFFFFFFFFFFFFFFF, // a signed integer is stored as a 128-bit integer with the top 64 bits set
			value:  lo,
		}
	case bpTagReal:
		nbytes := 1 << (tag & 0x0F)
		switch nbytes {
		case 4:
			bits := binary.BigEndian.Uint32(p.buffer[off+1:])
			return &cfReal{wide: false, value: float64(math.Float32frombits(bits))}
		case 8:
			bits := binary.BigEndian.Uint64(p.buffer[off+1:])
			return &cfReal{wide: true, value: math.Float64frombits(bits)}
		}
		panic(errors.New("illegal float size"))
	case bpTagDate:
		bits := binary.BigEndian.Uint64(p.buffer[off+1:])
		val := math.Float64frombits(bits)

		// Apple Epoch is 20110101000000Z
		// Adjust for UNIX Time
		val += 978307200

		sec, fsec := math.Modf(val)
		time := time.Unix(int64(sec), int64(fsec*float64(time.Second))).In(time.UTC)
		return cfDate(time)
	case bpTagData:
		data := p.parseDataAtOffset(off)
		return cfData(data)
	case bpTagASCIIString:
		str := p.parseASCIIStringAtOffset(off)
		return cfString(str)
	case bpTagUTF16String:
		str := p.parseUTF16StringAtOffset(off)
		return cfString(str)
	case bpTagUID: // Somehow different than int: low half is nbytes - 1 instead of log2(nbytes)
		lo, _, _ := p.parseSizedInteger(off+1, int(tag&0xF)+1)
		return cfUID(lo)
	case bpTagDictionary:
		return p.parseDictionaryAtOffset(off)
	case bpTagArray:
		return p.parseArrayAtOffset(off)
	}
	panic(fmt.Errorf("unexpected atom 0x%2.02x at offset 0x%x", tag, off))
}

func (p *bplistParser) parseIntegerAtOffset(off offset) (uint64, uint64, offset) {
	tag := p.buffer[off]
	return p.parseSizedInteger(off+1, 1<<(tag&0xF))
}

func (p *bplistParser) countForTagAtOffset(off offset) (uint64, offset) {
	tag := p.buffer[off]
	cnt := uint64(tag & 0x0F)
	if cnt == 0xF {
		cnt, _, off = p.parseIntegerAtOffset(off + 1)
		return cnt, off
	}
	return cnt, off + 1
}

func (p *bplistParser) parseDataAtOffset(off offset) []byte {
	len, start := p.countForTagAtOffset(off)
	if start+offset(len) > offset(p.trailer.OffsetTableOffset) {
		panic(fmt.Errorf("data@0x%x too long (%v bytes, max is %v)", off, len, p.trailer.OffsetTableOffset-uint64(start)))
	}
	return p.buffer[start : start+offset(len)]
}

func (p *bplistParser) parseASCIIStringAtOffset(off offset) string {
	len, start := p.countForTagAtOffset(off)
	if start+offset(len) > offset(p.trailer.OffsetTableOffset) {
		panic(fmt.Errorf("ascii string@0x%x too long (%v bytes, max is %v)", off, len, p.trailer.OffsetTableOffset-uint64(start)))
	}

	return zeroCopy8BitString(p.buffer, int(start), int(len))
}

func (p *bplistParser) parseUTF16StringAtOffset(off offset) string {
	len, start := p.countForTagAtOffset(off)
	bytes := len * 2
	if start+offset(bytes) > offset(p.trailer.OffsetTableOffset) {
		panic(fmt.Errorf("utf16 string@0x%x too long (%v bytes, max is %v)", off, bytes, p.trailer.OffsetTableOffset-uint64(start)))
	}

	u16s := make([]uint16, len)
	for i := offset(0); i < offset(len); i++ {
		u16s[i] = binary.BigEndian.Uint16(p.buffer[start+(i*2):])
	}
	runes := utf16.Decode(u16s)
	return string(runes)
}

func (p *bplistParser) parseObjectListAtOffset(off offset, count uint64) []cfValue {
	if off+offset(count*uint64(p.trailer.ObjectRefSize)) > offset(p.trailer.OffsetTableOffset) {
		panic(fmt.Errorf("list@0x%x length (%v) puts its end beyond the offset table at 0x%x", off, count, p.trailer.OffsetTableOffset))
	}
	objects := make([]cfValue, count)

	next := off
	var oid uint64
	for i := uint64(0); i < count; i++ {
		oid, next = p.parseObjectRefAtOffset(next)
		objects[i] = p.objectAtIndex(oid)
	}

	return objects
}

func (p *bplistParser) parseDictionaryAtOffset(off offset) *cfDictionary {
	p.pushNestedObject(off)
	defer p.popNestedObject()

	// a dictionary is an object list of [key key key val val val]
	cnt, start := p.countForTagAtOffset(off)
	objects := p.parseObjectListAtOffset(start, cnt*2)

	keys := make([]string, cnt)
	for i := uint64(0); i < cnt; i++ {
		if str, ok := objects[i].(cfString); ok {
			keys[i] = string(str)
		} else {
			panic(fmt.Errorf("dictionary@0x%x contains non-string key at index %d", off, i))
		}
	}

	return &cfDictionary{
		keys:   keys,
		values: objects[cnt:],
	}
}

func (p *bplistParser) parseArrayAtOffset(off offset) *cfArray {
	p.pushNestedObject(off)
	defer p.popNestedObject()

	// an array is just an object list
	cnt, start := p.countForTagAtOffset(off)
	return &cfArray{p.parseObjectListAtOffset(start, cnt)}
}

func newBplistParser(r io.ReadSeeker) *bplistParser {
	return &bplistParser{reader: r}
}
