/*
 * Copyright (c) 2007, 2017 Oracle and/or its affiliates. All rights reserved.
 * Copyright 2004 The Apache Software Foundation
 *
 * 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 org.glassfish.grizzly.http.util;

import java.io.UnsupportedEncodingException;
import java.text.DateFormat;
import java.text.FieldPosition;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
import java.util.TimeZone;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.atomic.AtomicBoolean;

import static org.glassfish.grizzly.http.util.HttpCodecUtils.*;
import org.glassfish.grizzly.utils.Charsets;

Utility class to generate HTTP dates.
Author:
Gustav Trede, Remy Maucherat/**
 * Utility class to generate HTTP dates.
 *
 * @author Gustav Trede 
 * @author Remy Maucherat
 */
public final class FastHttpDateFormat {

    private static final String ASCII_CHARSET_NAME = Charsets.ASCII_CHARSET.name();
    
    private static final int CACHE_SIZE = 1000;

    private static final TimeZone GMT_TIME_ZONE = TimeZone.getTimeZone("GMT");

    private static final SimpleDateFormatter FORMATTER = new SimpleDateFormatter();
    
    
HTTP date format.
/**
     * HTTP date format.
     */
    private static final ThreadLocal<SimpleDateFormatter> FORMAT =
        new ThreadLocal<SimpleDateFormatter>() {
            @Override
            protected SimpleDateFormatter initialValue() {
                return new SimpleDateFormatter();
            }
        };

    private static final class SimpleDateFormatter {
        private final Date date;
        private final SimpleDateFormat f;
        private final FieldPosition pos = new FieldPosition(-1);

        public SimpleDateFormatter() {
            date = new Date();
            f = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.US);
            f.setTimeZone(GMT_TIME_ZONE);
        }

        public final String format(final long timeMillis) {
            date.setTime(timeMillis);
            return f.format(date);
        }
        
        public final StringBuffer formatTo(final long timeMillis,
                final StringBuffer buffer) {
            date.setTime(timeMillis);
            return f.format(date, buffer, pos);
        }        
    }

    
ThreadLocal for the set of SimpleDateFormat formats to use in getDateHeader().
GMT timezone - all HTTP dates are on GMT
/**
     * ThreadLocal for the set of SimpleDateFormat formats to use in getDateHeader().
     * GMT timezone - all HTTP dates are on GMT
     */
    private static final ThreadLocal FORMATS =
        new ThreadLocal() {
            @Override
            protected Object initialValue() {
                SimpleDateFormat[] f = new SimpleDateFormat[3];
                f[0] = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz",
                        Locale.US);
                f[0].setTimeZone(GMT_TIME_ZONE);
                f[1] = new SimpleDateFormat("EEEEEE, dd-MMM-yy HH:mm:ss zzz",
                        Locale.US);
                f[1].setTimeZone(GMT_TIME_ZONE);
                f[2] = new SimpleDateFormat("EEE MMMM d HH:mm:ss yyyy",
                        Locale.US);
                f[2].setTimeZone(GMT_TIME_ZONE);
                return f;
            }
        };


    
Instant on which the currentDate object was generated.
/**
     * Instant on which the currentDate object was generated.
     */
    private static volatile long nextGeneration;

    private static final AtomicBoolean isGeneratingNow = new AtomicBoolean();
    
    private static final StringBuffer currentDateBuffer = new StringBuffer();
    
    
Current formatted date as byte[].
/**
     * Current formatted date as byte[].
     */
    private static byte[] currentDateBytes;

    
Current formatted date.
/**
     * Current formatted date.
     */
    private static String cachedStringDate;
    private static volatile byte[] dateBytesForCachedStringDate;

    
    
Formatter cache.
/**
     * Formatter cache.
     */
    private static final ConcurrentMap<Long, String> formatCache = 
        new ConcurrentHashMap<>(CACHE_SIZE, 0.75f, 64);


    
Parser cache.
/**
     * Parser cache.
     */
    private static final ConcurrentMap<String, Long> parseCache =
            new ConcurrentHashMap<>(CACHE_SIZE, 0.75f, 64);


    // --------------------------------------------------------- Public Methods


    
