package api

import (
	"math"
	"strconv"
	"strings"
	"time"
)

// What the download client is doing with something somebody asked for, normalised into the
// few words a viewer can act on.
//
// The whole point of this file is that the television is never told about indexers, release
// profiles, trackers or import queues. Radarr and Sonarr describe one download in three
// overlapping vocabularies — see radarr.QueueItem — and between them they can produce
// something like twenty distinct states. A viewer standing in front of a card needs to know
// one of five things: nothing has been found yet, something has been found, it is coming
// down and how far through it is, it is being filed away, or it went wrong.
//
// Everything here is pure, because it is the half of the feature that has to be right and
// the half that is cheapest to be wrong about: an ETA is a promise, and a promise made from
// a misread field is worse than no promise at all.

// requestWork is one row of a download queue with the *arr it came from forgotten.
//
// Keeping it free of radarr and sonarr types is what lets one rule answer for both — a film
// and a season of a show are the same question about bytes — and lets the rule be tested
// without either service.
type requestWork struct {
	// Size and SizeLeft are bytes. Both zero means the client has not said, which is
	// different from a finished download and must not read as 100%.
	Size     float64
	SizeLeft float64
	// TimeLeft is the download client's own estimate as a .NET TimeSpan ("00:14:32",
	// "1.02:03:04"), or empty when it will not say — which is the ordinary case for a
	// queued or stalled item and exactly where an ETA must not be manufactured.
	TimeLeft string
	// Status is the download client's word, TrackedState is what the *arr will do with the
	// bytes once they land, and TrackedStatus is the verdict over both.
	Status        string
	TrackedState  string
	TrackedStatus string
}

// requestProgress is the normalised answer, and it is deliberately the shape of the wire.
//
// Progress and EstimatedReadySeconds are both zero when unknown, which is why they are
// omitempty on the response types that embed this: a card draws a figure it was given and
// says nothing at all when it was given none. Zero percent and "we have no idea" therefore
// look the same to the television, which is the correct conflation — neither is a number
// worth printing.
type requestProgress struct {
	// Status is one of the request status slugs below, or empty when the queue had nothing
	// to say about this title at all.
	Status string
	// Progress is whole percent, 0-100.
	Progress int
	// EstimatedReadySeconds is how long until the bytes have landed. It never includes the
	// import that follows, because nothing measures that — see requestStatusDetail, where
	// "a few minutes" is wording rather than an estimate.
	EstimatedReadySeconds int
}

// Download-client states, in the order a request passes through them. These sit alongside
// the states in requests_status.go and share its vocabulary space; they are separate only
// because these four are the ones a queue can answer for.
const (
	// RequestStatusSearching means monitored, released, nothing found yet — the honest
	// reading of "the *arr holds this and the download client has never heard of it".
	RequestStatusSearching = "searching"
	// RequestStatusFound means a release has been grabbed and is waiting on the download
	// client: queued, paused, held by a delay profile. There is something to wait for, but
	// no bytes are moving.
	RequestStatusFound = "found"
	// RequestStatusDownloading means bytes are moving. This is the only state that carries
	// a percentage.
	RequestStatusDownloading = "downloading"
	// RequestStatusFailed means the download failed and the *arr will look for another
	// release. Deliberately not a dead end: it is the one state whose wording has to say
	// that Memby is still trying.
	RequestStatusFailed = "failed"
)

// workState is the per-row rule, and the order of its tests is the whole of it.
//
// A verdict of error outranks everything, because a row can look perfectly healthy —
// "completed", even — while the *arr has decided it cannot use what arrived. Importing
// outranks downloading next, since a row that has finished downloading is still reported by
// some clients with a downloading-ish status while the *arr moves the file. Only then does
// the download client's own word matter, and anything it says that is not "downloading" is
// a wait of some kind, which is what "found" means.
//
// A word this build has never seen falls through to found rather than to failed: a new
// vocabulary in a future Radarr must degrade to "something is happening" rather than
// telling a viewer their film is broken.
func workState(w requestWork) string {
	status := strings.ToLower(strings.TrimSpace(w.Status))
	tracked := strings.ToLower(strings.TrimSpace(w.TrackedState))
	verdict := strings.ToLower(strings.TrimSpace(w.TrackedStatus))
	switch {
	case verdict == "error", status == "failed", tracked == "failed", tracked == "failedpending":
		return RequestStatusFailed
	case tracked == "importpending", tracked == "importing", tracked == "imported",
		status == "completed":
		return RequestStatusProcessing
	case status == "downloading":
		return RequestStatusDownloading
	default:
		return RequestStatusFound
	}
}

// workRank orders the states by how much they deserve to be what a card says when one title
// has several rows — a season pack is a dozen episodes at a dozen different stages.
//
// Highest wins, and the ordering is "what is the most active thing happening to this": a
// show with one episode downloading and eleven already filed is downloading. Failed is
// lowest, so a single failed episode never overrides eleven healthy ones and a title only
// reads as failed when every row of it has.
func workRank(status string) int {
	switch status {
	case RequestStatusDownloading:
		return 4
	case RequestStatusFound:
		return 3
	case RequestStatusProcessing:
		return 2
	case RequestStatusFailed:
		return 1
	default:
		return 0
	}
}

