/*

 * Copyright (c) 1996, 2019, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package sun.net.www.http;

import java.io.IOException;

import java.io.NotSerializableException;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.net.URL;

import java.security.AccessController;

import java.security.PrivilegedAction;

import java.util.ArrayDeque;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import jdk.internal.misc.InnocuousThread;

import sun.security.action.GetIntegerAction;

/**

 * A class that implements a cache of idle Http connections for keep-alive

 *

 * @author Stephen R. Pietrowicz (NCSA)

 * @author Dave Brown

 */

public class KeepAliveCache

    extends HashMap<KeepAliveKey, ClientVector>

    implements Runnable {

    @java.io.Serial

    private static final long serialVersionUID = -2937172892064557949L;

    /* maximum # keep-alive connections to maintain at once

     * This should be 2 by the HTTP spec, but because we don't support pipe-lining

     * a larger value is more appropriate. So we now set a default of 5, and the value

     * refers to the number of idle connections per destination (in the cache) only.

     * It can be reset by setting system property "http.maxConnections".

     */

    static final int MAX_CONNECTIONS = 5;

    static int result = -1;

    static int getMaxConnections() {

        if (result == -1) {

            result = AccessController.doPrivileged(

                new GetIntegerAction("http.maxConnections", MAX_CONNECTIONS))

                .intValue();

            if (result <= 0) {

                result = MAX_CONNECTIONS;

            }

        }

        return result;

    }

    static final int LIFETIME = 5000;

    private Thread keepAliveTimer = null;

    /**

     * Constructor

     */

    public KeepAliveCache() {}

    /**

     * Register this URL and HttpClient (that supports keep-alive) with the cache

     * @param url  The URL contains info about the host and port

     * @param http The HttpClient to be cached

     */

            }

        }

    }

    /* remove an obsolete HttpClient from its VectorCache */

            }

        }

    }

    /**

     * Check to see if this URL has a cached HttpClient

     */

        }

    }

    /* Sleeps for an alloted timeout, then checks for timed out connections.

     * Errs on the side of caution (leave connections idle for a relatively

     * short time).

     */

    @Override

    public void run() {

        do {

            try {

                Thread.sleep(LIFETIME);

            } catch (InterruptedException e) {}

            // Remove all outdated HttpClients.

                long currentTime = System.currentTimeMillis();

                List<KeepAliveKey> keysToRemove = new ArrayList<>();

                for (KeepAliveKey key : keySet()) {

                    ClientVector v = get(key);

                        KeepAliveEntry e = v.peek();

                        while (e != null) {

                            if ((currentTime - e.idleStartTime) > v.nap) {

                                v.poll();

                                e.hc.closeServer();

                            } else {

                                break;

                            }

                            e = v.peek();

                        }

                        if (v.isEmpty()) {

                            keysToRemove.add(key);

                        }

                    }

                }

                for (KeepAliveKey key : keysToRemove) {

                }

            }

        } while (!isEmpty());

    }

    /*

     * Do not serialize this class!

     */

    @java.io.Serial

    private void writeObject(ObjectOutputStream stream) throws IOException {

        throw new NotSerializableException();

    }

    @java.io.Serial

    private void readObject(ObjectInputStream stream)

        throws IOException, ClassNotFoundException

    {

        throw new NotSerializableException();

    }

}

/* FILO order for recycling HttpClients, should run in a thread

 * to time them out.  If > maxConns are in use, block.

 */

class ClientVector extends ArrayDeque<KeepAliveEntry> {

    @java.io.Serial

    private static final long serialVersionUID = -8680532108106489459L;

    // sleep time in milliseconds, before cache clear

    int nap;

    ClientVector(int nap) {

        this.nap = nap;

    }

    }

    /* return a still valid, unused HttpClient */

        }

    }

    /* remove an HttpClient */

            }

        }

    }

    /*

     * Do not serialize this class!

     */

    @java.io.Serial

    private void writeObject(ObjectOutputStream stream) throws IOException {

        throw new NotSerializableException();

    }

    @java.io.Serial

    private void readObject(ObjectInputStream stream)

        throws IOException, ClassNotFoundException

    {

        throw new NotSerializableException();

    }

}

class KeepAliveKey {

    private String      protocol = null;

    private String      host = null;

    private int         port = 0;

    private Object      obj = null; // additional key, such as socketfactory

    /**

     * Constructor

     *

     * @param url the URL containing the protocol, host and port information

     */

    public KeepAliveKey(URL url, Object obj) {

        this.protocol = url.getProtocol();

        this.host = url.getHost();

        this.port = url.getPort();

        this.obj = obj;

    }

    /**

     * Determine whether or not two objects of this type are equal

     */

    @Override

    public boolean equals(Object obj) {

        if ((obj instanceof KeepAliveKey) == false)

            return false;

        KeepAliveKey kae = (KeepAliveKey)obj;

        return host.equals(kae.host)

            && (port == kae.port)

            && protocol.equals(kae.protocol)

            && this.obj == kae.obj;

    }

    /**

     * The hashCode() for this object is the string hashCode() of

     * concatenation of the protocol, host name and port.

     */

    @Override

    public int hashCode() {

        String str = protocol+host+port;

        return this.obj == null? str.hashCode() :

            str.hashCode() + this.obj.hashCode();

    }

}

class KeepAliveEntry {

    HttpClient hc;

    long idleStartTime;

    KeepAliveEntry(HttpClient hc, long idleStartTime) {

        this.hc = hc;

        this.idleStartTime = idleStartTime;

    }

}