Get the current date in HTTP format.
/**
     * Get the current date in HTTP format.
     */
    public static String getCurrentDate() {
        final byte[] currentDateBytesNow = getCurrentDateBytes();
        if (currentDateBytesNow != dateBytesForCachedStringDate) {
            try {
                cachedStringDate = new String(currentDateBytesNow, ASCII_CHARSET_NAME);
                dateBytesForCachedStringDate = currentDateBytesNow;
            } catch (UnsupportedEncodingException ignored) {
                // should never reach this line
            }
        }
        
        return cachedStringDate;
    }

    
Get the current date in HTTP format.
/**
     * Get the current date in HTTP format.
     */
    public static byte[] getCurrentDateBytes() {
        final long now = System.currentTimeMillis();
        final long diff = now - nextGeneration;
        
        if (diff > 0 &&
                (diff > 5000 ||
                    (!isGeneratingNow.get() &&
                     isGeneratingNow.compareAndSet(false, true)))) {
            synchronized (FORMAT) {
                if (now > nextGeneration) {
                    currentDateBuffer.setLength(0);
                    FORMATTER.formatTo(now, currentDateBuffer);
                    currentDateBytes = toCheckedByteArray(currentDateBuffer);
                    nextGeneration = now + 1000;
                }
                
                isGeneratingNow.set(false);
            }
        }
        return currentDateBytes;
    }
    
    
Get the HTTP format of the specified date.

http spec only requre second precision http://tools.ietf.org/html/rfc2616#page-20 

therefore we dont use the millisecond precision , but second .
truncation is done in the same way for second precision in SimpleDateFormat:

(999 millisec. = 0 sec.)
Params:
value – in milli-seconds
threadLocalFormat – the DateFormat used if cache value was not found/**
     * Get the HTTP format of the specified date.<br>
     * http spec only requre second precision http://tools.ietf.org/html/rfc2616#page-20 <br>
     * therefore we dont use the millisecond precision , but second .
     * truncation is done in the same way for second precision in SimpleDateFormat:<br>
     * (999 millisec. = 0 sec.)
     * @param value in milli-seconds
     * @param threadLocalFormat the {@link DateFormat} used if cache value was 
     *  not found
     */
    public static String formatDate(long value, DateFormat threadLocalFormat) {
        // truncating to second precision
        // this way we optimally use the cache to only store needed http values
        value = (value/1000)*1000;
        final Long longValue =  value;
        String cachedDate = formatCache.get(longValue);
        if (cachedDate != null){
            return cachedDate;
        }
        String newDate;
//        Date dateValue = new Date(value);
        if (threadLocalFormat != null) {
            newDate = threadLocalFormat.format(value);
        } else {
            newDate = FORMAT.get().format(value);
        }
        updateFormatCache(longValue, newDate);
        return newDate;

    }


    
Try to parse the given date as a HTTP date.
/**
     * Try to parse the given date as a HTTP date.
     */
    public static long parseDate(final String value,
            DateFormat[] threadLocalformats) {

        Long cachedDate = parseCache.get(value);
        if (cachedDate != null){
            return cachedDate;
        }
        long date ;
        if (threadLocalformats != null) {
            date = internalParseDate(value, threadLocalformats);
        } else {
            date = internalParseDate(value, (SimpleDateFormat[])FORMATS.get());
        }        
        if (date != -1) {
            updateParseCache(value, date);
        }
        return date;
    }


    
Parse date with given formatters.
/**
     * Parse date with given formatters.
     */
    private static long internalParseDate (String value, DateFormat[] formats){
        for (int i = 0;i < formats.length; i++) {
            try {
                return formats[i].parse(value).getTime();
            } catch (ParseException ignore) {
            }
        }
        return -1;
    }


    
Update cache.
/**
     * Update cache.
     */
    private static void updateFormatCache(Long key, String value) {
        if (value == null) {
            return;
        }
        if (formatCache.size() > CACHE_SIZE) {
            formatCache.clear();
        }
        formatCache.put(key, value);
    }


    
Update cache.
/**
     * Update cache.
     */
    private static void updateParseCache(String key, Long value) {
        if (parseCache.size() > CACHE_SIZE) {
            parseCache.clear(); 
        }
        parseCache.put(key, value);
    }


}