#include <errno.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <unistd.h>

#include <arpa/inet.h>
#include <netdb.h>
#include <net/if.h>
#include <netpacket/packet.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/types.h>

#include <fstream>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <memory>

#include "device_stats.pb.h"

#define ETH_PORT "eth0"
#define GOOG_PROTOCOL 0x8930
#define STAT_INTERVAL 60

std::string multicast_addr = "FF12::8000:1";

uint8_t mc_mac[] = { 0x01, 0x00, 0x5e, 0x00, 0x00, 0x01 };
const char *optstring = "s:i:a:";

std::string serial_number;
std::string wan_interface;
std::string acs_contact_file;

void usage() {
  printf("Usage: statpitcher -s <serial number> -i <wan interface> "
         "-a <acs_contact_file>\n");
  exit(1);
}

void ReadFile(const std::string& fname, std::string* data) {
  data->clear();

  std::ifstream s(fname);
  if (!s.is_open())
    return;
  data->assign(std::istreambuf_iterator<char>(s),
               std::istreambuf_iterator<char>());
}

int GetIfIndex(int sock) {
  struct ifreq ifr;
  memset(&ifr, 0, sizeof(ifr));
  snprintf(reinterpret_cast<char*>(ifr.ifr_name),
           sizeof(ifr.ifr_name), ETH_PORT);
  if (ioctl(sock, SIOCGIFINDEX, &ifr) != 0) {
    perror("Failed to get ifindex for ethernet port.");
    exit(1);
  }
  return ifr.ifr_ifindex;
}

bool WanUp() {
  std::string if_status;
  std::string stat_file = "/sys/class/net/" + wan_interface + "/operstate";
  ReadFile(stat_file, &if_status);
  if (if_status.compare(0, 2, "up") == 0)  // compare first 2 characters.
    return true;
  return false;
}

// Returns 0 if not contacted.
// Otherwise the contact time in seconds since 1970.
int64_t AcsContacted() {
  struct stat stat_buf;
  memset(&stat_buf, 0, sizeof(stat_buf));
  if (stat(acs_contact_file.c_str(), &stat_buf) < 0)
    return 0;
  return stat_buf.st_mtime;
}

int64_t Uptime() {
  std::string data;
  float up, idle;
  ReadFile("/proc/uptime", &data);
  if (sscanf(data.c_str(), "%f %f", &up, &idle) != 2) {
    return 0;
  }
  return static_cast<int64_t>(up);
}

std::string IPAddress() {
  std::ifstream infile;
  infile.open("/proc/net/if_inet6");

  if (!infile.good()) {
    perror("error reading ipv6 from file");
    exit(1);
  }

  std::string line;
  int found = 0;
  while (!infile.eof()) {
    getline(infile, line);
    // Want Ipv6 address on man interface
    if (line.find("man") == std::string::npos) {
      continue;
    }
    // Avoid local ipv6
    if (line.substr(0, 4) == "0100" || // Discard prefix RFC 6666
        line.substr(0, 2) == "fc" || // Unique local addresses
        line.substr(0, 2) == "fd" ||
        line.substr(0, 4) == "fe80" || // Link-local addresses
        line.substr(0, 4) == "fec0") { // Old, deprecated local address range
      continue;
    }
    found = 1;
    break;
  }

  infile.close();
  if (!found || line.size() < 32) {
    perror("ipv6 address on man not found in file");
    return "::1";
  }

  // Add colons
  std::stringstream ipv6;
  line = line.substr(0, 32);
  for (unsigned int i = 0; i < line.size(); i++) {
    if (i != 0 && i % 4 == 0) {
      ipv6 << ':';
    }
    ipv6 << line[i];
  }

  // Format canonically
  struct in6_addr ipv6_struct;
  if (!inet_pton(AF_INET6, ipv6.str().c_str(), &ipv6_struct)) {
    std::string errmsg = "unable to parse ipv6 address to inet_pton: " +
        ipv6.str();
    perror(errmsg.c_str());
    exit(1);
  }
  char address[INET6_ADDRSTRLEN];
  if (!inet_ntop(AF_INET6, &ipv6_struct, address, INET6_ADDRSTRLEN)) {
    std::string errmsg = "unable to parse ipv6 address from inet_pton struct "
        "created from: " + ipv6.str();
    perror(errmsg.c_str());
    exit(1);
  }

  std::string result(address);
  return result;
}

int64_t RequestedONUChannel() {
  int64_t ret = -1;
  std::string req_channel = "";
  ReadFile("/sys/devices/platform/gpon/misc/laserChannel", &req_channel);
  std::istringstream(req_channel) >> ret;
  return ret;
}

int64_t CurrentONUChannel() {
  int64_t ret = -1;
  // Read current channel from I2C byte
  std::shared_ptr<FILE> pipe(popen("i2cget -y 0 0x51 0x91", "r"), pclose);
  if (pipe) {
    char buffer[128];
    if (fgets(buffer, 128, pipe.get()) != NULL) {
      std::istringstream(buffer) >> std::hex >> ret;
    }
  }
  return ret;
}

void MakePacket(std::vector<uint8_t>* pkt) {
  devstatus::Status status;

  int64_t acs_contact_time = AcsContacted();

  status.set_wan_connected(WanUp());
  status.set_acs_contacted(acs_contact_time != 0);
  status.set_acs_contact_time(acs_contact_time);
  status.set_uptime(Uptime());
  status.set_serial(serial_number);
  status.set_ipv6(IPAddress());
  status.set_requested_channel(RequestedONUChannel());
  status.set_current_channel(CurrentONUChannel());

  pkt->resize(status.ByteSize());
  status.SerializeToArray(&(*pkt)[0], status.ByteSize());
}

int MakeSocket() {
  int sock = socket(PF_INET6, SOCK_DGRAM, 0);
  if (sock == -1) {
    perror("can't open socket");
    exit(1);
  }
  int if_index = GetIfIndex(sock);
  if (setsockopt(sock, IPPROTO_IPV6, IPV6_MULTICAST_IF,
                 reinterpret_cast<char*>(&if_index), sizeof(if_index)) != 0) {
    perror("Failed to setsockopt.");
    exit(1);
  }
  return sock;
}

int main(int argc, char** argv) {
  std::vector<uint8_t> pkt;
  int opt;

  while ((opt = getopt(argc, argv, optstring)) != -1) {
    switch (opt) {
      case 'i':
        wan_interface = std::string(optarg);
        break;

      case 's':
        serial_number = std::string(optarg);
        break;

      case 'a':
        acs_contact_file = std::string(optarg);
        break;

      default:
        printf("Unknown option: %d\n", opt);
        usage();
        break;
    }
  }

  if (wan_interface.empty() || serial_number.empty() ||
      acs_contact_file.empty()) {
    usage();
    return 0;
  }

  int sock = MakeSocket();
  struct sockaddr_in6 sin6;
  memset(&sin6, 0, sizeof(sin6));
  sin6.sin6_family = AF_INET6;
  sin6.sin6_port = htons(61453);
  if (inet_pton(AF_INET6, multicast_addr.c_str(), &sin6.sin6_addr) != 1) {
    perror("inet_pton failed: ");
    exit(-1);
  }

  for (;;) {
    pkt.clear();
    MakePacket(&pkt);
    int written = sendto(sock, &pkt[0], pkt.size(), 0,
                         (struct sockaddr*)&sin6, sizeof(sin6));
    if (written < 0) {
      perror("sendto: ");
      printf("pkt.size()=%d\n", (int)pkt.size());
    }
    sleep(STAT_INTERVAL+1);
  }
  return 0;
}