// downloadProgress folds a title's queue rows into one answer.
//
// No rows is not an error and not a state: it is the caller's question to answer, since
// "nothing is downloading" means something different for a film that is already in the
// library, one nobody has released yet, and one the *arr has been searching for all
// afternoon. So this returns an empty status and requestStatusFor decides.
func downloadProgress(work []requestWork) requestProgress {
	if len(work) == 0 {
		return requestProgress{}
	}

	var (
		best      string
		totalSize float64
		totalLeft float64
		// eta is the longest remaining time across the rows that have not landed yet: a
		// season is ready when its slowest episode is, not its fastest.
		eta time.Duration
		// etaKnown starts true and is cleared by the first unfinished row that will not say.
		// One silent row makes the total unknowable, and reporting the rest of the pack's
		// time as the whole pack's would be an ETA that quietly expires and keeps going.
		etaKnown = true
	)
	for _, row := range work {
		state := workState(row)
		if workRank(state) > workRank(best) {
			best = state
		}
		if row.Size > 0 {
			totalSize += row.Size
			totalLeft += math.Min(math.Max(row.SizeLeft, 0), row.Size)
		}
		switch state {
		case RequestStatusDownloading, RequestStatusFound:
			remaining, ok := parseTimeLeft(row.TimeLeft)
			if !ok {
				etaKnown = false
				continue
			}
			if remaining > eta {
				eta = remaining
			}
		}
	}

	progress := requestProgress{Status: best}
	if totalSize > 0 {
		done := (totalSize - totalLeft) / totalSize * 100
		progress.Progress = int(math.Round(math.Min(math.Max(done, 0), 100)))
	}
	// An estimate is only ever offered against moving bytes. A queue that is paused or
	// waiting on a delay profile has a "time left" only in the sense that the download
	// client is guessing, and an import has no measured duration at all.
	if etaKnown && eta > 0 && best == RequestStatusDownloading {
		progress.EstimatedReadySeconds = int(math.Round(eta.Seconds()))
	}
	return progress
}

// parseTimeLeft reads the .NET TimeSpan the *arrs send: "hh:mm:ss", with an optional
// "d." day part in front and an optional fractional-seconds part behind.
//
// It refuses anything it cannot read completely rather than salvaging a number from part of
// it. This is the one input that becomes a promise to a viewer, and a misparse here is how
// "ready in 14 minutes" becomes "ready in 14 hours".
func parseTimeLeft(value string) (time.Duration, bool) {
	value = strings.TrimSpace(value)
	if value == "" {
		return 0, false
	}
	days := 0
	// A day part is separated by a full stop, and so is a fractional second — so a leading
	// "d." only exists when what follows still holds two colons.
	if dot := strings.Index(value, "."); dot > 0 && strings.Count(value[dot+1:], ":") == 2 {
		parsed, err := strconv.Atoi(value[:dot])
		if err != nil || parsed < 0 {
			return 0, false
		}
		days = parsed
		value = value[dot+1:]
	}
	if dot := strings.Index(value, "."); dot >= 0 {
		value = value[:dot] // drop fractional seconds; nobody counts a film in milliseconds
	}
	parts := strings.Split(value, ":")
	if len(parts) != 3 {
		return 0, false
	}
	units := []time.Duration{time.Hour, time.Minute, time.Second}
	total := time.Duration(days) * 24 * time.Hour
	for index, part := range parts {
		number, err := strconv.Atoi(strings.TrimSpace(part))
		if err != nil || number < 0 {
			return 0, false
		}
		total += time.Duration(number) * units[index]
	}
	return total, true
}

// estimatedReadyLabel is the second half of the download line: the sentence under
// "Downloading - 68%".
//
// It is worded in the coarsest unit that is still useful, because the precision the
// download client reports is not precision anybody has: a client that says 14 minutes 3
// seconds is guessing at the minutes, so printing the seconds claims an accuracy the number
// does not have. An estimate of zero is not an estimate and produces nothing at all, which
// is what makes "we will let you know when it is ready" reachable.
func estimatedReadyLabel(seconds int) string {
	if seconds <= 0 {
		return ""
	}
	remaining := time.Duration(seconds) * time.Second
	switch {
	case remaining < 90*time.Second:
		return "Estimated ready in under a minute"
	case remaining < time.Hour:
		return "Estimated ready in ~" + strconv.Itoa(int(math.Round(remaining.Minutes()))) + " minutes"
	case remaining < 2*time.Hour:
		return "Estimated ready in about an hour"
	case remaining < 24*time.Hour:
		return "Estimated ready in ~" + strconv.Itoa(int(remaining.Hours())) + " hours"
	default:
		// Past a day the number stops being an estimate and starts being a warning that
		// something is wrong with the release, so it is deliberately vague.
		return "Estimated ready in over a day"
	}
}