/*
 * This file is part of the Owl Positioning System (OwlPS).
 * OwlPS is a project of the University of Franche-Comte
 * (Université de Franche-Comté), France.
 *
 * Copyright © Université de Franche-Comté 2007-2012.
 *
 * Corresponding author: Matteo Cypriani <mcy@lm7.fr>
 *
 ***********************************************************************
 *
 * This software is governed by the CeCILL license under French law and
 * abiding by the rules of distribution of free software. You can use,
 * modify and/or redistribute the software under the terms of the CeCILL
 * license as circulated by CEA, CNRS and INRIA at the following URL:
 * http://www.cecill.info
 *
 * As a counterpart to the access to the source code and rights to copy,
 * modify and redistribute granted by the license, users are provided
 * only with a limited warranty and the software's authors, the holder
 * of the economic rights, and the successive licensors have only
 * limited liability.
 *
 * In this respect, the user's attention is drawn to the risks
 * associated with loading, using, modifying and/or developing or
 * reproducing the software by the user in light of its specific status
 * of free software, that may mean that it is complicated to manipulate,
 * and that also therefore means that it is reserved for developers and
 * experienced professionals having in-depth computer knowledge. Users
 * are therefore encouraged to load and test the software's suitability
 * as regards their requirements in conditions enabling the security of
 * their systems and/or data to be ensured and, more generally, to use
 * and operate it in the same conditions as regards security.
 *
 * The fact that you are presently reading this means that you have had
 * knowledge of the CeCILL license and that you accept its terms.
 *
 ***********************************************************************
 */


#ifndef _OWLPS_POSITIONING_REQUEST_HH_
#define _OWLPS_POSITIONING_REQUEST_HH_

class Mobile ;

#include "measurement.hh"
#include "timestamp.hh"

#include <owlps.h>

#include <ctime>
#include <vector>
#include <boost/tr1/unordered_map.hpp>
#include <ostream>

/// Represents a request sent by a Mobile
class Request
{
protected:
  /// Type of the request
  uint_fast8_t type ;
  /// Number of packets sent by the mobile for this request
  pkt_id_t nb_packets ;
  /// The mobile that sent the request
  Mobile *mobile ;
  /// Local date of the request on the mobile
  Timestamp time_sent ;
  /// Date at which we received the request from the aggregator
  Timestamp time_received ;
  /// List of Measurement of the request
  /** Note that this is not a pointer list, values are actually stored.
      The \em string parameter is the MAC address of the receiver AP. */
  std::tr1::unordered_map<std::string, Measurement> measurements ;
  /// \brief Real coordinates of the request (normally unavailable for a
  /// standard positioning request)
  Point3D *real_position ;

  /** @name Write accessors */
  //@{
  void clear_real_position(void) ;
  //@}

public:
  Request(const Mobile *_mobile = NULL,
          const Timestamp &_time_sent = Timestamp(),
          const std::tr1::unordered_map<std::string, Measurement>
          &_measurements =
            std::tr1::unordered_map<std::string, Measurement>()) ;

  Request(const std::tr1::unordered_map<std::string, Measurement>
          &_measurements) ;

  Request(const Timestamp &_time_sent,
          const std::tr1::unordered_map<std::string, Measurement>
          &_measurements =
            std::tr1::unordered_map<std::string, Measurement>()) ;

  Request(const Request &source) ;

  virtual ~Request(void) ;

  /** @name Read accessors */
  //@{
  uint_fast8_t get_type(void) const ;
  uint_fast16_t get_nb_packets(void) const ;
  Mobile* get_mobile(void) const ;
  const Timestamp& get_time_sent(void) const ;
  const Timestamp& get_time_received(void) const ;
  /// Returns all the measurements
  const std::tr1::unordered_map<std::string, Measurement>&
  get_measurements(void) const ;
  /// Returns the measurement made by the AP \em mac_receiver, if any
  const Measurement*
  get_measurement(const std::string &mac_receiver) const ;
  const Point3D* get_real_position(void) const ;
  //@}

  /** @name Write accessors */
  //@{
  void set_type(const uint_fast8_t _type) ;
  void set_nb_packets(const uint_fast16_t _nb_packets) ;
  void set_mobile(const Mobile *_mobile) ;
  void set_time_sent(const Timestamp &_time_sent) ;
  void received_now(void) ;
  void set_measurements(const std::tr1::unordered_map
                        <std::string, Measurement> &_measurements) ;
  void set_real_position(const Point3D &_real_position) ;
/// Reinitialises all attributes
  void clear(void) ;
  //@}

  /** @name Conversion accessors */
  //@{
  /// Converts to a CSV string
  const std::string to_csv(void) const ;
  //@}

  /** @name Operations */
  //@{
  /// Computes the similarity of two Request
  float similarity(const Request &source) const ;
  //@}

  /** @name Operators */
  //@{
  Request& operator=(const Request &source) ;
  bool operator==(const Request &comp) const ;
  bool operator!=(const Request &comp) const ;
  operator bool(void) const ;
  //@}

  /// Displays a Request
  friend std::ostream& operator<<(std::ostream &os, const Request &r) ;

  /// Hashes a Request
  friend std::size_t hash_value(const Request &source) ;
} ;



/* *** Read accessors *** */



inline uint_fast8_t Request::get_type() const
{
  return type ;
}


inline uint_fast16_t Request::get_nb_packets() const
{
  return nb_packets ;
}


inline Mobile* Request::get_mobile() const
{
  return mobile ;
}


inline const Timestamp& Request::get_time_sent() const
{
  return time_sent ;
}


inline const Timestamp& Request::get_time_received() const
{
  return time_received ;
}


inline const std::tr1::unordered_map<std::string, Measurement>&
Request::get_measurements(void) const
{
  return measurements ;
}


inline const Point3D* Request::get_real_position(void) const
{
  return real_position ;
}



/* *** Write accessors *** */


inline void Request::set_type(const uint_fast8_t _type)
{
  type = _type ;
}


inline void Request::set_nb_packets(const uint_fast16_t _nb_packets)
{
  nb_packets = _nb_packets ;
}


inline void Request::set_mobile(const Mobile *_mobile)
{
  mobile = const_cast<Mobile*>(_mobile) ;
}


inline void Request::set_time_sent(const Timestamp &_time_sent)
{
  time_sent = _time_sent ;
}


inline void Request::received_now()
{
  time_received.now() ;
}


inline void Request::
set_measurements(const std::tr1::unordered_map<std::string, Measurement>
                 &_measurements)
{
  measurements = _measurements ;
}



/* *** Operators *** */


inline bool Request::operator!=(const Request &comp) const
{
  return !(*this == comp) ;
}


/**
 * @return \em false if the Request is empty.
 * @return \em true if at least one attribute (other than #type and
 * #nb_packets) is initialised.
 */
inline Request::operator bool() const
{
  return
    mobile != NULL ||
    time_sent ||
    measurements.size() > 0 ;
}



#endif // _OWLPS_POSITIONING_REQUEST_HH_