package data

import (
	"bufio"
	"encoding/binary"
	"fmt"
	"io"
	"io/ioutil"
	"os"
	"path/filepath"
	"strings"
)

type SpriteHeader struct {
	Unknown0  uint32
	Width     uint16 // FIXME: I'm not certain this is what these are.
	Height    uint16 // FIXME: If they are, they may be the wrong way around
	Padding1  uint32 // I don't think this is used. Could be wrong.
	PixelSize uint32 // Size of PixelData, excluding this sprite header
	Padding2  uint64 // I don't think this is used either. Could be wrong.
}

func (s SpriteHeader) Check(expectedSize uint32) error {
	if s.Padding1 != 0 || s.Padding2 != 0 {
		return fmt.Errorf("Sprite header padding contains unknown values: %d %d", s.Padding1, s.Padding2)
	}

	// Remove 24 bytes from passed-in size to account for the header
	if s.PixelSize != expectedSize-24 {
		return fmt.Errorf("Advertised pixel size: %d differs from expected: %v", s.PixelSize, expectedSize-24)
	}

	return nil
}

type Sprite struct {
	SpriteHeader

	Rows [][]byte
}

type dirEntry struct {
	Offset uint32 // Offset of the sprite relative to the data block
	Size   uint32 // Size of the sprite in bytes, including any header
}

func (d dirEntry) Check() error {
	if d.Size < 24 {
		return fmt.Errorf("Unexpected sprite size: %d (expected >= 24)", d.Size)
	}

	return nil
}

// ObjectHeader totals 24 bytes on disk
type ObjectHeader struct {
	NumSprites uint32 // How many sprites does this object have?
	DirOffset  uint32 // Offset of the directory block
	DirSize    uint32 // Size of the directory block. 8 * NumSprites
	DataOffset uint32 // Offset of the sprite data block
	DataSize   uint32 // Size of the sprite data block
}

func (h ObjectHeader) ExpectedDirSize() uint32 {
	return h.NumSprites * 8
}

func (h ObjectHeader) Check() error {
	// TODO: check for overlaps

	if h.ExpectedDirSize() != h.DirSize {
		return fmt.Errorf("Unexpected sprite directory size: %d (expected %d)", h.DirSize, h.ExpectedDirSize())
	}

	return nil
}

type Object struct {
	ObjectHeader

	Filename string
	Sprites  []*Sprite
}

func LoadObject(filename string) (*Object, error) {
	f, err := os.Open(filename)
	if err != nil {
		return nil, err
	}

	defer f.Close()

	out := &Object{Filename: filename}
	if err := binary.Read(f, binary.LittleEndian, &out.ObjectHeader); err != nil {
		return nil, fmt.Errorf("Reading object header: %v", err)
	}

	if err := out.ObjectHeader.Check(); err != nil {
		return nil, err
	}

	// Now load all sprites into memory
	dir := make([]dirEntry, out.NumSprites)
	if _, err := f.Seek(int64(out.DirOffset), io.SeekStart); err != nil {
		return nil, fmt.Errorf("Seeking to sprite directory: %v", err)
	}

	if err := binary.Read(f, binary.LittleEndian, &dir); err != nil {
		return nil, fmt.Errorf("Reading sprite directory: %v", err)
	}

	if _, err := f.Seek(int64(out.DataOffset), io.SeekStart); err != nil {
		return nil, fmt.Errorf("Seeking to sprites: %v", err)
	}

	for i, dirEntry := range dir {
		if err := dirEntry.Check(); err != nil {
			return nil, err
		}

		if _, err := f.Seek(int64(out.DataOffset+dirEntry.Offset), io.SeekStart); err != nil {
			return nil, fmt.Errorf("Seeking to sprite %v: %v", i, err)
		}

		sprite := &Sprite{}

		if err := binary.Read(f, binary.LittleEndian, &sprite.SpriteHeader); err != nil {
			return nil, fmt.Errorf("Reading sprite %v header: %v", i, err)
		}

		if err := sprite.Check(dirEntry.Size); err != nil {
			return nil, err
		}

		// The pixeldata seems to be formed of Y null-terminated records, with
		// varying numbers of bytes in each row. I don't know the internal
		// structure yet, but there's definitely working pixel data in there
		buf := bufio.NewReader(io.LimitReader(f, int64(sprite.PixelSize)))
		sprite.Rows = make([][]byte, sprite.Height)

		for y := 0; y < int(sprite.Height); y++ {
			if row, err := buf.ReadBytes(0x00); err != nil {
				return nil, fmt.Errorf("Reading row %v for sprite %v: %v", y, i, err)
			} else {
				sprite.Rows[y] = row
			}
		}

		out.Sprites = append(out.Sprites, sprite)
	}

	return out, nil
}

func LoadObjects(dir string) (map[string]*Object, error) {
	fis, err := ioutil.ReadDir(dir)
	if err != nil {
		return nil, err
	}

	out := make(map[string]*Object, len(fis))

	for _, fi := range fis {
		filename := filepath.Join(dir, fi.Name())
		basename := filepath.Base(filename)
		extname := filepath.Ext(filename)

		// Don't try to load non-.obj files
		if !strings.EqualFold(extname, ".obj") {
			continue
		}

		obj, err := LoadObject(filename)
		if err != nil {
			return nil, fmt.Errorf("%s: %v", filename, err)
		}

		out[basename] = obj
	}

	return out, nil
}