/*
 * JBoss, Home of Professional Open Source.
 * Copyright 2014 Red Hat, Inc., and individual contributors
 * as indicated by the @author tags.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

package io.undertow.util;

import io.undertow.UndertowLogger;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * Represents a byte range for a range request
 *
 *
 * @author Stuart Douglas
 */
public class ByteRange {

    private final List<Range> ranges;

    public ByteRange(List<Range> ranges) {
        this.ranges = ranges;
    }

    public int getRanges() {
        return ranges.size();
    }

    /**
     * Gets the start of the specified range segment, of -1 if this is a suffix range segment
     * @param range The range segment to get
     * @return The range start
     */
    public long getStart(int range) {
        return ranges.get(range).getStart();
    }

    /**
     * Gets the end of the specified range segment, or the number of bytes if this is a suffix range segment
     * @param range The range segment to get
     * @return The range end
     */
    public long getEnd(int range) {
        return ranges.get(range).getEnd();
    }

    /**
     * Attempts to parse a range request. If the range request is invalid it will just return null so that
     * it may be ignored.
     *
     *
     * @param rangeHeader The range spec
     * @return A range spec, or null if the range header could not be parsed
     */
    public static ByteRange parse(String rangeHeader) {
        if(rangeHeader == null || rangeHeader.length() < 7) {
            return null;
        }
        if(!rangeHeader.startsWith("bytes=")) {
            return null;
        }
        List<Range> ranges = new ArrayList<>();
        String[] parts = rangeHeader.substring(6).split(",");
        for(String part : parts) {
            try {
                int index = part.indexOf('-');
                if (index == 0) {
                    //suffix range spec
                    //represents the last N bytes
                    //internally we represent this using a -1 as the start position
                    long val = Long.parseLong(part.substring(1));
                    if(val < 0) {
                        UndertowLogger.REQUEST_LOGGER.debugf("Invalid range spec %s", rangeHeader);
                        return null;
                    }
                    ranges.add(new Range(-1, val));
                } else {
                    if(index == -1) {
                        UndertowLogger.REQUEST_LOGGER.debugf("Invalid range spec %s", rangeHeader);
                        return null;
                    }
                    long start = Long.parseLong(part.substring(0, index));
                    if(start < 0) {
                        UndertowLogger.REQUEST_LOGGER.debugf("Invalid range spec %s", rangeHeader);
                        return null;
                    }
                    long end;
                    if (index + 1 < part.length()) {
                        end = Long.parseLong(part.substring(index + 1));
                    } else {
                        end = -1;
                    }
                    ranges.add(new Range(start, end));
                }
            } catch (NumberFormatException e) {
                UndertowLogger.REQUEST_LOGGER.debugf("Invalid range spec %s", rangeHeader);
                return null;
            }
        }
        if(ranges.isEmpty()) {
            return null;
        }
        return new ByteRange(ranges);
    }

    /**
     * Returns a representation of the range result. If this returns null then a 200 response should be sent instead
     * @param resourceContentLength
     * @return
     */
    public RangeResponseResult getResponseResult(final long resourceContentLength, String ifRange, Date lastModified, String eTag) {
        if(ranges.isEmpty()) {
            return null;
        }
        long start = getStart(0);
        long end = getEnd(0);
        long rangeLength;
        if(ifRange != null && !ifRange.isEmpty()) {
            if(ifRange.charAt(0) == '"') {
                //entity tag
                if(eTag != null && !eTag.equals(ifRange)) {
                    return null;
                }
            } else {
                Date ifDate = DateUtils.parseDate(ifRange);
                if(ifDate != null && lastModified != null && ifDate.getTime() < lastModified.getTime()) {
                    return null;
                }
            }
        }

        if(start == -1 ) {
            //suffix range
            if(end < 0){
                //ignore the range request
                return new RangeResponseResult(0, 0, 0, "bytes */" + resourceContentLength, StatusCodes.REQUEST_RANGE_NOT_SATISFIABLE);
            }
            start = Math.max(resourceContentLength - end, 0);
            end = resourceContentLength - 1;
            rangeLength = resourceContentLength - start;
        } else if(end == -1) {
            //prefix range
            long toWrite = resourceContentLength - start;
            if(toWrite >= 0) {
                rangeLength = toWrite;
            } else {
                //ignore the range request
                return new RangeResponseResult(0, 0, 0, "bytes */" + resourceContentLength, StatusCodes.REQUEST_RANGE_NOT_SATISFIABLE);
            }
            end = resourceContentLength - 1;
        } else {
            end = Math.min(end, resourceContentLength - 1);
            if(start >= resourceContentLength || start > end) {
                return new RangeResponseResult(0, 0, 0, "bytes */" + resourceContentLength, StatusCodes.REQUEST_RANGE_NOT_SATISFIABLE);
            }
            rangeLength = end - start + 1;
        }
        return new RangeResponseResult(start, end, rangeLength,  "bytes " + start + "-" + end + "/" + resourceContentLength, StatusCodes.PARTIAL_CONTENT);
    }

    public static class RangeResponseResult {
        private final long start;
        private final long end;
        private final long contentLength;
        private final String contentRange;
        private final int statusCode;

        public RangeResponseResult(long start, long end, long contentLength, String contentRange, int statusCode) {
            this.start = start;
            this.end = end;
            this.contentLength = contentLength;
            this.contentRange = contentRange;
            this.statusCode = statusCode;
        }

        public long getStart() {
            return start;
        }

        public long getEnd() {
            return end;
        }

        public long getContentLength() {
            return contentLength;
        }

        public String getContentRange() {
            return contentRange;
        }

        public int getStatusCode() {
            return statusCode;
        }
    }

    public static class Range {
        private final long start, end;

        public Range(long start, long end) {
            this.start = start;
            this.end = end;
        }

        public long getStart() {
            return start;
        }

        public long getEnd() {
            return end;
        }
    }
}
