#ifndef __router_private_h__
#define __router_private_h__ 1
/*
 * 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.
 */

/**@file
 * Router Private type definitions
 *@internal
 */

#include <qpid/dispatch/enum.h>
#include <qpid/dispatch/router.h>
#include <qpid/dispatch/message.h>
#include <qpid/dispatch/bitmask.h>
#include <qpid/dispatch/hash.h>
#include <qpid/dispatch/log.h>
#include "dispatch_private.h"
#include "entity.h"

qd_error_t qd_router_python_setup(qd_router_t *router);
void qd_router_python_free(qd_router_t *router);
qd_error_t qd_pyrouter_tick(qd_router_t *router);
qd_error_t qd_router_configure_address(qd_router_t *router, qd_entity_t *entity);
qd_error_t qd_router_configure_waypoint(qd_router_t *router, qd_entity_t *entity);
qd_error_t qd_router_configure_lrp(qd_router_t *router, qd_entity_t *entity);

void qd_router_configure_free(qd_router_t *router);

typedef enum {
    QD_ROUTER_MODE_STANDALONE,  ///< Standalone router.  No routing protocol participation
    QD_ROUTER_MODE_INTERIOR,    ///< Interior router.  Full participation in routing protocol.
    QD_ROUTER_MODE_EDGE,        ///< Edge router.  No transit-router capability.
    QD_ROUTER_MODE_ENDPOINT     ///< No routing except for internal modules (agent, etc.).
} qd_router_mode_t;
ENUM_DECLARE(qd_router_mode);

typedef enum {
    QD_LINK_ENDPOINT,   ///< A link to a connected endpoint
    QD_LINK_WAYPOINT,   ///< A link to a configured waypoint
    QD_LINK_ROUTER,     ///< A link to a peer router in the same area
    QD_LINK_AREA        ///< A link to a peer router in a different area (area boundary)
} qd_link_type_t;
ENUM_DECLARE(qd_link_type);

typedef struct qd_routed_event_t {
    DEQ_LINKS(struct qd_routed_event_t);
    qd_router_delivery_t *delivery;
    qd_message_t  *message;
    bool           settle;
    uint64_t       disposition;
} qd_routed_event_t;

extern const char *QD_ROUTER_NODE_TYPE;
extern const char *QD_ROUTER_ADDRESS_TYPE;
extern const char *QD_ROUTER_LINK_TYPE;

ALLOC_DECLARE(qd_routed_event_t);
DEQ_DECLARE(qd_routed_event_t, qd_routed_event_list_t);

DEQ_DECLARE(qd_router_delivery_t, qd_router_delivery_list_t);

struct qd_router_link_t {
    DEQ_LINKS(qd_router_link_t);
    int                       mask_bit;        ///< Unique mask bit if this is an inter-router link
    qd_link_type_t            link_type;
    qd_direction_t            link_direction;
    qd_address_t             *owning_addr;     ///< [ref] Address record that owns this link
    qd_waypoint_t            *waypoint;        ///< [ref] Waypoint that owns this link
    qd_link_t                *link;            ///< [own] Link pointer
    qd_router_link_t         *connected_link;  ///< [ref] If this is a link-route, reference the connected link
    qd_router_link_ref_t     *ref;             ///< Pointer to a containing reference object
    char                     *target;          ///< Target address for incoming links
    qd_routed_event_list_t    event_fifo;      ///< FIFO of outgoing delivery/link events (no messages)
    qd_routed_event_list_t    msg_fifo;        ///< FIFO of outgoing message deliveries
    qd_router_delivery_list_t deliveries;      ///< [own] outstanding unsettled deliveries
    bool                      strip_inbound_annotations;  ///<should the dispatch specific inbound annotations be stripped at the ingress router
    bool                      strip_outbound_annotations; ///<should the dispatch specific outbound annotations be stripped at the egress router
};

ALLOC_DECLARE(qd_router_link_t);
DEQ_DECLARE(qd_router_link_t, qd_router_link_list_t);
void qd_router_link_free_LH(qd_router_link_t *);

struct qd_router_node_t {
    DEQ_LINKS(qd_router_node_t);
    qd_address_t     *owning_addr;
    int               mask_bit;
    qd_router_node_t *next_hop;   ///< Next hop node _if_ this is not a neighbor node
    qd_router_link_t *peer_link;  ///< Outgoing link _if_ this is a neighbor node
    uint32_t          ref_count;
    qd_bitmask_t     *valid_origins;
};

ALLOC_DECLARE(qd_router_node_t);
DEQ_DECLARE(qd_router_node_t, qd_router_node_list_t);

struct qd_router_ref_t {
    DEQ_LINKS(qd_router_ref_t);
    qd_router_node_t *router;
};

