/*
    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, see <http://www.gnu.org/licenses/>.

        Authors: 	Domas Mituzas, Facebook ( domas at fb dot com )
                        Mark Leith, Oracle Corporation (mark dot leith at oracle
   dot com) Andrew Hutchings, SkySQL (andrew at skysql dot com)

*/

#include <glib.h>
#include <glib/gstdio.h>
#include <my_global.h>
#include <mysql.h>
#include <my_sys.h>
#include <mysqld_error.h>
#include <sql_common.h>
#include <string.h>
#include <zlib.h>
#include "mydumper.h"
#include "binlog.h"

#define BINLOG_MAGIC "\xfe\x62\x69\x6e"

#define EVENT_HEADER_LENGTH 19
#define EVENT_ROTATE_FIXED_LENGTH 8

enum event_postions {
  EVENT_TIMESTAMP_POSITION = 0,
  EVENT_TYPE_POSITION = 4,
  EVENT_SERVERID_POSITION = 5,
  EVENT_LENGTH_POSITION = 9,
  EVENT_NEXT_POSITION = 13,
  EVENT_FLAGS_POSITION = 17,
  EVENT_EXTRA_FLAGS_POSITION =
      19 // currently unused in v4 binlogs, but a good marker for end of header
};

enum event_type {
  ROTATE_EVENT = 4,
  FORMAT_DESCRIPTION_EVENT = 15,
  EVENT_TOO_SHORT = 254 // arbitrary high number, in 5.1 the max event type
                        // number is 27 so this should be fine for a while
};

extern int compress_output;
extern gboolean daemon_mode;
extern gboolean shutdown_triggered;

FILE *new_binlog_file(char *binlog_file, const char *binlog_dir);
void close_binlog_file(FILE *outfile);
char *rotate_file_name(const char *buf);

void get_binlogs(MYSQL *conn, struct configuration *conf) {
  // TODO: find logs we already have, use start position based on position of
  // last log.
  MYSQL_RES *result;
  MYSQL_ROW row;
  char *last_filename = NULL;
  guint64 last_position;

  // Only snapshot dump the binlogs once in daemon mode
  static gboolean got_binlogs = FALSE;
  if (got_binlogs)
    return;
  else
    got_binlogs = TRUE;

  if (mysql_query(conn, "SHOW MASTER STATUS")) {
    g_critical("Error: Could not execute query: %s", mysql_error(conn));
    return;
  }

  result = mysql_store_result(conn);
  if ((row = mysql_fetch_row(result))) {
    last_filename = g_strdup(row[0]);
    last_position = strtoll(row[1], NULL, 10);
  } else {
    g_critical("Error: Could not obtain binary log stop position");
    if (last_filename != NULL)
      g_free(last_filename);
    return;
  }
  mysql_free_result(result);

  if (mysql_query(conn, "SHOW BINARY LOGS")) {
    g_critical("Error: Could not execute query: %s", mysql_error(conn));
    if (last_filename != NULL)
      g_free(last_filename);
    return;
  }

  result = mysql_store_result(conn);
  while ((row = mysql_fetch_row(result))) {
    struct job *j = g_new0(struct job, 1);
    struct binlog_job *bj = g_new0(struct binlog_job, 1);
    j->job_data = (void *)bj;
    bj->filename = g_strdup(row[0]);
    bj->start_position = 4;
    bj->stop_position =
        (!strcasecmp(row[0], last_filename)) ? last_position : 0;
    j->conf = conf;
    j->type = JOB_BINLOG;
    g_async_queue_push(conf->queue, j);
  }
  mysql_free_result(result);
  if (last_filename != NULL)
    g_free(last_filename);
}

