/*
 * Copyright (c) 2005, 2006, 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.security.smartcardio;

import java.util.*;
import java.lang.ref.*;

import javax.smartcardio.*;
import static javax.smartcardio.CardTerminals.State.*;

import static sun.security.smartcardio.PCSC.*;

/**
 * TerminalFactorySpi implementation class.
 *
 * @since   1.6
 * @author  Andreas Sterbenz
 */
final class PCSCTerminals extends CardTerminals {

    // SCARDCONTEXT, currently shared between all threads/terminals
    private static long contextId;

    // terminal state used by waitForCard()
    private Map<String,ReaderState> stateMap;

    PCSCTerminals() {
        // empty
    }

    static synchronized void initContext() throws PCSCException {
        if (contextId == 0) {
            contextId = SCardEstablishContext(SCARD_SCOPE_USER);
        }
    }

    private static final Map<String,Reference<TerminalImpl>> terminals
        = new HashMap<String,Reference<TerminalImpl>>();

    private static synchronized TerminalImpl implGetTerminal(String name) {
        Reference<TerminalImpl> ref = terminals.get(name);
        TerminalImpl terminal = (ref != null) ? ref.get() : null;
        if (terminal != null) {
            return terminal;
        }
        terminal = new TerminalImpl(contextId, name);
        terminals.put(name, new WeakReference<TerminalImpl>(terminal));
        return terminal;

    }

    public synchronized List<CardTerminal> list(State state) throws CardException {
        if (state == null) {
            throw new NullPointerException();
        }
        try {
            String[] readerNames = SCardListReaders(contextId);
            List<CardTerminal> list = new ArrayList<CardTerminal>(readerNames.length);
            if (stateMap == null) {
                // If waitForChange() has never been called, treat event
                // queries as status queries.
                if (state == CARD_INSERTION) {
                    state = CARD_PRESENT;
                } else if (state == CARD_REMOVAL) {
                    state = CARD_ABSENT;
                }
            }
            for (String readerName : readerNames) {
                CardTerminal terminal = implGetTerminal(readerName);
                ReaderState readerState;
                switch (state) {
                case ALL:
                    list.add(terminal);
                    break;
                case CARD_PRESENT:
                    if (terminal.isCardPresent()) {
                        list.add(terminal);
                    }
                    break;
                case CARD_ABSENT:
                    if (terminal.isCardPresent() == false) {
                        list.add(terminal);
                    }
                    break;
                case CARD_INSERTION:
                    readerState = stateMap.get(readerName);
                    if ((readerState != null) && readerState.isInsertion()) {
                        list.add(terminal);
                    }
                    break;
                case CARD_REMOVAL:
                    readerState = stateMap.get(readerName);
                    if ((readerState != null) && readerState.isRemoval()) {
                        list.add(terminal);
                    }
                    break;
                default:
                    throw new CardException("Unknown state: " + state);
                }
            }
            return Collections.unmodifiableList(list);
        } catch (PCSCException e) {
            throw new CardException("list() failed", e);
        }
    }

    private static class ReaderState {
        private int current, previous;
        ReaderState() {
            current = SCARD_STATE_UNAWARE;
            previous = SCARD_STATE_UNAWARE;
        }
        int get() {
            return current;
        }
        void update(int newState) {
            previous = current;
            current = newState;
        }
        boolean isInsertion() {
            return !present(previous) && present(current);
        }
        boolean isRemoval() {
            return present(previous) && !present(current);
        }
        static boolean present(int state) {
            return (state & SCARD_STATE_PRESENT) != 0;
        }
    }

    public synchronized boolean waitForChange(long timeout) throws CardException {
        if (timeout < 0) {
            throw new IllegalArgumentException
                ("Timeout must not be negative: " + timeout);
        }
        if (stateMap == null) {
            // We need to initialize the state database.
            // Do that with a recursive call, which will return immediately
            // because we pass SCARD_STATE_UNAWARE.
            // After that, proceed with the real call.
            stateMap = new HashMap<String,ReaderState>();
            waitForChange(0);
        }
        if (timeout == 0) {
            timeout = TIMEOUT_INFINITE;
        }
        try {
            String[] readerNames = SCardListReaders(contextId);
            int n = readerNames.length;
            if (n == 0) {
                throw new IllegalStateException("No terminals available");
            }
            int[] status = new int[n];
            ReaderState[] readerStates = new ReaderState[n];
            for (int i = 0; i < readerNames.length; i++) {
                String name = readerNames[i];
                ReaderState state = stateMap.get(name);
                if (state == null) {
                    state = new ReaderState();
                }
                readerStates[i] = state;
                status[i] = state.get();
            }
            status = SCardGetStatusChange(contextId, timeout, status, readerNames);
            stateMap.clear(); // remove any readers that are no longer available
            for (int i = 0; i < n; i++) {
                ReaderState state = readerStates[i];
                state.update(status[i]);
                stateMap.put(readerNames[i], state);
            }
            return true;
        } catch (PCSCException e) {
            if (e.code == SCARD_E_TIMEOUT) {
                return false;
            } else {
                throw new CardException("waitForChange() failed", e);
            }
        }
    }

    static List<CardTerminal> waitForCards(List<? extends CardTerminal> terminals,
            long timeout, boolean wantPresent) throws CardException {
        // the argument sanity checks are performed in
        // javax.smartcardio.TerminalFactory or TerminalImpl

        long thisTimeout;
        if (timeout == 0) {
            timeout = TIMEOUT_INFINITE;
            thisTimeout = TIMEOUT_INFINITE;
        } else {
            // if timeout is not infinite, do the initial call that retrieves
            // the status with a 0 timeout. Otherwise, we might get incorrect
            // timeout exceptions (seen on Solaris with PC/SC shim)
            thisTimeout = 0;
        }

        String[] names = new String[terminals.size()];
        int i = 0;
        for (CardTerminal terminal : terminals) {
            if (terminal instanceof TerminalImpl == false) {
                throw new IllegalArgumentException
                    ("Invalid terminal type: " + terminal.getClass().getName());
            }
            TerminalImpl impl = (TerminalImpl)terminal;
            names[i++] = impl.name;
        }

        int[] status = new int[names.length];
        Arrays.fill(status, SCARD_STATE_UNAWARE);

        try {
            while (true) {
                // note that we pass "timeout" on each native PC/SC call
                // that means that if we end up making multiple (more than 2)
                // calls, we might wait too long.
                // for now assume that is unlikely and not a problem.
                status = SCardGetStatusChange(contextId, thisTimeout, status, names);
                thisTimeout = timeout;

                List<CardTerminal> results = null;
                for (i = 0; i < names.length; i++) {
                    boolean nowPresent = (status[i] & SCARD_STATE_PRESENT) != 0;
                    if (nowPresent == wantPresent) {
                        if (results == null) {
                            results = new ArrayList<CardTerminal>();
                        }
                        results.add(implGetTerminal(names[i]));
                    }
                }

                if (results != null) {
                    return Collections.unmodifiableList(results);
                }
            }
        } catch (PCSCException e) {
            if (e.code == SCARD_E_TIMEOUT) {
                return Collections.emptyList();
            } else {
                throw new CardException("waitForCard() failed", e);
            }
        }
    }

}