rtapi.go

package rtapi

// Written for 'pyed/rtelegram'.

import (
	"bytes"
	"encoding/base64"
	"encoding/xml"
	"errors"
	"fmt"
	"io"
	"math"
	"net"
	"net/url"
	"os"
	"strconv"
	"strings"
	"time"
)

const (
	// DefaultTimeout bounds each connection, request, and response lifecycle.
	DefaultTimeout = 30 * time.Second
	// DefaultMaxResponseSize bounds one SCGI response while allowing callers
	// with unusually large libraries to choose a larger explicit limit.
	DefaultMaxResponseSize int64 = 16 << 20
)

// ErrUnsafeDataDelete is returned because torrent paths belong to the rTorrent
// host and must never be deleted from the API client's filesystem.
var ErrUnsafeDataDelete = errors.New("rtapi: deleting torrent data is unsafe; delete it on the explicitly authorized rTorrent host")

const (
	Leeching = "Leeching"
	Seeding = "Seeding"
	Complete = "Complete"
	Stopped = "Stopped"
	Hashing = "Hashing"
	Error = "Error"
)

// Torrent represents a single torrent.
type Torrent struct {
	Name string
	Hash string
	DownRate uint64
	UpRate uint64
	Size uint64
	Completed uint64
	Percent string
	ETA uint64
	Ratio float64
	Age uint64
	UpTotal uint64
	State string
	Message string
	Tracker *url.URL
	Path string
	Label string // ruTorrent label
}

// Torrents is a slice of *Torrent.
type Torrents []*Torrent

type xmlrpcMethodCall struct {
	XMLName xml.Name `xml:"methodCall"`
	MethodName string `xml:"methodName"`
	Params []xmlrpcParam `xml:"params>param"`
}

type xmlrpcMethodResponse struct {
	XMLName xml.Name `xml:"methodResponse"`
	Params []xmlrpcParam `xml:"params>param"`
	Fault *xmlrpcFaultBody `xml:"fault"`
}

type xmlrpcFaultBody struct {
	Value xmlrpcValue `xml:"value"`
}

type xmlrpcParam struct {
	Value xmlrpcValue `xml:"value"`
}

type xmlrpcValue struct {
	String *string `xml:"string,omitempty"`
	Base64 *string `xml:"base64,omitempty"`
	Array *xmlrpcArray `xml:"array,omitempty"`
	Struct *xmlrpcStruct `xml:"struct,omitempty"`
	Int *int64 `xml:"int,omitempty"`
	I4 *int64 `xml:"i4,omitempty"`
	I8 *int64 `xml:"i8,omitempty"`
	Double *float64 `xml:"double,omitempty"`
	Boolean *bool `xml:"boolean,omitempty"`
	Text string `xml:",chardata"`
}

type xmlrpcArray struct {
	Values []xmlrpcValue `xml:"data>value"`
}

type xmlrpcStruct struct {
	Members []xmlrpcMember `xml:"member"`
}

type xmlrpcMember struct {
	Name string `xml:"name"`
	Value xmlrpcValue `xml:"value"`
}

func newStringParam(val string) xmlrpcParam {
	return xmlrpcParam{Value: newStringValue(val)}
}

func newBase64Param(val []byte) xmlrpcParam {
	v := base64.StdEncoding.EncodeToString(val)
	return xmlrpcParam{Value: xmlrpcValue{Base64: &v}}
}

func newStringValue(val string) xmlrpcValue {
	v := val
	return xmlrpcValue{String: &v}
}

func newArrayValue(values ...xmlrpcValue) xmlrpcValue {
	return xmlrpcValue{Array: &xmlrpcArray{Values: values}}
}

func newStructValue(members ...xmlrpcMember) xmlrpcValue {
	return xmlrpcValue{Struct: &xmlrpcStruct{Members: members}}
}

func newStringMember(name, val string) xmlrpcMember {
	return xmlrpcMember{Name: name, Value: newStringValue(val)}
}

func newArrayMember(name string, values ...xmlrpcValue) xmlrpcMember {
	return xmlrpcMember{Name: name, Value: newArrayValue(values...)}
}

func newMethodCall(method string, params ...string) xmlrpcValue {
	values := make([]xmlrpcValue, 0, len(params))
	for _, param := range params {
		values = append(values, newStringValue(param))
	}

	return newStructValue(
		newStringMember("methodName", method),
		newArrayMember("params", values...),
	)
}