ALLOC_DECLARE(qd_router_ref_t);
DEQ_DECLARE(qd_router_ref_t, qd_router_ref_list_t);


struct qd_router_link_ref_t {
    DEQ_LINKS(qd_router_link_ref_t);
    qd_router_link_t *link;
};

ALLOC_DECLARE(qd_router_link_ref_t);
DEQ_DECLARE(qd_router_link_ref_t, qd_router_link_ref_list_t);


struct qd_lrp_t {
    DEQ_LINKS(qd_lrp_t);
    char               *prefix;
    bool                inbound;
    bool                outbound;
    qd_lrp_container_t *container;
};

DEQ_DECLARE(qd_lrp_t, qd_lrp_list_t);


struct qd_lrp_container_t {
    DEQ_LINKS(qd_lrp_container_t);
    qd_dispatch_t         *qd;
    qd_config_connector_t *cc;
    qd_lrp_list_t          lrps;
    qd_timer_t            *timer;
    qd_connection_t       *conn;
};

DEQ_DECLARE(qd_lrp_container_t, qd_lrp_container_list_t);


struct qd_router_lrp_ref_t {
    DEQ_LINKS(qd_router_lrp_ref_t);
    qd_lrp_t *lrp;
};

ALLOC_DECLARE(qd_router_lrp_ref_t);
DEQ_DECLARE(qd_router_lrp_ref_t, qd_router_lrp_ref_list_t);


struct qd_router_conn_t {
    int ref_count;
    int mask_bit;
};

ALLOC_DECLARE(qd_router_conn_t);

/** A router address */
struct qd_address_t {
    DEQ_LINKS(qd_address_t);
    qd_router_message_cb_t     on_message;          ///< In-Process Message Consumer
    void                      *on_message_context;  ///< In-Process Consumer context
    qd_router_lrp_ref_list_t   lrps;              ///< Local link-route destinations
    qd_router_link_ref_list_t  rlinks;            ///< Locally-Connected Consumers
    qd_router_ref_list_t       rnodes;            ///< Remotely-Connected Consumers
    qd_hash_handle_t          *hash_handle;       ///< Linkage back to the hash table entry
    qd_address_semantics_t     semantics;
    qd_address_t              *redirect;
    qd_address_t              *static_cc;
    qd_address_t              *dynamic_cc;
    bool                       toggle;
    bool                       waypoint;
    bool                       block_deletion;
    qd_router_forwarder_t     *forwarder;

    //
    // TODO - Add support for asynchronous address lookup:
    //  - Add a FIFO for routed_events holding the message and delivery
    //  - Add an indication that the address is awaiting a lookup response
    //

    /**@name Statistics */
    ///@{
    uint64_t deliveries_ingress;
    uint64_t deliveries_egress;
    uint64_t deliveries_transit;
    uint64_t deliveries_to_container;
    uint64_t deliveries_from_container;
    ///@}
};

ALLOC_DECLARE(qd_address_t);
DEQ_DECLARE(qd_address_t, qd_address_list_t);

/** Constructor for qd_address_t */
qd_address_t* qd_address(qd_address_semantics_t semantics);

struct qd_config_phase_t {
    DEQ_LINKS(qd_config_phase_t);
    char                    phase;
    qd_address_semantics_t  semantics;
};

DEQ_DECLARE(qd_config_phase_t, qd_config_phase_list_t);

struct qd_config_address_t {
    DEQ_LINKS(qd_config_address_t);
    char                   *prefix;
    char                    last_phase;
    qd_config_phase_list_t  phases;
};

DEQ_DECLARE(qd_config_address_t, qd_config_address_list_t);

/**
 * A waypoint is a point on a multi-phase route where messages can exit and re-enter the router.
 *
 * NOTE: a message received by a waypoint is first sent OUT and then received back IN.
 */
struct qd_waypoint_t {
    DEQ_LINKS(qd_waypoint_t);
    char                  *address;
    char                   in_phase;       ///< Phase for re-entering message.
    char                   out_phase;      ///< Phase for exiting message.
    char                  *connector_name; ///< On-demand connector name for outgoing messages.
    qd_config_connector_t *connector;      ///< Connector for outgoing messages.
    qd_connection_t       *connection;     ///< Connection for outgoing messages.
    qd_link_t             *in_link;        ///< Link for re-entering messages.
    qd_link_t             *out_link;       ///< Link for exiting messages.
    qd_address_t          *in_address;     ///< Address for re-entering messages.
    qd_address_t          *out_address;    ///< Address for exiting messages.
    bool                   connected;      ///< True if connected.
};