void get_binlog_file(MYSQL *conn, char *binlog_file,
                     const char *binlog_directory, guint64 start_position,
                     guint64 stop_position, gboolean continuous) {
  // set serverID = max serverID - threadID to try an eliminate conflicts,
  // 0 is bad because mysqld will disconnect at the end of the last log
  // dupes aren't too bad since it is up to the client to check for them
  uchar buf[128];
  // We need to read the raw network packets
  NET *net;
  net = &conn->net;
  unsigned long len;
  FILE *outfile;
  guint32 event_type;
  gboolean read_error = FALSE;
  gboolean read_end = FALSE;
  gboolean rotated = FALSE;
  guint32 server_id = G_MAXUINT32 - mysql_thread_id(conn);
  guint64 pos_counter = 0;

  int4store(buf, (guint32)start_position);
  // Binlog flags (2 byte int)
  int2store(buf + 4, 0);
  // ServerID
  int4store(buf + 6, server_id);
  memcpy(buf + 10, binlog_file, strlen(binlog_file));
#if MYSQL_VERSION_ID < 50100
  if (simple_command(conn, COM_BINLOG_DUMP, (const char *)buf,
#else
  if (simple_command(conn, COM_BINLOG_DUMP, buf,
#endif
                     strlen(binlog_file) + 10, 1)) {
    g_critical("Error: binlog: Critical error whilst requesting binary log");
  }

  while (1) {
    outfile = new_binlog_file(binlog_file, binlog_directory);
    if (outfile == NULL) {
      g_critical("Error: binlog: Could not create binlog file '%s', %d",
                 binlog_file, errno);
      return;
    }

    write_binlog(outfile, BINLOG_MAGIC, 4);
    while (1) {
      len = 0;
      if (net->vio != 0)
        len = my_net_read(net);
      if ((len == 0) || (len == ~(unsigned long)0)) {
        // Net timeout (set to 1 second)
        if (mysql_errno(conn) == ER_NET_READ_INTERRUPTED) {
          if (shutdown_triggered) {
            close_binlog_file(outfile);
            return;
          } else {
            continue;
          }
          // A real error
        } else {
          g_critical("Error: binlog: Network packet read error getting binlog "
                     "file: %s",
                     binlog_file);
          close_binlog_file(outfile);
          return;
        }
      }
      if (len < 8 && net->read_pos[0]) {
        // end of data
        break;
      }
      pos_counter += len;
      event_type = get_event((const char *)net->read_pos + 1, len - 1);
      switch (event_type) {
      case EVENT_TOO_SHORT:
        g_critical("Error: binlog: Event too short in binlog file: %s",
                   binlog_file);
        read_error = TRUE;
        break;
      case ROTATE_EVENT:
        if (rotated) {
          read_end = TRUE;
        } else {
          len = 1;
          rotated = TRUE;
        }
        break;
      default:
        // if we get this far this is a normal event to record
        break;
      }
      if (read_error)
        break;
      write_binlog(outfile, (const char *)net->read_pos + 1, len - 1);
      if (read_end) {
        if (!continuous) {
          break;
        } else {
          g_free(binlog_file);
          binlog_file = rotate_file_name((const char *)net->read_pos + 1);
          break;
        }
      }
      // stop if we are at requested end of last log
      if ((stop_position > 0) && (pos_counter >= stop_position))
        break;
    }
    close_binlog_file(outfile);
    if ((!continuous) || (!read_end))
      break;

    if (continuous && read_end) {
      read_end = FALSE;
      rotated = FALSE;
    }
  }
}

char *rotate_file_name(const char *buf) {
  guint32 event_length = 0;

  // event length is 4 bytes at position 9
  event_length = uint4korr(&buf[EVENT_LENGTH_POSITION]);
  // event length includes the header, plus a rotate event has a fixed 8byte
  // part we don't need
  event_length = event_length - EVENT_HEADER_LENGTH - EVENT_ROTATE_FIXED_LENGTH;

  return g_strndup(&buf[EVENT_HEADER_LENGTH + EVENT_ROTATE_FIXED_LENGTH],
                   event_length);
}

FILE *new_binlog_file(char *binlog_file, const char *binlog_dir) {
  FILE *outfile;
  char *filename;

  if (!compress_output) {
    filename = g_strdup_printf("%s/%s", binlog_dir, binlog_file);
    outfile = g_fopen(filename, "w");
  } else {
    filename = g_strdup_printf("%s/%s.gz", binlog_dir, binlog_file);
    outfile = (void *)gzopen(filename, "w");
  }
  g_free(filename);

  return outfile;
}

void close_binlog_file(FILE *outfile) {
  if (!compress_output)
    fclose(outfile);
  else
    gzclose((gzFile)outfile);
}

unsigned int get_event(const char *buf, unsigned int len) {
  if (len < EVENT_TYPE_POSITION)
    return EVENT_TOO_SHORT;
  return buf[EVENT_TYPE_POSITION];

  // TODO: Would be good if we can check for valid event type, unfortunately
  // this check can change from version to version
}

void write_binlog(FILE *file, const char *data, guint64 len) {
  int err;

  if (len > 0) {
    int write_result;

    if (!compress_output)
      write_result = write(fileno(file), data, len);
    else
      write_result = gzwrite((gzFile)file, data, len);

    if (write_result <= 0) {
      if (!compress_output)
        g_critical("Error: binlog: Error writing binary log: %s",
                   strerror(errno));
      else
        g_critical("Error: binlog: Error writing compressed binary log: %s",
                   gzerror((gzFile)file, &err));
    }
  }
}