#ifndef __aodvsec_h__
#define __aodvsec_h__

#include <cmu-trace.h>
#include <priqueue.h>
#include <aodvsec/aodvsec_rtable.h>
#include <aodvsec/aodvsec_rqueue.h>
#include <classifier/classifier-port.h>

/*
  Allows local repair of routes 
*/
#define AODVSEC_LOCAL_REPAIR

/*
  Allows AODVSEC to use link-layer (802.11) feedback in determining when
  links are up/down.
*/
#define AODVSEC_LINK_LAYER_DETECTION

/*
  Causes AODVSEC to apply a "smoothing" function to the link layer feedback
  that is generated by 802.11.  In essence, it requires that RT_MAX_ERROR
  errors occurs within a window of RT_MAX_ERROR_TIME before the link
  is considered bad.
*/
#define AODVSEC_USE_LL_METRIC

/*
  Only applies if AODVSEC_USE_LL_METRIC is defined.
  Causes AODVSEC to apply omniscient knowledge to the feedback received
  from 802.11.  This may be flawed, because it does not account for
  congestion.
*/
//#define AODVSEC_USE_GOD_FEEDBACK


class AODVSEC;

#define MY_ROUTE_TIMEOUT        10                      	// 100 seconds
#define ACTIVE_ROUTE_TIMEOUT    10				// 50 seconds
#define REV_ROUTE_LIFE          6				// 5  seconds
#define BCAST_ID_SAVE           6				// 3 seconds


// No. of times to do network-wide search before timing out for 
// MAX_RREQ_TIMEOUT sec. 
#define RREQ_RETRIES            3  
// timeout after doing network-wide search RREQ_RETRIES times
#define MAX_RREQ_TIMEOUT	10.0 //sec

/* Various constants used for the expanding ring search */
#define TTL_START     3
#define TTL_THRESHOLD 4
#define TTL_INCREMENT 1 

// This should be somewhat related to arp timeout
#define NODE_TRAVERSAL_TIME     0.03             // 30 ms
#define LOCAL_REPAIR_WAIT_TIME  0.15 //sec

// Should be set by the user using best guess (conservative) 
#define NETWORK_DIAMETER        4            // 30 hops

// Must be larger than the time difference between a node propagates a route 
// request and gets the route reply back.

//#define RREP_WAIT_TIME     (3 * NODE_TRAVERSAL_TIME * NETWORK_DIAMETER) // ms
//#define RREP_WAIT_TIME     (2 * REV_ROUTE_LIFE)  // seconds
#define RREP_WAIT_TIME         1.0  // sec

#define ID_NOT_FOUND    0x00
#define ID_FOUND        0x01
//#define INFINITY        0xff

// The followings are used for the forward() function. Controls pacing.
#define DELAY 1.0           // random delay
#define NO_DELAY -1.0       // no delay 

// think it should be 30 ms
#define ARP_DELAY 0.01      // fixed delay to keep arp happy


#define HELLO_INTERVAL          1               // 1000 ms
#define ALLOWED_HELLO_LOSS      3               // packets
#define BAD_LINK_LIFETIME       3               // 3000 ms
#define MaxHelloInterval        (1.25 * HELLO_INTERVAL)
#define MinHelloInterval        (0.75 * HELLO_INTERVAL)

/*
  Timersecs (Broadcast ID, Hello, Neighbor Cache, Route Cache)
*/
class BroadcastTimersec : public Handler {
public:
        BroadcastTimersec(AODVSEC* a) : agent(a) {}
        void	handle(Event*);
private:
        AODVSEC    *agent;
	Event	intr;
};

class HelloTimersec : public Handler {
public:
        HelloTimersec(AODVSEC* a) : agent(a) {}
        void	handle(Event*);
private:
        AODVSEC    *agent;
	Event	intr;
};

class NeighborTimersec : public Handler {
public:
        NeighborTimersec(AODVSEC* a) : agent(a) {}
        void	handle(Event*);
private:
        AODVSEC    *agent;
	Event	intr;
};

class RouteCacheTimersec : public Handler {
public:
        RouteCacheTimersec(AODVSEC* a) : agent(a) {}
        void	handle(Event*);
private:
        AODVSEC    *agent;
	Event	intr;
};

class LocalRepairTimersec : public Handler {
public:
        LocalRepairTimersec(AODVSEC* a) : agent(a) {}
        void	handle(Event*);
private:
        AODVSEC    *agent;
	Event	intr;
};