DEQ_DECLARE(qd_waypoint_t, qd_waypoint_list_t);


struct qd_router_t {
    qd_dispatch_t            *qd;
    qd_log_source_t          *log_source;
    qd_router_mode_t          router_mode;
    const char               *router_area;
    const char               *router_id;
    qd_node_t                *node;

    qd_address_list_t         addrs;
    qd_hash_t                *addr_hash;
    qd_address_t             *router_addr;
    qd_address_t             *routerma_addr;
    qd_address_t             *hello_addr;

    qd_router_link_list_t     links;
    qd_router_node_list_t     routers;
    qd_lrp_container_list_t   lrp_containers;
    qd_router_link_t        **out_links_by_mask_bit;
    qd_router_node_t        **routers_by_mask_bit;

    qd_bitmask_t             *neighbor_free_mask;
    sys_mutex_t              *lock;
    qd_timer_t               *timer;
    uint64_t                  dtag;

    qd_config_address_list_t  config_addrs;
    qd_waypoint_list_t        waypoints;
};

void qd_router_check_addr(qd_router_t *router, qd_address_t *addr, int was_local);
void qd_router_add_link_ref_LH(qd_router_link_ref_list_t *ref_list, qd_router_link_t *link);
void qd_router_del_link_ref_LH(qd_router_link_ref_list_t *ref_list, qd_router_link_t *link);

void qd_router_add_node_ref_LH(qd_router_ref_list_t *ref_list, qd_router_node_t *rnode);
void qd_router_del_node_ref_LH(qd_router_ref_list_t *ref_list, qd_router_node_t *rnode);

void qd_router_add_lrp_ref_LH(qd_router_lrp_ref_list_t *ref_list, qd_lrp_t *lrp);
void qd_router_del_lrp_ref_LH(qd_router_lrp_ref_list_t *ref_list, qd_lrp_t *lrp);

void qd_router_mobile_added(qd_router_t *router, qd_field_iterator_t *iter);
void qd_router_mobile_removed(qd_router_t *router, const char *addr);
void qd_router_link_lost(qd_router_t *router, int link_mask_bit);

qd_address_semantics_t router_semantics_for_addr(qd_router_t *router, qd_field_iterator_t *iter,
                                                 char in_phase, char *out_phase);
qd_address_t *qd_router_address_lookup_LH(qd_router_t *router,
                                          qd_field_iterator_t *addr_iter,
                                          bool *is_local, bool *is_direct);

/**
 * Important: qd_router_link_new_delivery must never be called twice in a row
 *            without an intervening pn_link_advance.  The Disatch architecture
 *            provides a hook for discovering when an outgoing link is writable
 *            and has credit.  When a link is writable, a delivery is
 *            allocated, written, and advanced in one operation.  If a backlog
 *            of pending deliveries is created, an assertion will be thrown.
 */
qd_router_delivery_t *qd_router_link_new_delivery(qd_router_link_t *link, pn_delivery_tag_t tag);
qd_router_delivery_t *qd_router_delivery(qd_router_link_t *link, pn_delivery_t *pnd);
void qd_router_delivery_set_undeliverable_LH(qd_router_delivery_t *delivery);
void qd_router_delivery_free_LH(qd_router_delivery_t *delivery, uint64_t final_disposition);
void qd_router_delivery_link_peers_LH(qd_router_delivery_t *left, qd_router_delivery_t *right);
void qd_router_delivery_unlink_LH(qd_router_delivery_t *delivery);
void qd_router_delivery_fifo_enter_LH(qd_router_delivery_t *delivery);
bool qd_router_delivery_fifo_exit_LH(qd_router_delivery_t *delivery);
qd_router_delivery_t *qd_router_delivery_peer(qd_router_delivery_t *delivery);
void qd_router_delivery_set_context(qd_router_delivery_t *delivery, void *context);
void *qd_router_delivery_context(qd_router_delivery_t *delivery);
pn_delivery_t *qd_router_delivery_pn(qd_router_delivery_t *delivery);
void qd_router_delivery_settle(qd_router_delivery_t *delivery);
bool qd_router_delivery_settled(qd_router_delivery_t *delivery);
bool qd_router_delivery_disp_changed(qd_router_delivery_t *delivery);
uint64_t qd_router_delivery_disp(qd_router_delivery_t *delivery);
qd_router_link_t *qd_router_delivery_link(qd_router_delivery_t *delivery);

/**
 * Instanciates, initializes and returns a pointer to qd_router_link_t.
 */
qd_router_link_t* qd_router_link(qd_link_t *link, qd_link_type_t link_type, qd_direction_t direction, qd_address_t *owning_addr, qd_waypoint_t *wp, int mask_bit);

#endif