codec

var DecodeCBOR Decoder = func(b []byte, options ...Option) (senml.Pack, error) {
	var p senml.Pack

	err := cbor.Unmarshal(b, &p)
	if err != nil {
		return nil, err
	}
	return p, nil
}

var DecodeCSV Decoder = func(b []byte, options ...Option) (senml.Pack, error) {

	p, err := ReadCSV(bytes.NewReader(b), options...)
	if err != nil {
		return nil, err
	}

	return p, nil
}

var DecodeJSON Decoder = func(b []byte, options ...Option) (senml.Pack, error) {
	var p senml.Pack

	err := json.Unmarshal(b, &p)
	if err != nil {
		return nil, err
	}
	return p, nil
}

var DecodeXML Decoder = func(b []byte, options ...Option) (senml.Pack, error) {
	var temp xmlPack
	err := xml.Unmarshal(b, &temp)
	if err != nil {
		return nil, err
	}
	return temp.Pack, nil
}

var EncodeCBOR Encoder = func(p senml.Pack, options ...Option) ([]byte, error) {

	return cbor.Marshal(p)
}

var EncodeCSV Encoder = func(p senml.Pack, options ...Option) ([]byte, error) {

	var buf bytes.Buffer
	err := WriteCSV(p, &buf, options...)
	if err != nil {
		return nil, err
	}
	return buf.Bytes(), nil
}

var EncodeJSON Encoder = func(p senml.Pack, options ...Option) ([]byte, error) {
	o := &codecOptions{
		prettyPrint: false,
	}
	for _, opt := range options {
		opt(o)
	}

	if o.prettyPrint {
		var buf bytes.Buffer
		buf.WriteString("[\n  ")
		for i, r := range p {
			if i != 0 {
				buf.WriteString(",\n  ")
			}
			recData, err := json.Marshal(r)
			if err != nil {
				return nil, err
			}
			buf.Write(recData)
		}
		buf.WriteString("\n]\n")
		return buf.Bytes(), nil
	}

	return json.Marshal(p)
}

var EncodeXML Encoder = func(p senml.Pack, options ...Option) ([]byte, error) {
	o := &codecOptions{
		prettyPrint: false,
	}
	for _, opt := range options {
		opt(o)
	}

	xmlPack := xmlPack{
		Pack:  p,
		XMLNS: "urn:ietf:params:xml:ns:senml",
	}

	if o.prettyPrint {
		return xml.MarshalIndent(&xmlPack, "", "  ")
	}

	return xml.Marshal(&xmlPack)
}

var ReadCSV Reader = func(r io.Reader, options ...Option) (senml.Pack, error) {
	o := &codecOptions{
		header: false,
	}
	for _, opt := range options {
		opt(o)
	}

	csvReader := csv.NewReader(r)

	if o.header {
		row, err := csvReader.Read()
		if err == io.EOF {
			return nil, fmt.Errorf("missing header or no input")
		}
		if err != nil {
			return nil, err
		}
		if joined := strings.Join(row, ","); joined != DefaultCSVHeader {
			return nil, fmt.Errorf("unexpected header: %s. Expected: %s", joined, DefaultCSVHeader)
		}
	}

	var p senml.Pack
	for {
		row, err := csvReader.Read()
		if err == io.EOF {
			break
		}
		if err != nil {
			return nil, err
		}

		var record senml.Record

		record.Time, err = strconv.ParseFloat(row[0], 10)
		if err != nil {
			return nil, err
		}

		record.UpdateTime, err = strconv.ParseFloat(row[1], 10)
		if err != nil {
			return nil, err
		}

		record.Name = row[2]

		record.Unit = row[3]

		if row[4] != "" {
			value, err := strconv.ParseFloat(row[4], 10)
			if err != nil {
				return nil, err
			}
			record.Value = &value
		}

		record.StringValue = row[5]

		if row[6] != "" {
			boolValue, err := strconv.ParseBool(row[6])
			if err != nil {
				return nil, err
			}
			record.BoolValue = &boolValue
		}

		record.DataValue = row[7]

		if row[8] != "" {
			sum, err := strconv.ParseFloat(row[8], 10)
			if err != nil {
				return nil, err
			}
			record.Sum = &sum
		}

		p = append(p, record)
	}

	return p, nil
}

var WriteCSV Writer = func(p senml.Pack, w io.Writer, options ...Option) error {
	o := &codecOptions{
		header: false,
	}
	for _, opt := range options {
		opt(o)
	}

	csvWriter := csv.NewWriter(w)

	if o.header {
		err := csvWriter.Write(strings.Split(DefaultCSVHeader, ","))
		if err != nil {
			return err
		}
	}

	p.Normalize()

	for i := range p {
		row := make([]string, 9)
		row[0] = strconv.FormatFloat(p[i].Time, 'f', -1, 64)
		row[1] = strconv.FormatFloat(p[i].UpdateTime, 'f', -1, 64)
		row[2] = p[i].Name
		row[3] = p[i].Unit
		if p[i].Value != nil {
			row[4] = strconv.FormatFloat(*p[i].Value, 'f', -1, 64)
		}
		row[5] = p[i].StringValue
		if p[i].BoolValue != nil {
			row[6] = fmt.Sprintf("%t", *p[i].BoolValue)
		}
		row[7] = p[i].DataValue
		if p[i].Sum != nil {
			row[8] = strconv.FormatFloat(*p[i].Sum, 'f', -1, 64)
		}

		err := csvWriter.Write(row)
		if err != nil {
			return err
		}
		csvWriter.Flush()
	}
	if err := csvWriter.Error(); err != nil {
		return err
	}
	return nil
}