// DotTorrentWithOptions controls the directory and ruTorrent label used when
// loading a torrent. Link is used by DownloadWithOptions; Name is caller metadata.
type DotTorrentWithOptions struct {
	Link string
	Name string
	Dir string
	Label string
}

// Rtorrent holds the network and address e.g.'tcp|localhost:5000' or 'unix|path/to/socket'.
type Rtorrent struct {
	network, address string
	Version string
	// Timeout bounds dialing, writing, and reading. Non-positive values use DefaultTimeout.
	Timeout time.Duration
	// MaxResponseSize bounds response bytes. Non-positive values use DefaultMaxResponseSize.
	MaxResponseSize int64
}

// NewRtorrent takes the address, defined in .rtorrent.rc
func NewRtorrent(address string) (*Rtorrent, error) {
	if strings.TrimSpace(address) == "" {
		return nil, fmt.Errorf("rtapi: address must not be empty")
	}

	network := "tcp"

	if _, err := os.Stat(address); err == nil {
		network = "unix"
	}

	rt := &Rtorrent{
		network: network,
		address: address,
		Timeout: DefaultTimeout,
		MaxResponseSize: DefaultMaxResponseSize,
	}

	ver, err := rt.getVersion()
	if err != nil {
		return nil, err
	}

	rt.Version = ver
	return rt, nil
}

func buildTorrentsRequest() (string, error) {
	fields := []string{
		"",
		"main",
		"d.name=",
		"d.hash=",
		"d.down.rate=",
		"d.up.rate=",
		"d.size_bytes=",
		"d.completed_bytes=",
		"d.ratio=",
		"d.up.total=",
		"d.load_date=",
		"d.message=",
		"d.base_path=",
		"d.is_active=",
		"d.connection_current=",
		"d.complete=",
		"d.hashing=",
		"d.custom1=",
	}

	params := make([]xmlrpcParam, 0, len(fields))
	for _, field := range fields {
		params = append(params, newStringParam(field))
	}

	request := xmlrpcMethodCall{
		MethodName: "d.multicall2",
		Params: params,
	}

	return marshalMethodCall(request)
}

func buildDownloadRequest(link string) (string, error) {
	request := xmlrpcMethodCall{
		MethodName: "load.start",
		Params: []xmlrpcParam{
			newStringParam(""),
			newStringParam(link),
		},
	}

	return marshalMethodCall(request)
}

func buildDownloadWithOptionsRequest(link, dir, label string) (string, error) {
	directory := "d.directory.set=" + strconv.Quote(dir)
	customLabel := "d.custom1.set=" + strconv.Quote(label)

	request := xmlrpcMethodCall{
		MethodName: "system.multicall",
		Params: []xmlrpcParam{
			{
				Value: newArrayValue(
					newMethodCall("load.start", "", link, directory, customLabel),
				),
			},
		},
	}

	return marshalMethodCall(request)
}

func buildDownloadRawRequest(data []byte, dir, label string, withOptions bool) (string, error) {
	params := []xmlrpcParam{newStringParam(""), newBase64Param(data)}
	if withOptions {
		params = append(params,
			newStringParam("d.directory.set="+strconv.Quote(dir)),
			newStringParam("d.custom1.set="+strconv.Quote(label)),
		)
	}

	return marshalMethodCall(xmlrpcMethodCall{
		MethodName: "load.raw_start",
		Params: params,
	})
}

func buildSystemMulticallRequest(method string, params ...string) (string, error) {
	calls := make([]xmlrpcValue, 0, len(params))
	for _, param := range params {
		calls = append(calls, newMethodCall(method, param))
	}

	request := xmlrpcMethodCall{
		MethodName: "system.multicall",
		Params: []xmlrpcParam{
			{
				Value: newArrayValue(calls...),
			},
		},
	}

	return marshalMethodCall(request)
}

func buildSpeedsRequest() (string, error) {
	request := xmlrpcMethodCall{
		MethodName: "system.multicall",
		Params: []xmlrpcParam{
			{
				Value: newArrayValue(
					newMethodCall("throttle.global_down.rate", ""),
					newMethodCall("throttle.global_up.rate", ""),
				),
			},
		},
	}

	return marshalMethodCall(request)
}

