package rest

import (
	"errors"
	"fmt"
	"net/http"
	"strconv"
	"strings"

	"github.com/rclone/rclone/fs"
)

// ContentRange is a parsed Content-Range response header.
type ContentRange struct {
	Start int64 // first byte position of the range
	End   int64 // last byte position of the range (inclusive)
	Size  int64 // complete length of the representation, or -1 if unknown
}

// ParseContentRange parses a Content-Range header of the form
// "bytes start-end/size" as returned with a ranged (206) response.
// The Size is -1 if the complete length is unknown ("*").
func ParseContentRange(value string) (ContentRange, error) {
	const prefix = "bytes "
	if !strings.HasPrefix(value, prefix) {
		return ContentRange{}, fmt.Errorf("doesn't start with %q", prefix)
	}

	rangeAndSize := strings.Split(value[len(prefix):], "/")
	if len(rangeAndSize) != 2 {
		return ContentRange{}, errors.New("must contain one '/'")
	}
	bounds := strings.Split(rangeAndSize[0], "-")
	if len(bounds) != 2 {
		return ContentRange{}, errors.New("must contain one '-'")
	}

	start, err := strconv.ParseInt(bounds[0], 10, 64)
	if err != nil || start < 0 {
		return ContentRange{}, errors.New("invalid start")
	}
	end, err := strconv.ParseInt(bounds[1], 10, 64)
	if err != nil || end < start {
		return ContentRange{}, errors.New("invalid end")
	}

	size := int64(-1)
	if rangeAndSize[1] != "*" {
		size, err = strconv.ParseInt(rangeAndSize[1], 10, 64)
		if err != nil || size < 0 || end >= size {
			return ContentRange{}, errors.New("invalid complete length")
		}
	}

	return ContentRange{Start: start, End: end, Size: size}, nil
}

// CheckContentRange checks that a response satisfies a Range open option.
// The size is the expected size of the complete representation, or -1 if it is
// unknown. Calls without a Range option are ignored.
func CheckContentRange(resp *http.Response, options []fs.OpenOption, size int64) error {
	var requestRange string
	for _, option := range options {
		key, value := option.Header()
		if strings.EqualFold(key, "Range") {
			requestRange = value
		}
	}
	if requestRange == "" {
		return nil
	}

	requested, err := fs.ParseRangeOption(requestRange)
	if err != nil {
		return fmt.Errorf("invalid requested range %q: %w", requestRange, err)
	}
	if requested.Start < 0 && requested.End < 0 {
		return fmt.Errorf("invalid requested range %q", requestRange)
	}
	if requested.Start >= 0 && requested.End >= 0 && requested.End < requested.Start {
		return fmt.Errorf("invalid requested range %q", requestRange)
	}
	if resp == nil {
		return errors.New("nil response to range request")
	}

	if resp.StatusCode == http.StatusOK {
		responseSize := size
		if resp.ContentLength >= 0 {
			if size >= 0 && resp.ContentLength != size {
				return fmt.Errorf("Content-Length %d does not match expected size %d", resp.ContentLength, size)
			}
			responseSize = resp.ContentLength
		}
		if responseSize >= 0 {
			offset, limit := requested.Decode(responseSize)
			if limit < 0 {
				limit = responseSize - offset
			}
			if offset == 0 && limit >= responseSize {
				return nil
			}
		} else if requested.Start == 0 && requested.End < 0 {
			return nil
		}
		return fmt.Errorf("%w %q", fs.ErrorRangeIgnored, requestRange)
	}
	if resp.StatusCode != http.StatusPartialContent {
		return fmt.Errorf("response status %d does not satisfy requested range %q", resp.StatusCode, requestRange)
	}

	responseRange := resp.Header.Get("Content-Range")
	got, err := ParseContentRange(responseRange)
	if err != nil {
		return fmt.Errorf("invalid Content-Range %q: %w", responseRange, err)
	}

	if size >= 0 && got.Size >= 0 && got.Size != size {
		return fmt.Errorf("Content-Range %q does not match expected size %d", responseRange, size)
	}

	rangeSize := size
	if rangeSize < 0 {
		rangeSize = got.Size
	}
	expectedStart := requested.Start
	expectedEnd := requested.End
	if requested.Start >= 0 {
		if rangeSize >= 0 && (expectedEnd < 0 || expectedEnd >= rangeSize) {
			expectedEnd = rangeSize - 1
		}
	} else if rangeSize >= 0 {
		expectedStart = max(rangeSize-requested.End, 0)
		expectedEnd = rangeSize - 1
	}

	var matches bool
	if requested.Start < 0 && rangeSize < 0 {
		matches = got.End-got.Start+1 <= requested.End
	} else {
		matches = got.Start == expectedStart
		if expectedEnd >= 0 {
			matches = matches && got.End == expectedEnd
		}
	}
	if !matches {
		return fmt.Errorf("Content-Range %q does not match requested range %q", responseRange, requestRange)
	}

	contentLength := got.End - got.Start + 1
	if contentLength <= 0 {
		return fmt.Errorf("invalid Content-Range %q: length overflows", responseRange)
	}
	if resp.ContentLength >= 0 && resp.ContentLength != contentLength {
		return fmt.Errorf("Content-Length %d does not match Content-Range %q", resp.ContentLength, responseRange)
	}
	return nil
}

// ParseSizeFromHeaders parses HTTP response headers to get the full file size.
// Returns -1 if the headers did not exist or were invalid.
func ParseSizeFromHeaders(headers http.Header) (size int64) {
	size = -1

	var contentLength = headers.Get("Content-Length")
	if len(contentLength) != 0 {
		var err error
		if size, err = strconv.ParseInt(contentLength, 10, 64); err != nil {
			return -1
		}
	}

	var contentRange = headers.Get("Content-Range")
	if len(contentRange) == 0 {
		return size
	}

	if !strings.HasPrefix(contentRange, "bytes ") {
		return -1
	}
	slash := strings.IndexRune(contentRange, '/')
	if slash < 0 {
		return -1
	}
	ret, err := strconv.ParseInt(contentRange[slash+1:], 10, 64)
	if err != nil {
		return -1
	}
	return ret
}