/*

 * Copyright (c) 2003, 2018, 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 com.sun.tools.jdi;

import java.util.Map;

import java.util.HashMap;

import java.util.ArrayList;

import java.io.IOException;

import com.sun.jdi.Bootstrap;

import com.sun.jdi.VirtualMachine;

import com.sun.jdi.connect.*;

import com.sun.jdi.connect.spi.*;

/*

 * A ListeningConnector to listen for connections from target VM

 * using the configured transport service

 */

public class GenericListeningConnector

        extends ConnectorImpl implements ListeningConnector

{

    static final String ARG_ADDRESS = "address";

    static final String ARG_TIMEOUT = "timeout";

    Map<Map<String,? extends Connector.Argument>, TransportService.ListenKey>  listenMap;

    TransportService transportService;

    Transport transport;

    /**

     * Initialize a new instance of this connector. The connector

     * encapsulates a transport service, has a "timeout" connector argument,

     * and optionally an "address" connector argument.

     */

    private GenericListeningConnector(TransportService ts,

                                      boolean addAddressArgument)

    {

        transportService = ts;

        transport = new Transport() {

                public String name() {

                    return transportService.name();

                }

            };

        if (addAddressArgument) {

            addStringArgument(

                ARG_ADDRESS,

                getString("generic_listening.address.label"),

                getString("generic_listening.address"),

                "",

                false);

        }

        addIntegerArgument(

                ARG_TIMEOUT,

                getString("generic_listening.timeout.label"),

                getString("generic_listening.timeout"),

                "",

                false,

                0, Integer.MAX_VALUE);

        listenMap = new HashMap<Map<String,? extends Connector.Argument>,TransportService.ListenKey>(10);

    }

    /**

     * Initialize a new instance of this connector. This constructor is used

     * when sub-classing - the resulting connector will a "timeout" connector

     * argument.

     */

    protected GenericListeningConnector(TransportService ts) {

        this(ts, false);

    }

    /**

     * Create an instance of this Connector. The resulting ListeningConnector will

     * have "address" and "timeout" connector arguments.

     */

    public static GenericListeningConnector create(TransportService ts) {

        return new GenericListeningConnector(ts, true);

    }

    public String startListening(String address, Map<String,? extends Connector.Argument> args)

        throws IOException, IllegalConnectorArgumentsException

    {

        TransportService.ListenKey listener = listenMap.get(args);

        if (listener != null) {

           throw new IllegalConnectorArgumentsException("Already listening",

               new ArrayList<String>(args.keySet()));

        }

        listener = transportService.startListening(address);

        updateArgumentMapIfRequired(args, listener);

        listenMap.put(args, listener);

        return listener.address();

    }

    public String

        startListening(Map<String,? extends Connector.Argument> args)

        throws IOException, IllegalConnectorArgumentsException

    {

        String address = argument(ARG_ADDRESS, args).value();

        return startListening(address, args);

    }

    public void stopListening(Map<String,? extends Connector.Argument> args)

        throws IOException, IllegalConnectorArgumentsException

    {

        TransportService.ListenKey listener = listenMap.get(args);

        if (listener == null) {

           throw new IllegalConnectorArgumentsException("Not listening",

               new ArrayList<String>(args.keySet()));

        }

        transportService.stopListening(listener);

        listenMap.remove(args);

    }

    public VirtualMachine

        accept(Map<String,? extends Connector.Argument> args)

        throws IOException, IllegalConnectorArgumentsException

    {

        String ts = argument(ARG_TIMEOUT, args).value();

        int timeout = 0;

        if (ts.length() > 0) {

            timeout = Integer.decode(ts).intValue();

        }

        TransportService.ListenKey listener = listenMap.get(args);

        Connection connection;

        if (listener != null) {

            connection = transportService.accept(listener, timeout, 0);

        } else {

            /*

             * Keep compatibility with previous releases - if the

             * debugger hasn't called startListening then we do a

             * once-off accept

             */

             startListening(args);

             listener = listenMap.get(args);

             assert listener != null;

             connection = transportService.accept(listener, timeout, 0);

             stopListening(args);

        }

        return Bootstrap.virtualMachineManager().createVirtualMachine(connection);

    }

    public boolean supportsMultipleConnections() {

        return transportService.capabilities().supportsMultipleConnections();

    }

    public String name() {

        return transport.name() + "Listen";

    }

    public String description() {

        return transportService.description();

    }

    public Transport transport() {

        return transport;

    }

    protected void updateArgumentMapIfRequired(

        Map<String, ? extends Connector.Argument> args, TransportService.ListenKey listener) {

    }

}