func buildStatsRequest() (string, error) {
	request := xmlrpcMethodCall{
		MethodName: "system.multicall",
		Params: []xmlrpcParam{
			{
				Value: newArrayValue(
					newMethodCall("throttle.up.max", "", ""),
					newMethodCall("throttle.down.max", "", ""),
					newMethodCall("throttle.global_up.total"),
					newMethodCall("throttle.global_down.total"),
					newMethodCall("network.listen.port"),
					newMethodCall("directory.default"),
				),
			},
		},
	}

	return marshalMethodCall(request)
}

func buildVersionRequest() (string, error) {
	request := xmlrpcMethodCall{
		MethodName: "system.multicall",
		Params: []xmlrpcParam{
			{
				Value: newArrayValue(
					newMethodCall("system.client_version", ""),
					newMethodCall("system.library_version", ""),
				),
			},
		},
	}

	return marshalMethodCall(request)
}

func marshalMethodCall(request xmlrpcMethodCall) (string, error) {
	payload, err := xml.Marshal(request)
	if err != nil {
		return "", err
	}

	return xml.Header + string(payload), nil
}

func decodeMethodResponse(r io.Reader, limit int64) (*xmlrpcMethodResponse, error) {
	if limit <= 0 {
		limit = DefaultMaxResponseSize
	}
	readLimit := limit
	if readLimit < math.MaxInt64 {
		readLimit++
	}
	payload, err := io.ReadAll(io.LimitReader(r, readLimit))
	if err != nil {
		return nil, fmt.Errorf("rtapi: read response: %w", err)
	}
	if int64(len(payload)) > limit {
		return nil, fmt.Errorf("rtapi: response exceeds %d bytes", limit)
	}

	start := bytes.Index(payload, []byte("<methodResponse"))
	if start == -1 {
		return nil, fmt.Errorf("rtapi: XML-RPC methodResponse not found")
	}

	payload = payload[start:]

	var resp xmlrpcMethodResponse
	if err := xml.Unmarshal(payload, &resp); err != nil {
		return nil, fmt.Errorf("rtapi: decode XML-RPC response: %w", err)
	}
	if resp.Fault != nil {
		fault, ok, err := faultFromValue(resp.Fault.Value)
		if err != nil {
			return nil, fmt.Errorf("rtapi: decode XML-RPC fault: %w", err)
		}
		if !ok {
			return nil, fmt.Errorf("rtapi: malformed XML-RPC fault")
		}
		return nil, fault
	}
	if len(resp.Params) == 0 {
		return nil, fmt.Errorf("rtapi: XML-RPC response missing params")
	}

	return &resp, nil
}

// XMLRPCFault is an error returned by rTorrent.
type XMLRPCFault struct {
	Code int64
	Message string
}

func (f *XMLRPCFault) Error() string {
	return fmt.Sprintf("rtapi: XML-RPC faultCode %d: faultString %q", f.Code, f.Message)
}

func faultFromValue(v xmlrpcValue) (*XMLRPCFault, bool, error) {
	if v.Struct == nil {
		return nil, false, nil
	}

	var fault XMLRPCFault
	var hasCode, hasMessage bool
	for _, member := range v.Struct.Members {
		switch member.Name {
		case "faultCode":
			code, err := member.Value.int64Value()
			if err != nil {
				return nil, true, fmt.Errorf("faultCode: %w", err)
			}
			fault.Code, hasCode = code, true
		case "faultString":
			message, err := member.Value.stringValue()
			if err != nil {
				return nil, true, fmt.Errorf("faultString: %w", err)
			}
			fault.Message, hasMessage = message, true
		}
	}

	if !hasCode && !hasMessage {
		return nil, false, nil
	}
	if !hasCode || !hasMessage {
		return nil, true, fmt.Errorf("fault is missing faultCode or faultString")
	}
	return &fault, true, nil
}

func (resp *xmlrpcMethodResponse) arrayParam() ([]xmlrpcValue, error) {
	if resp == nil || len(resp.Params) == 0 {
		return nil, fmt.Errorf("rtapi: xmlrpc response missing params")
	}

	array := resp.Params[0].Value.Array
	if array == nil {
		return nil, fmt.Errorf("rtapi: expected array value in response param")
	}

	return array.Values, nil
}

