types

var (
	ErrWrongLength = errors.New("length must be 32")
	ErrInvalidSign = errors.New("big int sign must be 0 or 1")
)

var BigIntConverter = options.NamedBytesConverter("BigInt",
	func(b []byte) (big.Int, error) {
		if len(b) == 0 {
			return *big.NewInt(0), nil
		}
		var negative bool
		switch b[0] {
		case 0:
			negative = false
		case 1:
			negative = true
		default:
			return *big.NewInt(0), ErrInvalidSign
		}
		n := big.NewInt(0).SetBytes(b[1:])
		if negative {
			n.Neg(n)
		}
		return *n, nil
	},
	func(n big.Int) ([]byte, error) {
		switch {
		case n.Sign() > 0:
			return append([]byte{0}, n.Bytes()...), nil
		case n.Sign() < 0:
			return append([]byte{1}, n.Bytes()...), nil
		default:
			return []byte{0}, nil
		}
	})

var Converters = []bindnode.Option{
	MultiaddrConverter,
	HasMultihashConverter,
	DIDConverter,
	URLConverter,
	HTTPHeaderConverter,
	Version1LinkConverter,
	PieceLinkConverter,
	MerkleNodeConverter,
	ISO8601DateConverter,
	UnixTimeMilliConverter,
	BigIntConverter,
}

var DIDConverter = options.NamedBytesConverter("DID", func(bytes []byte) (did.DID, error) {
	if len(bytes) == 0 {
		return did.Undef, nil
	}
	return did.Decode(bytes)
}, func(did did.DID) ([]byte, error) { return did.Bytes(), nil })

var HTTPHeaderConverter = options.NamedAnyConverter("HTTPHeaders", nodeToHeader, headerToNode)

var HasMultihashConverter = options.NamedAnyConverter("HasMultihash", func(nd datamodel.Node) (HasMultihash, error) {
	return linkOrDigest.Read(nd)
}, func(h HasMultihash) (datamodel.Node, error) {
	return h.ToIPLD()
})

var ISO8601DateConverter = options.NamedStringConverter("ISO8601Date",
	func(s string) (time.Time, error) {
		return time.Parse(time.RFC3339, s)
	},
	func(t time.Time) (string, error) {
		return t.Format(time.RFC3339), nil
	})

var MerkleNodeConverter = options.NamedBytesConverter("MerkleNode", func(b []byte) (merkletree.Node, error) {
	if len(b) != len(merkletree.Node{}) {
		return merkletree.Node{}, ErrWrongLength
	}
	return *(*merkletree.Node)(b), nil
}, func(n merkletree.Node) ([]byte, error) {
	return n[:], nil
})

var MultiaddrConverter = options.NamedBytesConverter("Multiaddr", multiaddr.NewMultiaddrBytes, func(m multiaddr.Multiaddr) ([]byte, error) {
	return m.Bytes(), nil
})

var PieceLinkConverter = options.NamedLinkConverter("PieceLink", func(c cid.Cid) (piece.PieceLink, error) {
	return piece.FromLink(cidlink.Link{Cid: c})
}, func(p piece.PieceLink) (cid.Cid, error) {
	return p.Link().(cidlink.Link).Cid, nil
})

var URLConverter = options.NamedStringConverter("URL",
	func(s string) (url.URL, error) { return schema.URI().Read(s) },
	func(url url.URL) (string, error) { return url.String(), nil })

var UnixTimeMilliConverter = options.NamedIntConverter("UnixTimeMilli",
	func(millis int64) (time.Time, error) {
		return time.UnixMilli(millis), nil
	},
	func(t time.Time) (int64, error) {
		return t.UnixMilli(), nil
	})

var Version1LinkConverter = options.NamedLinkConverter("V1Link", func(c cid.Cid) (ipld.Link, error) {
	return schema.Link(schema.WithVersion(1)).Read(cidlink.Link{Cid: c})
}, func(link ipld.Link) (cid.Cid, error) {
	cl, ok := link.(cidlink.Link)
	if !ok {
		return cid.Undef, errors.New("unsupported link type")
	}
	return cl.Cid, nil
})