package network // import "collectd.org/network"

import (
	"bytes"
	"encoding/binary"
	"errors"
	"fmt"
	"log"
	"time"

	"collectd.org/api"
	"collectd.org/cdtime"
)

// ErrInvalid is returned when parsing the network data was aborted due to
// illegal data format.
var ErrInvalid = errors.New("invalid data")

// ParseOpts holds confiruation options for "Parse()".
type ParseOpts struct {
	// PasswordLookup is used lookup passwords to verify signed data and
	// decrypt encrypted data.
	PasswordLookup PasswordLookup
	// SecurityLevel determines the minimum security level expected by the
	// caller. If set to "Sign", only signed and encrypted data is returned
	// by Parse(), if set to "Encrypt", only encrypted data is returned.
	SecurityLevel SecurityLevel
}

// Parse parses the binary network format and returns a slice of ValueLists. If
// a parse error is encountered, all ValueLists parsed to this point are
// returned as well as the error. Unknown "parts" are silently ignored.
func Parse(b []byte, opts ParseOpts) ([]api.ValueList, error) {
	return parse(b, None, opts)
}

func parse(b []byte, sl SecurityLevel, opts ParseOpts) ([]api.ValueList, error) {
	var valueLists []api.ValueList

	var state api.ValueList
	buf := bytes.NewBuffer(b)

	for buf.Len() > 0 {
		partType := binary.BigEndian.Uint16(buf.Next(2))
		partLength := int(binary.BigEndian.Uint16(buf.Next(2)))

		if partLength < 5 || partLength-4 > buf.Len() {
			return valueLists, fmt.Errorf("invalid length %d", partLength)
		}

		// First 4 bytes were already read
		partLength -= 4

		payload := buf.Next(partLength)
		if len(payload) != partLength {
			return valueLists, fmt.Errorf("invalid length: want %d, got %d", partLength, len(payload))
		}

		switch partType {
		case typeHost, typePlugin, typePluginInstance, typeType, typeTypeInstance:
			if err := parseIdentifier(partType, payload, &state); err != nil {
				return valueLists, err
			}

		case typeInterval, typeIntervalHR, typeTime, typeTimeHR:
			if err := parseTime(partType, payload, &state); err != nil {
				return valueLists, err
			}

		case typeValues:
			vl := state
			var err error
			if vl.Values, err = parseValues(payload); err != nil {
				return valueLists, err
			}
			if opts.SecurityLevel <= sl {
				valueLists = append(valueLists, vl)
			}

		case typeSignSHA256:
			vls, err := parseSignSHA256(payload, buf.Bytes(), opts)
			if err != nil {
				return valueLists, err
			}
			valueLists = append(valueLists, vls...)

		case typeEncryptAES256:
			vls, err := parseEncryptAES256(payload, opts)
			if err != nil {
				return valueLists, err
			}
			valueLists = append(valueLists, vls...)

		default:
			log.Printf("ignoring field of type %#x", partType)
		}
	}

	return valueLists, nil
}

func parseIdentifier(partType uint16, payload []byte, state *api.ValueList) error {
	str, err := parseString(payload)
	if err != nil {
		return err
	}

	switch partType {
	case typeHost:
		state.Identifier.Host = str
	case typePlugin:
		state.Identifier.Plugin = str
	case typePluginInstance:
		state.Identifier.PluginInstance = str
	case typeType:
		state.Identifier.Type = str
	case typeTypeInstance:
		state.Identifier.TypeInstance = str
	}

	return nil
}

func parseTime(partType uint16, payload []byte, state *api.ValueList) error {
	v, err := parseInt(payload)
	if err != nil {
		return err
	}

	switch partType {
	case typeInterval:
		state.Interval = time.Duration(v) * time.Second
	case typeIntervalHR:
		state.Interval = cdtime.Time(v).Duration()
	case typeTime:
		state.Time = time.Unix(int64(v), 0)
	case typeTimeHR:
		state.Time = cdtime.Time(v).Time()
	}

	return nil
}

func parseValues(b []byte) ([]api.Value, error) {
	buffer := bytes.NewBuffer(b)

	var n uint16
	if err := binary.Read(buffer, binary.BigEndian, &n); err != nil {
		return nil, err
	}

	if int(n*9) != buffer.Len() {
		return nil, ErrInvalid
	}

	types := make([]byte, n)
	values := make([]api.Value, n)

	if _, err := buffer.Read(types); err != nil {
		return nil, err
	}

	for i, typ := range types {
		switch typ {
		case dsTypeGauge:
			var v float64
			if err := binary.Read(buffer, binary.LittleEndian, &v); err != nil {
				return nil, err
			}
			values[i] = api.Gauge(v)

		case dsTypeDerive:
			var v int64
			if err := binary.Read(buffer, binary.BigEndian, &v); err != nil {
				return nil, err
			}
			values[i] = api.Derive(v)

		case dsTypeCounter:
			var v uint64
			if err := binary.Read(buffer, binary.BigEndian, &v); err != nil {
				return nil, err
			}
			values[i] = api.Counter(v)

		default:
			return nil, ErrInvalid
		}
	}

	return values, nil
}

func parseSignSHA256(pkg, payload []byte, opts ParseOpts) ([]api.ValueList, error) {
	ok, err := verifySHA256(pkg, payload, opts.PasswordLookup)
	if err != nil {
		return nil, err
	} else if !ok {
		return nil, errors.New("SHA256 verification failure")
	}

	return parse(payload, Sign, opts)
}

func parseEncryptAES256(payload []byte, opts ParseOpts) ([]api.ValueList, error) {
	plaintext, err := decryptAES256(payload, opts.PasswordLookup)
	if err != nil {
		return nil, errors.New("AES256 decryption failure")
	}

	return parse(plaintext, Encrypt, opts)
}

func parseInt(b []byte) (uint64, error) {
	if len(b) != 8 {
		return 0, ErrInvalid
	}

	var i uint64
	buf := bytes.NewBuffer(b)
	if err := binary.Read(buf, binary.BigEndian, &i); err != nil {
		return 0, err
	}

	return i, nil
}

func parseString(b []byte) (string, error) {
	if b[len(b)-1] != 0 {
		return "", ErrInvalid
	}

	buf := bytes.NewBuffer(b[:len(b)-1])
	return buf.String(), nil
}