func (v xmlrpcValue) arrayValues() ([]xmlrpcValue, error) {
	if v.Array == nil {
		return nil, fmt.Errorf("rtapi: expected array value")
	}
	return v.Array.Values, nil
}

func (v xmlrpcValue) firstArrayValue() (xmlrpcValue, error) {
	values, err := v.arrayValues()
	if err != nil {
		return xmlrpcValue{}, err
	}
	if len(values) == 0 {
		return xmlrpcValue{}, fmt.Errorf("rtapi: expected value in array")
	}
	return values[0], nil
}

func (v xmlrpcValue) stringValue() (string, error) {
	if v.String != nil {
		return *v.String, nil
	}
	if v.Base64 == nil && v.Array == nil && v.Struct == nil && v.Int == nil &&
		v.I4 == nil && v.I8 == nil && v.Double == nil && v.Boolean == nil {
		return v.Text, nil
	}
	return "", fmt.Errorf("rtapi: expected string value")
}

func (v xmlrpcValue) int64Value() (int64, error) {
	switch {
	case v.I8 != nil:
		return *v.I8, nil
	case v.I4 != nil:
		return *v.I4, nil
	case v.Int != nil:
		return *v.Int, nil
	}
	return 0, fmt.Errorf("rtapi: expected integer value")
}

func (v xmlrpcValue) uint64Value() (uint64, error) {
	n, err := v.int64Value()
	if err != nil {
		return 0, err
	}
	if n < 0 {
		return 0, fmt.Errorf("rtapi: expected non-negative integer value")
	}
	return uint64(n), nil
}

func (r *Rtorrent) execute(req string) (*xmlrpcMethodResponse, error) {
	data := encode(req)
	conn, err := r.send(data)
	if err != nil {
		return nil, fmt.Errorf("rtapi: send request: %w", err)
	}
	defer conn.Close()

	return decodeMethodResponse(conn, r.MaxResponseSize)
}

func (r *Rtorrent) executeMulticall(req string, expected int) (*xmlrpcMethodResponse, error) {
	resp, err := r.execute(req)
	if err != nil {
		return nil, err
	}
	values, err := resp.arrayParam()
	if err != nil {
		return nil, err
	}
	for i, value := range values {
		fault, ok, err := faultFromValue(value)
		if err != nil {
			return nil, fmt.Errorf("rtapi: decode XML-RPC multicall item %d: %w", i, err)
		}
		if ok {
			return nil, fmt.Errorf("rtapi: XML-RPC multicall item %d: %w", i, fault)
		}
	}
	if len(values) != expected {
		return nil, fmt.Errorf("rtapi: expected %d XML-RPC multicall results, got %d", expected, len(values))
	}
	return resp, nil
}

// Torrents returns a slice that contains all the torrents.
func (r *Rtorrent) Torrents() (Torrents, error) {
	req, err := buildTorrentsRequest()
	if err != nil {
		return nil, err
	}

	resp, err := r.execute(req)
	if err != nil {
		return nil, err
	}

	values, err := resp.arrayParam()
	if err != nil {
		return nil, err
	}

	torrents := make(Torrents, 0, len(values))
	for _, torrentValue := range values {
		torrent, err := parseTorrent(torrentValue)
		if err != nil {
			return nil, err
		}
		torrents = append(torrents, torrent)
	}

	// set the Tracker field
	if err := r.getTrackers(torrents); err != nil {
		return nil, err
	}

	return torrents, nil
}

