/*
 * Copyright (C) 2009 The Android Open Source Project
 *
 * 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.apache.harmony.xnet.provider.jsse;

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Iterator;
import java.util.ArrayList;
import java.util.Arrays;

import javax.net.ssl.SSLSession;

/**
 * Caches server sessions. Indexes by session ID. Users typically look up
 * sessions using the ID provided by an SSL client.
 */
public class ServerSessionContext extends AbstractSessionContext {

    /*
     * TODO: Expire timed-out sessions more pro-actively.
     */

    private final Map<ByteArray, SSLSession> sessions
            = new LinkedHashMap<ByteArray, SSLSession>() {
        @Override
        protected boolean removeEldestEntry(
                Map.Entry<ByteArray, SSLSession> eldest) {
            return maximumSize > 0 && size() > maximumSize;
        }
    };

    private final SSLServerSessionCache persistentCache;

    public ServerSessionContext(SSLParameters parameters,
            SSLServerSessionCache persistentCache) {
        super(parameters, 100, 0);
        this.persistentCache = persistentCache;
    }

    Iterator<SSLSession> sessionIterator() {
        synchronized (sessions) {
            SSLSession[] array = sessions.values().toArray(
                    new SSLSession[sessions.size()]);
            return Arrays.asList(array).iterator();
        }
    }

    void trimToSize() {
        synchronized (sessions) {
            int size = sessions.size();
            if (size > maximumSize) {
                int removals = size - maximumSize;
                Iterator<SSLSession> i = sessions.values().iterator();
                do {
                    i.next();
                    i.remove();
                } while (--removals > 0);
            }
        }
    }

    public void setSessionTimeout(int seconds)
            throws IllegalArgumentException {
        if (seconds < 0) {
            throw new IllegalArgumentException("seconds < 0");
        }
        timeout = seconds;
    }

    public SSLSession getSession(byte[] sessionId) {
        ByteArray key = new ByteArray(sessionId);
        synchronized (sessions) {
            SSLSession session = sessions.get(key);
            if (session != null) {
                return session;
            }
        }

        // Check persistent cache.
        if (persistentCache != null) {
            byte[] data = persistentCache.getSessionData(sessionId);
            if (data != null) {
                SSLSession session = toSession(data, null, -1);
                if (session != null) {
                    synchronized (sessions) {
                        sessions.put(key, session);
                    }
                    return session;
                }
            }
        }

        return null;
    }

    void putSession(SSLSession session) {
        ByteArray key = new ByteArray(session.getId());
        synchronized (sessions) {
            sessions.put(key, session);
        }

        // TODO: In background thread.
        if (persistentCache != null) {
            byte[] data = toBytes(session);
            if (data != null) {
                persistentCache.putSessionData(session, data);
            }
        }
    }
}