/*
  Broadcast ID Cache
*/
class BroadcastID {
        friend class AODVSEC;
 public:
        BroadcastID(nsaddr_t i, u_int32_t b) { src = i; id = b;  }
 protected:
        LIST_ENTRY(BroadcastID) link;
        nsaddr_t        src;
        u_int32_t       id;
        double          expire;         // now + BCAST_ID_SAVE s
};

LIST_HEAD(aodvsec_bcache, BroadcastID);


/*
  The Routing Agent
*/
class AODVSEC: public Agent {

  /*
   * make some friends first 
   */

        friend class aodvsec_rt_entry;
        friend class BroadcastTimersec;
        friend class HelloTimersec;
        friend class NeighborTimersec;
        friend class RouteCacheTimersec;
        friend class LocalRepairTimersec;

 public:
        AODVSEC(nsaddr_t id);

        void		recv(Packet *p, Handler *);

 protected:
        int             command(int, const char *const *);
        int             initialized() { return 1 && target_; }

        /*
         * Route Table Management
         */
        void            rt_resolve(Packet *p);
        void            rt_update(aodvsec_rt_entry *rt, u_int32_t seqnum,
		     	  	u_int16_t metric, nsaddr_t nexthop,
		      		double expire_time);
        void            rt_down(aodvsec_rt_entry *rt);
        void            local_rt_repair(aodvsec_rt_entry *rt, Packet *p);
 public:
        void            rt_ll_failed(Packet *p);
        void            handle_link_failure(nsaddr_t id);
 protected:
        void            rt_purge(void);

        void            enque(aodvsec_rt_entry *rt, Packet *p);
        Packet*         deque(aodvsec_rt_entry *rt);

        /*
         * Neighbor Management
         */
        void            nb_insert(nsaddr_t id);
        AODVSEC_Neighbor*       nb_lookup(nsaddr_t id);
        void            nb_delete(nsaddr_t id);
        void            nb_purge(void);

        /*
         * Broadcast ID Management
         */

        void            id_insert(nsaddr_t id, u_int32_t bid);
        bool	        id_lookup(nsaddr_t id, u_int32_t bid);
        void            id_purge(void);

        /*
         * Packet TX Routines
         */
        void            forward(aodvsec_rt_entry *rt, Packet *p, double delay);
        void            sendHello(void);
        void            sendRequest(nsaddr_t dst);

        void            sendReply(nsaddr_t ipdst, u_int32_t hop_count,
                                  nsaddr_t rpdst, u_int32_t rpseq,
                                  u_int32_t lifetime, double timestamp);
        void            sendError(Packet *p, bool jitter = true);
                                          
        /*
         * Packet RX Routines
         */
        void            recvAODVSEC(Packet *p);
        void            recvHello(Packet *p);
        void            recvRequest(Packet *p);
        void            recvReply(Packet *p);
        void            recvError(Packet *p);

	/*
	 * History management
	 */
	
	double 		PerHopTime(aodvsec_rt_entry *rt);


        nsaddr_t        index;                  // IP Address of this node
        u_int32_t       seqno;                  // Sequence Number
        int             bid;                    // Broadcast ID

        aodvsec_rtable         rthead;                 // routing table
        aodvsec_ncache         nbhead;                 // Neighbor Cache
        aodvsec_bcache          bihead;                 // Broadcast ID Cache

        /*
         * Timersecs
         */
        BroadcastTimersec  btimersec;
        HelloTimersec      htimersec;
        NeighborTimersec   ntimersec;
        RouteCacheTimersec rtimersec;
        LocalRepairTimersec lrtimersec;

        /*
         * Routing Table
         */
        aodvsec_rtable          rtable;
        /*
         *  A "drop-front" queue used by the routing layer to buffer
         *  packets to which it does not have a route.
         */
        aodvsec_rqueue         rqueue;

        /*
         * A mechanism for logging the contents of the routing
         * table.
         */
        Trace           *logtarget;

        /*
         * A pointer to the network interface queue that sits
         * between the "classifier" and the "link layer".
         */
        PriQueue        *ifqueue;

        /*
         * Logging stuff
         */
        void            log_link_del(nsaddr_t dst);
        void            log_link_broke(Packet *p);
        void            log_link_kept(nsaddr_t dst);

	/* for passing packets up to agents */
	PortClassifier *dmux_;

};

#endif /* __aodvsec_h__ */