/*
 * Copyright (c) 2017 Cisco and/or its affiliates.
 * Licensed 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.
 */

#ifndef ICNET_RATE_ESTIMATION_H_
#define ICNET_RATE_ESTIMATION_H_

#include <unistd.h>

#include "icnet_transport_raaqm_data_path.h"
#include "icnet_transport_download_observer.h"

#define BATCH 50
#define KV 20
#define ALPHA 0.8
#define RATE_CHOICE 0

namespace icnet {

namespace transport {

class IcnRateEstimator {
 public:
  IcnRateEstimator() {
  };

  virtual ~IcnRateEstimator() {
  };

  virtual void onRttUpdate(double rtt) {
  };

  virtual void onDataReceived(int packetSize) {
  };

  virtual void onWindowIncrease(double winCurrent) {
  };

  virtual void onWindowDecrease(double winCurrent) {
  };

  virtual void onStart() {
  };

  virtual void onDownloadFinished() {
  };

  virtual void setObserver(IcnObserver *observer) {
    this->observer_ = observer;
  };
  IcnObserver *observer_;
  struct timeval begin_;
  double base_alpha_;
  double alpha_;
  double estimation_;
  int number_of_packets_;
  // this boolean is to make sure at least one estimation of the BW is done
  bool estimated_;
};

// A rate estimator RTT-based. Computes EWMA(WinSize)/EWMA(RTT)

class InterRttEstimator : public IcnRateEstimator {
 public:
  InterRttEstimator(double alpha_arg);

  ~InterRttEstimator();

  void onRttUpdate(double rtt);

  void onDataReceived(int packet_size) {
    if (packet_size > this->max_packet_size_) {
      this->max_packet_size_ = packet_size;
    }
  };

  void onWindowIncrease(double win_current);

  void onWindowDecrease(double win_current);

  void onStart() {
  };

  void onDownloadFinished() {
  };

  // private: should be done by using getters
  pthread_t *my_th_;
  bool thread_is_running_;
  double rtt_;
  bool is_running_;
  pthread_mutex_t mutex_;
  double avg_rtt_;
  double avg_win_;
  int max_packet_size_;
  double win_change_;
  double win_current_;
};

// A rate estimator, Batching Packets based. Computes EWMA(WinSize)/EWMA(RTT)

class BatchingPacketsEstimator : public IcnRateEstimator {
 public:
  BatchingPacketsEstimator(double alpha_arg, int batchingParam);

  void onRttUpdate(double rtt);

  void onDataReceived(int packet_size) {
    if (packet_size > this->max_packet_size_) {
      this->max_packet_size_ = packet_size;
    }
  };

  void onWindowIncrease(double win_current);

  void onWindowDecrease(double win_current);

  void onStart() {
  };

  void onDownloadFinished() {
  };

 private:
  int batching_param_;
  double avg_rtt_;
  double avg_win_;
  double win_change_;
  int max_packet_size_;
  double win_current_;
};

//Segment Estimator

class ALaTcpEstimator : public IcnRateEstimator {
 public:
  ALaTcpEstimator();

  void onDataReceived(int packet_size);
  void onStart();
  void onDownloadFinished();

 private:
  double totalSize_;
};

// A Rate estimator, this one is the simplest: counting batching_param_ packets and then divide the sum of the size of these packets by the time taken to DL them.
// Should be the one used

class SimpleEstimator : public IcnRateEstimator {
 public:
  SimpleEstimator(double alpha, int batching_param);

  void onRttUpdate(double rtt);

  void onDataReceived(int packet_size);

  void onWindowIncrease(double win_current) {
  };

  void onWindowDecrease(double win_current) {
  };

  void onStart();

  void onDownloadFinished();

 private:
  int batching_param_;
  double total_size_;
};

void *Timer(void *data);

} // end namespace transport

} // end namespace icnet

#endif // ICNET_RATE_ESTIMATION_H_