func parseTorrent(value xmlrpcValue) (*Torrent, error) {
	fields, err := value.arrayValues()
	if err != nil {
		return nil, fmt.Errorf("rtapi: parse torrent: %w", err)
	}

	const expectedFields = 16
	if len(fields) < expectedFields {
		return nil, fmt.Errorf("rtapi: expected %d torrent fields, got %d", expectedFields, len(fields))
	}

	t := new(Torrent)

	if t.Name, err = fields[0].stringValue(); err != nil {
		return nil, fmt.Errorf("rtapi: parse torrent name: %w", err)
	}
	if t.Hash, err = fields[1].stringValue(); err != nil {
		return nil, fmt.Errorf("rtapi: parse torrent hash: %w", err)
	}

	if t.DownRate, err = fields[2].uint64Value(); err != nil {
		return nil, fmt.Errorf("rtapi: parse torrent down rate: %w", err)
	}
	if t.UpRate, err = fields[3].uint64Value(); err != nil {
		return nil, fmt.Errorf("rtapi: parse torrent up rate: %w", err)
	}

	if t.Size, err = fields[4].uint64Value(); err != nil {
		return nil, fmt.Errorf("rtapi: parse torrent size: %w", err)
	}
	if t.Completed, err = fields[5].uint64Value(); err != nil {
		return nil, fmt.Errorf("rtapi: parse torrent completed bytes: %w", err)
	}
	ratioRaw, err := fields[6].uint64Value()
	if err != nil {
		return nil, fmt.Errorf("rtapi: parse torrent ratio: %w", err)
	}
	if t.UpTotal, err = fields[7].uint64Value(); err != nil {
		return nil, fmt.Errorf("rtapi: parse torrent uploaded bytes: %w", err)
	}
	t.Percent, t.ETA = calcPercentAndETA(t.Size, t.Completed, t.DownRate)
	t.Ratio = math.Round(float64(ratioRaw)/10) / 100

	if t.Age, err = fields[8].uint64Value(); err != nil {
		return nil, fmt.Errorf("rtapi: parse torrent age: %w", err)
	}
	if t.Message, err = fields[9].stringValue(); err != nil {
		return nil, fmt.Errorf("rtapi: parse torrent message: %w", err)
	}
	if t.Path, err = fields[10].stringValue(); err != nil {
		return nil, fmt.Errorf("rtapi: parse torrent path: %w", err)
	}

	isActive, err := fields[11].uint64Value()
	if err != nil {
		return nil, fmt.Errorf("rtapi: parse torrent active flag: %w", err)
	}
	connectionCurrent, err := fields[12].stringValue()
	if err != nil {
		return nil, fmt.Errorf("rtapi: parse torrent connection: %w", err)
	}
	complete, err := fields[13].uint64Value()
	if err != nil {
		return nil, fmt.Errorf("rtapi: parse torrent complete flag: %w", err)
	}
	hashing, err := fields[14].uint64Value()
	if err != nil {
		return nil, fmt.Errorf("rtapi: parse torrent hashing flag: %w", err)
	}
	if t.Label, err = fields[15].stringValue(); err != nil {
		return nil, fmt.Errorf("rtapi: parse torrent label: %w", err)
	}

	switch {
	case isActive == 1 && len(t.Message) != 0:
		t.State = Error
	case hashing != 0:
		t.State = Hashing
	case isActive == 1 && complete == 1:
		t.State = Seeding
	case isActive == 1 && connectionCurrent == "leech":
		t.State = Leeching
	case complete == 1:
		t.State = Complete
	default:
		t.State = Stopped
	}

	return t, nil
}

// GetTorrent takes a hash and returns *Torrent
func (r *Rtorrent) GetTorrent(hash string) (*Torrent, error) {
	if strings.TrimSpace(hash) == "" {
		return nil, fmt.Errorf("rtapi: torrent hash must not be empty")
	}
	torrents, err := r.Torrents()
	if err != nil {
		return nil, err
	}

	for i := range torrents {
		if torrents[i].Hash == hash {
			return torrents[i], nil
		}
	}
	return nil, fmt.Errorf("rtapi: no torrent with hash %q", hash)
}

// Download takes URL to a .torrent file to start downloading it.
func (r *Rtorrent) Download(url string) error {
	if strings.TrimSpace(url) == "" {
		return fmt.Errorf("rtapi: download URL must not be empty")
	}
	req, err := buildDownloadRequest(url)
	if err != nil {
		return fmt.Errorf("rtapi: build download request: %w", err)
	}
	if _, err := r.execute(req); err != nil {
		return fmt.Errorf("rtapi: download: %w", err)
	}
	return nil
}

