/*
 *
 * (C) 2019-25 - ntop.org
 *
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 */

#ifndef _FLOWS_STATS_H_
#define _FLOWS_STATS_H_

#include "ntop_includes.h"

/* *************************************** */

class AggregatedFlowsStats {
 private:
  std::set<std::string> clients, servers;
  u_int32_t num_flows, tot_score;
  u_int64_t tot_sent, tot_rcvd;
  u_int8_t l4_proto;
  FlowsHostInfo* client;
  FlowsHostInfo* server;
  u_int16_t vlan_id;
  u_int16_t srv_port;
  char* proto_name;
  char* info_key;
  u_int64_t key;
  u_int64_t proto_key;
  bool is_not_guessed;
  u_int32_t flow_device_ip;

 public:
  AggregatedFlowsStats(const IpAddress* c, const IpAddress* s, u_int8_t _l4_proto,
             u_int64_t bytes_sent, u_int64_t bytes_rcvd, u_int32_t score);

  ~AggregatedFlowsStats();


  /* Getters */
  inline u_int8_t getL4Protocol() { return (l4_proto); };
  inline u_int16_t getSrvPort() { return (srv_port); };
  inline u_int16_t getVlanId() { return vlan_id; };
  inline u_int16_t getCliVLANId() { return (client ? client->getVLANId() : 0); };
  inline u_int16_t getSrvVLANId() { return (server ? server->getVLANId() : 0); };
  inline u_int32_t getNumClients() { return (clients.size()); };
  inline u_int32_t getNumServers() { return (servers.size()); };
  inline u_int32_t getNumFlows() { return (num_flows); };
  inline u_int32_t getTotalScore() { return (tot_score); };
  inline u_int64_t getKey() { return key; };
  inline u_int64_t getProtoKey() { return proto_key; };
  inline u_int64_t getTotalSent() { return (tot_sent); };
  inline u_int64_t getTotalRcvd() { return (tot_rcvd); };
  inline char* getProtoName() { return (proto_name ? proto_name : (char *)""); };
  inline char* getInfoKey() { return (info_key ? info_key : (char *)""); };
 
  inline const char* getCliIP(char* buf, u_int len) { return (client ? client->getIP(buf, len) : (char *)""); };
  inline const char* getSrvIP(char* buf, u_int len) { return (server ? server->getIP(buf, len) : (char *)""); };
  
  inline IpAddress* getClientIPaddr() { return(client ? client->getIPaddr() : NULL); }
  inline IpAddress* getServerIPaddr() { return(server ? server->getIPaddr() : NULL); }

  inline const char* getCliName(char* buf, u_int len) {
    return (client ? client->getHostName(buf, len) : (char *)"");
  };
  inline const char* getSrvName(char* buf, u_int len) {
    return (server ? server->getHostName(buf, len) : (char *)"");
  };
  inline const char* getCliIPHex(char* buf, u_int len) {
    return (client ? client->getIPHex(buf, len) : (char *)"");
  };
  inline const char* getSrvIPHex(char* buf, u_int len) {
    return (server ? server->getIPHex(buf, len) : (char *)"");
  };
  inline const char* getFlowDeviceIP(char* buf, u_int len) {
    return (flow_device_ip != 0 ? Utils::intoaV4(flow_device_ip, buf, len) : (char *)"");
  };
  inline bool isNotGuessed() { return(is_not_guessed); };

  /* Setters */
  inline void setProtoName(char* _proto_name) {
    if (proto_name) { free(proto_name); }
    proto_name = strdup(_proto_name);
  };
  inline void setInfoKey(string _key) { 
    if (info_key) { free(info_key); }
    info_key = strdup(_key.c_str());
  };
  inline void setProtoKey(u_int64_t _key) { proto_key = _key; };
  inline void setKey(u_int64_t _key) { key = _key; };
  inline void setVlanId(u_int16_t _vlan_id) { vlan_id = _vlan_id; };
  inline void setClient(IpAddress* _ip, Host* _host) {
    if(!client) { client = new (std::nothrow) FlowsHostInfo(_ip, _host); }
  };
  inline void setServer(IpAddress* _ip, Host* _host) {
    if(!server) { server = new (std::nothrow) FlowsHostInfo(_ip, _host); }
  };
  inline void setSrvPort(u_int16_t _srv_port) { srv_port = _srv_port; };
  inline void setFlowDeviceIP(u_int32_t _flow_device_ip) { flow_device_ip = _flow_device_ip; };

  void setFlowIPVLANDeviceIP(Flow *f);

  inline bool isCliInMem() { return (client->isHostInMem()); };
  inline bool isSrvInMem() { return (server->isHostInMem()); };
  inline void setIsNotGuessed(bool isNotGuessed) { is_not_guessed = isNotGuessed; };

  void incFlowStats(const IpAddress* _client, const IpAddress* _server,
                           u_int64_t bytes_sent, u_int64_t bytes_rcvd,
                           u_int32_t score);
};

struct aggregated_stats {
  std::unordered_map<u_int64_t, AggregatedFlowsStats *> count;
  std::unordered_map<string, AggregatedFlowsStats *> info_count;
  IpAddress *ip_addr;
  u_int16_t vlan_id;
  u_int32_t flow_device_ip;
  u_int32_t in_if_index;
  u_int32_t out_if_index;
};

#endif /* _FLOWS_STATS_H_ */
