#include "proxy.h"
#include "algo_utils.h"
#include "packet.h"

struct dup2_ctx {
  uint16_t recv_id;
  uint16_t emit_id;
};

void algo_dup2_init(struct evt_core_ctx* ctx, struct algo_ctx* app_ctx, struct algo_params* ap) {
  app_ctx->misc = malloc(sizeof(struct dup2_ctx));
  if (app_ctx->misc == NULL) {
    perror("malloc failed in algo dup2 init");
    exit(EXIT_FAILURE);
  }
  memset(app_ctx->misc, 0, sizeof(struct dup2_ctx));
}

int algo_dup2_on_stream(struct evt_core_ctx* ctx, struct evt_core_fdinfo* fdinfo, struct buffer_packet* bp) {
  char url[256];
  struct evt_core_fdinfo *to_fdinfo = NULL;
  struct algo_ctx* app_ctx = fdinfo->cat->app_ctx;
  union abstract_packet *ap = (union abstract_packet*) &bp->ip, *ap_prev = NULL;
  struct dup2_ctx* dup2c = app_ctx->misc;
  uint16_t id = 0;

  switch (ap->fmt.headers.cmd) {
  case CMD_UDP_METADATA_THUNDER:
    id = ap->fmt.content.udp_metadata_thunder.id;
    mv_buffer_rtof(&app_ctx->br, fdinfo);

    // Check that received identifier has not been delivered
    if (ring_ge(dup2c->recv_id, id)) {
      mv_buffer_atof(&app_ctx->br, fdinfo);
      return 0;
    }

    // Update delivered identifier
    dup2c->recv_id = id;

    // 1. Find destination
    ap_prev = (union abstract_packet*) get_app_buffer(&app_ctx->br, fdinfo)->ip;
    sprintf(url, "udp:write:127.0.0.1:%d", ap_prev->fmt.content.udp_encapsulated.port);
    to_fdinfo = evt_core_get_from_url (ctx, url);
    if (to_fdinfo == NULL) {
      fprintf(stderr, "No fd for URL %s in tcp-read. Dropping packet :( \n", url);
      mv_buffer_atof (&app_ctx->br, fdinfo);
      return 1;
    }

    // 2. Move buffer
    mv_buffer_atow (&app_ctx->br, fdinfo, to_fdinfo);
    main_on_udp_write(ctx, to_fdinfo);

    break;

  case CMD_UDP_ENCAPSULATED:
    mv_buffer_rtoa(&app_ctx->br, fdinfo, fdinfo);
    break;

  default:
    fprintf(stderr, "Unknown packet type\n");
    break;
  }

  return 1;
}

int algo_dup2_on_datagram(struct evt_core_ctx* ctx, struct evt_core_fdinfo* fdinfo, struct buffer_packet* bp) {
  struct evt_core_fdinfo *to_fdinfo = NULL;
  struct algo_ctx* app_ctx = fdinfo->cat->app_ctx;

  struct dup2_ctx* dup2c = app_ctx->misc;
  bp->ip.ap.fmt.content.clear.id = dup2c->emit_id;
  dup2c->emit_id = dup2c->emit_id + 1;

  struct evt_core_cat* cat = evt_core_get_from_cat (ctx, "tcp-write");

  for (int i = 0; i < app_ctx->ap.links; i++) {
    // 1. A whole packet has been read, we will find someone to write it
    to_fdinfo = cat->socklist->len > i ? g_array_index(cat->socklist, struct evt_core_fdinfo*, i) : NULL;
    if (to_fdinfo == NULL) {
      fprintf(stderr, "No fd for cat %s in udp-read.\n", cat->name);
      continue;
    }

    // 2. We move the buffer and notify the target
    dup_buffer_tow (&app_ctx->br, bp, to_fdinfo);
    main_on_tcp_write(ctx, to_fdinfo);
  }

  // 3. Release the buffer
  mv_buffer_rtof (&app_ctx->br, fdinfo);

  return 0;
}

int algo_dup2_on_err(struct evt_core_ctx *ctx, struct evt_core_fdinfo *fdinfo) {
  // We do nothing
  return 1;
}