// DownloadWithOptions takes *DotTorrentWithOptions downloading it.
func (r *Rtorrent) DownloadWithOptions(tFile *DotTorrentWithOptions) error {
	if tFile == nil {
		return fmt.Errorf("rtapi: torrent options must not be nil")
	}
	if strings.TrimSpace(tFile.Link) == "" {
		return fmt.Errorf("rtapi: download URL must not be empty")
	}

	dir := tFile.Dir
	if dir == "" {
		stats, err := r.Stats()
		if err != nil {
			return fmt.Errorf("rtapi: resolve default download directory: %w", err)
		}
		dir = stats.Directory
	}
	req, err := buildDownloadWithOptionsRequest(tFile.Link, dir, tFile.Label)
	if err != nil {
		return fmt.Errorf("rtapi: build download request: %w", err)
	}
	if _, err := r.executeMulticall(req, 1); err != nil {
		return fmt.Errorf("rtapi: download with options: %w", err)
	}
	return nil
}

// DownloadRaw loads torrent metadata without requiring rTorrent to fetch a URL.
func (r *Rtorrent) DownloadRaw(data []byte, options *DotTorrentWithOptions) error {
	if len(data) == 0 {
		return fmt.Errorf("rtapi: torrent data must not be empty")
	}

	var dir, label string
	if options != nil {
		dir, label = options.Dir, options.Label
		if dir == "" {
			stats, err := r.Stats()
			if err != nil {
				return fmt.Errorf("rtapi: resolve default download directory: %w", err)
			}
			dir = stats.Directory
		}
	}

	req, err := buildDownloadRawRequest(data, dir, label, options != nil)
	if err != nil {
		return fmt.Errorf("rtapi: build raw download request: %w", err)
	}
	if _, err := r.execute(req); err != nil {
		return fmt.Errorf("rtapi: raw download: %w", err)
	}
	return nil
}

func torrentHashes(ts []*Torrent) ([]string, error) {
	hashes := make([]string, len(ts))
	for i, torrent := range ts {
		if torrent == nil {
			return nil, fmt.Errorf("rtapi: torrent %d must not be nil", i)
		}
		if strings.TrimSpace(torrent.Hash) == "" {
			return nil, fmt.Errorf("rtapi: torrent %d hash must not be empty", i)
		}
		hashes[i] = torrent.Hash
	}
	return hashes, nil
}

func (r *Rtorrent) mutate(method string, ts ...*Torrent) error {
	hashes, err := torrentHashes(ts)
	if err != nil {
		return err
	}
	if len(hashes) == 0 {
		return nil
	}
	req, err := buildSystemMulticallRequest(method, hashes...)
	if err != nil {
		return fmt.Errorf("rtapi: build %s request: %w", method, err)
	}
	if _, err := r.executeMulticall(req, len(hashes)); err != nil {
		return fmt.Errorf("rtapi: %s: %w", method, err)
	}
	return nil
}

// Stop takes a *Torrent or more to 'd.stop' it/them.
func (r *Rtorrent) Stop(ts ...*Torrent) error {
	return r.mutate("d.stop", ts...)
}

// Start takes a *Torrent or more to 'd.start' it/them.
func (r *Rtorrent) Start(ts ...*Torrent) error {
	return r.mutate("d.start", ts...)
}

// Check takes a *Torrent or more to 'd.check_hash' it/them.
func (r *Rtorrent) Check(ts ...*Torrent) error {
	return r.mutate("d.check_hash", ts...)
}

// DeleteMetadata removes torrent metadata from rTorrent after validating the
// XML-RPC acknowledgement.
func (r *Rtorrent) DeleteMetadata(ts ...*Torrent) error {
	return r.mutate("d.erase", ts...)
}

// Delete removes torrents from rTorrent. Data deletion is deliberately rejected;
// callers must enforce filesystem ownership and containment on the rTorrent host.
// Deprecated: use DeleteMetadata to erase metadata explicitly.
func (r *Rtorrent) Delete(withData bool, ts ...*Torrent) error {
	if withData {
		return ErrUnsafeDataDelete
	}
	return r.DeleteMetadata(ts...)
}

