package ent

import (
	"fmt"

	"github.com/jordanorelli/hyperstone/bit"
	"github.com/jordanorelli/hyperstone/dota"
)

type tÿpe interface {
	read(bit.Reader) (value, error)
}

type typeFn func(bit.Reader) (value, error)

func (fn typeFn) read(r bit.Reader) (value, error) { return fn(r) }

type typeParseFn func(*typeSpec, *Env) tÿpe

func parseFieldType(flat *dota.ProtoFlattenedSerializerFieldT, env *Env) tÿpe {
	spec := new(typeSpec)
	spec.fromProto(flat, env)
	return parseTypeSpec(spec, env)
}

func parseTypeSpec(spec *typeSpec, env *Env) tÿpe {
	Debug.Printf("  parse spec: %v", spec)
	coalesce := func(fns ...typeParseFn) tÿpe {
		for _, fn := range fns {
			if t := fn(spec, env); t != nil {
				return t
			}
		}
		return nil
	}
	return coalesce(arrayType, atomType, floatType, handleType, qAngleType,
		hSeqType, genericType, vectorType, classType)
}

// a type error is both an error and a type. It represents a type that we were
// unable to correctly parse. It can be interpreted as an error or as a type;
// when interpreted as a type, it errors every time it tries to read a value.
func typeError(t string, args ...interface{}) tÿpe {
	Debug.Printf("  type error: %s", fmt.Sprintf(t, args...))
	return error_t(fmt.Sprintf(t, args...))
}

type error_t string

func (e error_t) Error() string { return string(e) }
func (e error_t) read(r bit.Reader) (value, error) {
	return nil, fmt.Errorf("type error: %s", string(e))
}

type typeSpec struct {
	name        string
	typeName    string
	bits        uint
	low         float32
	high        float32
	flags       int
	serializer  string
	serializerV int
	send        string
	encoder     string
}

func (s *typeSpec) fromProto(flat *dota.ProtoFlattenedSerializerFieldT, env *Env) {
	s.name = env.symbol(int(flat.GetVarNameSym()))
	s.typeName = env.symbol(int(flat.GetVarTypeSym()))
	if flat.GetBitCount() < 0 {
		// this would cause ridiculously long reads later if we let it overflow
		panic("negative bit count: data is likely corrupt")
	}
	s.bits = uint(flat.GetBitCount())
	s.low = flat.GetLowValue()
	s.high = flat.GetHighValue()
	s.flags = int(flat.GetEncodeFlags())
	if flat.FieldSerializerNameSym != nil {
		s.serializer = env.symbol(int(*flat.FieldSerializerNameSym))
	}
	s.serializerV = int(flat.GetFieldSerializerVersion())
	if flat.SendNodeSym != nil {
		s.send = env.symbol(int(*flat.SendNodeSym))
	}
	if flat.VarEncoderSym != nil {
		s.encoder = env.symbol(int(*flat.VarEncoderSym))
	}
}