package data

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

var (
	// FIXME: My poor understanding of the .obj format prevents me from
	// successfully loading these files
	objBlacklist = []string{
		/* Lots of unexpected magic values, disable the check for now
		"15_rocks.obj", // Unexpected magic value: 19726564 (expected 21102801)
		"2_cath.obj",   // Unexpected magic value: 21364973 (expected 21102801)
		"2nd_flor.obj", // Unexpected magic value: 22151377 (expected 21102801)
		"3_cath.obj",   // Unexpected magic value: 21102809 (expected 21102801)
		"4_cath.obj",   // Unexpected magic value: 21496017 (expected 21102801)
		"BODIES.obj",   // Unexpected magic value: 21627103 (expected 21102801)
		"BRDG_TIL.OBJ", // Unexpected magic value: 17957074 (expected 21102801)
		"Cheveron.obj", // Unexpected magic value: 10879118 (expected 21102801)

		"Heavy_Plasma_Effect.obj",      // Unexpected magic value: 14811345 (expected 21102801)
		"Heavy_Plasma_Mask.obj",        // Unexpected magic value: 14811345 (expected 21102801)
		"Heavy_Plasma_Pain_Effect.obj", // Unexpected magic value: 14811345 (expected 21102801)
		"Heavy_Plasma_Pain_Mask.obj",   // Unexpected magic value: 14811345 (expected 21102801)

		"Ht_drt.obj", // Unexpected magic value: 22806737 (expected 21102801)
		"Ht_grs.obj", // Unexpected magic value: 22806737 (expected 21102801)

		"IVY02.OBJ", // Unexpected magic value: 18481399 (expected 21102801)
		"J_top2.obj", // Unexpected magic value: 22347993 (expected 21102801)

		"Lascannon_Effect.obj", // Unexpected magic value: 14811345 (expected 21102801)
		"Lascannon_Mask.obj",   // Unexpected magic value: 14811345 (expected 21102801)
		"Lascannon_Pain_Effect.obj", // Unexpected magic value: 14811345 (expected 21102801)
		"Lascannon_Pain_Mask.obj", // Unexpected magic value: 14811136 (expected 21102801)

		"Man_Shadow.obj", // Unexpected magic value: 22479091 (expected 21102801)

		"Melta_Effect.obj", // Unexpected magic value: 14745777 (expected 21102801)
		"Melta_Mask.obj", // Unexpected magic value: 14811345 (expected 21102801)
		"Melta_Pain_Effect.obj", // Unexpected magic value: 14745777 (expected 21102801)
		"Melta_Pain_Mask.obj", // Unexpected magic value: 14811345 (expected 21102801)

		"Multi_Melta_Effect.obj",
		"Multi_Melta_Mask.obj",
		"Multi_Melta_Pain_Effect.obj",
		"Multi_Melta_Pain_Mask.obj",

		"Plasma_Effect.obj",      // Unexpected magic value: 14811345 (expected 21102801)
		"Plasma_Mask.obj",        // Unexpected magic value: 14811345 (expected 21102801)
		"Plasma_Pain_Effect.obj", // Unexpected magic value: 14811345 (expected 21102801)
		"Plasma_Pain_Mask.obj",   // Unexpected magic value: 14811345 (expected 21102801)

		"TZEENTCH.OBJ", // Unexpected magic value: 18088209 (expected 21102801)

		"altar.obj", // Unexpected magic value: 18219222 (expected 21102801)
		*/

		"j_tree2.obj", // ObjectHeader is completely empty
		"inven.obj",   // Main header padding contains unknown values: [134744072 134744072 134744072]
	}
)

func init() {
	sort.Strings(objBlacklist)
}

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

	PixelData []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, 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, err
	}

	if err := binary.Read(f, binary.LittleEndian, &dir); err != nil {
		return nil, err
	}

	if _, err := f.Seek(int64(out.DataOffset), io.SeekStart); err != nil {
		return nil, err
	}

	// FIXME: this might - *might* - load interstitial data we don't really
	// need, so wasting memory.
	data, err := ioutil.ReadAll(f)
	if err != nil {
		return nil, err
	}

	buf := bytes.NewReader(data)

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

		if _, err := buf.Seek(int64(dirEntry.Offset), io.SeekStart); err != nil {
			return nil, err
		}

		sprite := &Sprite{}

		if err := binary.Read(buf, binary.LittleEndian, &sprite.SpriteHeader); err != nil {
			return nil, err
		}

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

		// It's safe to assume that a `bytes.Reader` will always satisfy the
		// requested read size.
		sprite.PixelData = make([]byte, sprite.PixelSize)
		if _, err := buf.Read(sprite.PixelData); err != nil {
			return nil, err
		}

		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
		}

		i := sort.SearchStrings(objBlacklist, basename)
		if i >= len(objBlacklist) || objBlacklist[i] == basename {
			continue
		}

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

		out[basename] = obj
	}

	return out, nil
}