// SpeedsWithError returns current Down/Up rates and preserves transport and RPC failures.
func (r *Rtorrent) SpeedsWithError() (down, up uint64, err error) {
	req, err := buildSpeedsRequest()
	if err != nil {
		return 0, 0, fmt.Errorf("rtapi: build speeds request: %w", err)
	}

	resp, err := r.executeMulticall(req, 2)
	if err != nil {
		return 0, 0, fmt.Errorf("rtapi: get speeds: %w", err)
	}

	values, err := resp.arrayParam()
	if err != nil {
		return 0, 0, err
	}

	if len(values) < 2 {
		return 0, 0, fmt.Errorf("rtapi: expected 2 speed values, got %d", len(values))
	}

	downVal, err := values[0].firstArrayValue()
	if err != nil {
		return 0, 0, fmt.Errorf("rtapi: parse download speed: %w", err)
	}
	upVal, err := values[1].firstArrayValue()
	if err != nil {
		return 0, 0, fmt.Errorf("rtapi: parse upload speed: %w", err)
	}

	down, err = downVal.uint64Value()
	if err != nil {
		return 0, 0, fmt.Errorf("rtapi: parse download speed: %w", err)
	}
	up, err = upVal.uint64Value()
	if err != nil {
		return 0, 0, fmt.Errorf("rtapi: parse upload speed: %w", err)
	}

	return down, up, nil
}

// Speeds returns current Down/Up rates.
// Deprecated: use SpeedsWithError so failures are not confused with idle rates.
func (r *Rtorrent) Speeds() (down, up uint64) {
	down, up, _ = r.SpeedsWithError()
	return down, up
}

// Stats describes rTorrent's aggregate transfer and listener state.
type Stats struct {
	ThrottleUp, ThrottleDown, TotalUp, TotalDown uint64
	Port, Directory string
}

// Stats returns aggregate rTorrent information.
func (r *Rtorrent) Stats() (*Stats, error) {
	st := new(Stats)
	req, err := buildStatsRequest()
	if err != nil {
		return nil, err
	}

	resp, err := r.executeMulticall(req, 6)
	if err != nil {
		return nil, err
	}

	values, err := resp.arrayParam()
	if err != nil {
		return nil, err
	}

	if len(values) < 6 {
		return nil, fmt.Errorf("rtapi: expected 6 stats values, got %d", len(values))
	}

	throttleUpVal, err := values[0].firstArrayValue()
	if err != nil {
		return nil, err
	}
	if st.ThrottleUp, err = throttleUpVal.uint64Value(); err != nil {
		return nil, err
	}

	throttleDownVal, err := values[1].firstArrayValue()
	if err != nil {
		return nil, err
	}
	if st.ThrottleDown, err = throttleDownVal.uint64Value(); err != nil {
		return nil, err
	}

	totalUpVal, err := values[2].firstArrayValue()
	if err != nil {
		return nil, err
	}
	if st.TotalUp, err = totalUpVal.uint64Value(); err != nil {
		return nil, err
	}

	totalDownVal, err := values[3].firstArrayValue()
	if err != nil {
		return nil, err
	}
	if st.TotalDown, err = totalDownVal.uint64Value(); err != nil {
		return nil, err
	}

	portVal, err := values[4].firstArrayValue()
	if err != nil {
		return nil, err
	}
	port, err := portVal.uint64Value()
	if err != nil {
		return nil, err
	}
	st.Port = fmt.Sprintf("%d", port)

	directoryVal, err := values[5].firstArrayValue()
	if err != nil {
		return nil, err
	}
	if st.Directory, err = directoryVal.stringValue(); err != nil {
		return nil, err
	}

	return st, nil
}

// getVersion returns a string represnts rtorrent/libtorrent versions.
func (r *Rtorrent) getVersion() (string, error) {
	req, err := buildVersionRequest()
	if err != nil {
		return "", err
	}

	resp, err := r.executeMulticall(req, 2)
	if err != nil {
		return "", err
	}

	values, err := resp.arrayParam()
	if err != nil {
		return "", err
	}

	if len(values) < 2 {
		return "", fmt.Errorf("rtapi: expected 2 version values, got %d", len(values))
	}

	clientVal, err := values[0].firstArrayValue()
	if err != nil {
		return "", err
	}
	clientVer, err := clientVal.stringValue()
	if err != nil {
		return "", err
	}

	libVal, err := values[1].firstArrayValue()
	if err != nil {
		return "", err
	}
	libraryVer, err := libVal.stringValue()
	if err != nil {
		return "", err
	}

	return fmt.Sprintf("%s/%s", clientVer, libraryVer), nil

}

