#ifndef PROTON_PROACTOR_H
#define PROTON_PROACTOR_H

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.
 */

#include <proton/types.h>
#include <proton/import_export.h>
#include <proton/listener.h>

#ifdef __cplusplus
extern "C" {
#endif

typedef struct pn_condition_t pn_condition_t;

/**
 * @file
 *
 * **Experimental**: Proactor API for the the proton @ref engine.
 *
 * @defgroup proactor Proactor
 *
 * **Experimental**: Proactor API for portable, multi-threaded, asynchronous applications.
 *
 * The proactor establishes and listens for connections. It creates the @ref
 * "transport" transport that sends and receives data over the network and
 * delivers @ref "events" event to application threads for processing.
 *
 * ## Multi-threading
 *
 * The @ref proactor is thread-safe, but the @ref "protocol engine" is not.  The
 * proactor ensures that each @ref "connection" connection and its associated
 * values (@ref session, @ref link etc.) is processed sequentially, even if there
 * are multiple application threads. See pn_proactor_wait()
 *
 * @{
 */

/**
 * The proactor creates and manage @ref "transports" transport and delivers @ref
 * "event" events to the application.
 *
 */
typedef struct pn_proactor_t pn_proactor_t;

/**
 * Create a proactor. Must be freed with pn_proactor_free()
 */
pn_proactor_t *pn_proactor(void);

/**
 * Free the proactor.
 */
void pn_proactor_free(pn_proactor_t*);

/* FIXME aconway 2016-11-12: connect and listen need options to enable
   things like websockets, alternate encryption or other features.
   The "extra" parameter will be replaced by an "options" parameter
   that will include providing extra data and other manipulators
   to affect how the connection is processed.
*/

/**
 * Asynchronous connect: a connection and transport will be created, the
 * relevant events will be returned by pn_proactor_wait()
 *
 * Errors are indicated by PN_TRANSPORT_ERROR/PN_TRANSPORT_CLOSE events.
 *
 * @param extra bytes to copy to pn_connection_get_extra() on the new connection, @ref
 * pn_rwbytes_null for nothing.
 *
 * @return error if the connect cannot be initiated e.g. an allocation failure.
 * IO errors will be returned as transport events via pn_proactor_wait()
 */
int pn_proactor_connect(pn_proactor_t*, const char *host, const char *port, pn_bytes_t extra);

/**
 * Asynchronous listen: start listening, connections will be returned by pn_proactor_wait()
 * An error are indicated by PN_LISTENER_ERROR event.
 *
 * @param extra bytes to copy to pn_connection_get_extra() on the new connection, @ref
 * pn_rwbytes_null for nothing.
 *
 * @return error if the connect cannot be initiated e.g. an allocation failure.
 * IO errors will be returned as transport events via pn_proactor_wait()
 */
pn_listener_t *pn_proactor_listen(pn_proactor_t *, const char *host, const char *port, int backlog, pn_bytes_t extra);

/**
 * Wait for an event. Can be called in multiple threads concurrently.
 * You must call pn_event_done() when the event has been handled.
 *
 * The proactor ensures that events that cannot be handled concurrently
 * (e.g. events for for the same connection) are never returned concurrently.
 */
pn_event_t *pn_proactor_wait(pn_proactor_t* d);

/**
 * Cause PN_PROACTOR_INTERRUPT to be returned to exactly one thread calling wait()
 * for each call to pn_proactor_interrupt(). Thread safe.
 */
void pn_proactor_interrupt(pn_proactor_t* d);

/**
 * Cause PN_PROACTOR_TIMEOUT to be returned to a thread calling wait() after
 * timeout milliseconds. Thread safe.
 *
 * Note calling pn_proactor_set_timeout() again before the PN_PROACTOR_TIMEOUT is
 * delivered will cancel the previous timeout and deliver an event only after
 * the new timeout.
 */
void pn_proactor_set_timeout(pn_proactor_t* d, pn_millis_t timeout);

/**
 * Cause a PN_CONNECTION_WAKE event to be returned by the proactor, even if
 * there are no IO events pending for the connection.
 *
 * Thread safe: this is the only pn_connection_ function that can be
 * called concurrently.
 *
 * Wakes can be "coalesced" - if several pn_connection_wake() calls happen
 * concurrently, there may be only one PN_CONNECTION_WAKE event.
 */
void pn_connection_wake(pn_connection_t *c);

/**
 * The proactor that created the connection.
 */
pn_proactor_t *pn_connection_proactor(pn_connection_t *c);

/**
 * Call when a proactor event has been handled. Does nothing if not a proactor event.
 *
 * Thread safe: May be called from any thread but must be called exactly once
 * for each event returned by pn_proactor_wait()
 */
void pn_event_done(pn_event_t *);

/**
 * Get the proactor that created the event or NULL.
 */
pn_proactor_t *pn_event_proactor(pn_event_t *);

/**
 * Get the listener for the event or NULL.
 */
pn_listener_t *pn_event_listener(pn_event_t *);

/**
 * @}
 */

#ifdef __cplusplus
}
#endif

#endif // PROTON_PROACTOR_H