// getTrackers takes Torrents and fill their tracker fields.
func (r *Rtorrent) getTrackers(ts Torrents) error {
	if len(ts) == 0 {
		return nil
	}

	keys := make([]string, len(ts))
	for i := range ts {
		keys[i] = ts[i].Hash + ":t0"
	}

	req, err := buildSystemMulticallRequest("t.url", keys...)
	if err != nil {
		return err
	}

	// Trackerless torrents can return a per-call missing-target fault for t.url.
	// Handle that expected absence locally while preserving every other fault.
	resp, err := r.execute(req)
	if err != nil {
		return err
	}

	values, err := resp.arrayParam()
	if err != nil {
		return err
	}

	if len(values) != len(ts) {
		return fmt.Errorf("rtapi: received %d trackers for %d torrents", len(values), len(ts))
	}

	for i, trackerValue := range values {
		if fault, ok, err := faultFromValue(trackerValue); err != nil {
			return fmt.Errorf("rtapi: decode tracker %d fault: %w", i, err)
		} else if ok {
			message := strings.ToLower(fault.Message)
			missing := fault.Code == -501 &&
				(strings.Contains(message, "info-hash") ||
					strings.Contains(message, "could not find tracker") || strings.Contains(message, "no tracker"))
			if missing {
				continue
			}
			return fmt.Errorf("rtapi: get tracker %d: %w", i, fault)
		}

		trackerValues, err := trackerValue.arrayValues()
		if err != nil {
			return err
		}

		var trackerStr string
		if len(trackerValues) > 0 {
			trackerStr, err = trackerValues[0].stringValue()
			if err != nil {
				return err
			}
		}

		if trackerStr == "" {
			continue
		}
		trackerURL, err := url.Parse(trackerStr)
		if err != nil {
			return fmt.Errorf("rtapi: parse tracker url: %w", err)
		}
		ts[i].Tracker = trackerURL
	}

	return nil
}

// calcPercentAndETA takes size, size done, down rate to calculate the percenage + ETA.
func calcPercentAndETA(size, done, downrate uint64) (string, uint64) {
	if size == 0 || done >= size {
		return "100%", 0
	}

	percentage := float64(done) / float64(size) * 100
	rounded := math.Round(percentage*10) / 10
	if rounded >= 100 {
		rounded = 99.9
	}

	var ETA uint64
	if downrate > 0 {
		remaining := size - done
		ETA = remaining / downrate
		if remaining%downrate != 0 {
			ETA++
		}
	}

	return fmt.Sprintf("%.1f%%", rounded), ETA
}

// send takes scgi formated data and returns net.Conn
func (r *Rtorrent) send(data []byte) (net.Conn, error) {
	if r == nil {
		return nil, fmt.Errorf("nil rTorrent client")
	}
	timeout := r.Timeout
	if timeout <= 0 {
		timeout = DefaultTimeout
	}

	conn, err := (&net.Dialer{Timeout: timeout}).Dial(r.network, r.address)
	if err != nil {
		return nil, fmt.Errorf("dial %s %q: %w", r.network, r.address, err)
	}
	if err := conn.SetDeadline(time.Now().Add(timeout)); err != nil {
		conn.Close()
		return nil, fmt.Errorf("set connection deadline: %w", err)
	}

	written, err := writeAll(conn, data)
	if err != nil {
		conn.Close()
		return nil, fmt.Errorf("write SCGI request after %d of %d bytes: %w", written, len(data), err)
	}
	if written != len(data) {
		conn.Close()
		return nil, fmt.Errorf("write SCGI request: wrote %d of %d bytes", written, len(data))
	}

	return conn, nil
}

func writeAll(w io.Writer, data []byte) (int, error) {
	written := 0
	for len(data) > 0 {
		n, err := w.Write(data)
		if n < 0 || n > len(data) {
			return written, fmt.Errorf("invalid write count %d", n)
		}
		written += n
		data = data[n:]
		if err != nil {
			return written, err
		}
		if n == 0 {
			return written, io.ErrNoProgress
		}
	}
	return written, nil
}

// encode puts the data in scgi format.
func encode(data string) []byte {
	headers := fmt.Sprintf("CONTENT_LENGTH%c%d%cSCGI%c1%c", 0, len(data), 0, 0, 0)
	headers = fmt.Sprintf("%d:%s,", len(headers), headers)
	return []byte(headers + data)
}