/* notmuch - Not much of an email program, (just index and search)
 *
 * Copyright © 2023 Felipe Contreras
 * Copyright © 2024 David Bremner
 *
 * 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 https://www.gnu.org/licenses/ .
 *
 * Authors: Felipe Contreras
 *	    David Bremner <david@tethera.net>
 */

#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <notmuch.h>
#include "notmuch-client.h"
#include "path-util.h"
#include "hex-escape.h"
#include "string-util.h"

#define ASSERT(x) assert((x))

/* File scope globals */
const char *alias = NULL;
const char *nm_dir = NULL;
const char *url = NULL;
const char* debug_flags = NULL;
unsigned long lastmod;
notmuch_database_t *db;
FILE *log_file = NULL;

static void
flog (const char *format, ...) {
    va_list va_args;

    if (log_file) {
	va_start (va_args, format);
	vfprintf (log_file, format, va_args);
	fflush (log_file);
	va_end (va_args);
    }
}

static unsigned long read_lastmod (const void *ctx, const char *dir) {
    char *filename = NULL;
    unsigned long num = 0;

    FILE *in;

    ASSERT(filename = talloc_asprintf (ctx, "%s/lastmod", dir));

    in = fopen (filename, "r");
    if (in) {
	ASSERT(fscanf (in, "%zu", &num) == 1);
    } else {
	if (errno != ENOENT) {
	    fprintf (stderr, "error opening lastmod file");
	    exit(EXIT_FAILURE);
	}
    }

    flog ("loaded lastmod = %zu\n", num);

    return num;
}

static void
store_lastmod (notmuch_database_t *notmuch, const char *dir) {
    char *filename = NULL;
    FILE *out;

    ASSERT(filename = talloc_asprintf (notmuch, "%s/lastmod", dir));

    ASSERT(out = fopen (filename, "w"));

    ASSERT(fprintf (out, "%zu\n", notmuch_database_get_revision (notmuch, NULL)) > 0);
}

static void
read_one_line (FILE *stream, char **line_p, size_t *len_p) {
    ssize_t nread;

    nread = getline(line_p, len_p, stream);
    if (nread < 0) {
	perror ("getline");
	exit (EXIT_FAILURE);
    }
    ASSERT(line_p);

    chomp_newline(*line_p);
}

static const char*
shell2string (const char* command) {
    FILE *out;
    char *line = NULL;
    size_t len;

    out = popen (command,"r");
    if (out == NULL) {
	perror("popen");
	exit(EXIT_FAILURE);
    }

    read_one_line (out, &line, &len);
    return line;
}

static void
wr_data(const char *data) {
    printf ("data %zu\n", strlen(data));
    fputs (data, stdout);
}

static void
cmd_capabilities () {
    fputs("import\nexport\nrefspec refs/heads/*:refs/notmuch/*\n\n", stdout);
    fflush (stdout);
}

static void
cmd_list () {
    unsigned long current_lastmod;
    current_lastmod = notmuch_database_get_revision (db, NULL);
    printf("? refs/heads/master%s\n\n",
	   lastmod == current_lastmod ? " unchanged" : "");
    fflush (stdout);
}

static void
usage() {
    fprintf (stderr, "usage: git-remote-nm ALIAS URL\n");
    exit(EXIT_FAILURE);
}

static void
cmd_import (notmuch_database_t *notmuch) {
    const char* ident = NULL;
    const char* lastmod_str = NULL;
    notmuch_messages_t *messages;
    notmuch_status_t status;
    notmuch_query_t *query;
    char *mid_buf = NULL;
    size_t mid_buf_len = 0;

    ident = shell2string("git var GIT_COMMITTER_IDENT");

    printf ("feature done\ncommit refs/notmuch/master\nmark :1\ncommitter %s\n", ident);

    ASSERT(lastmod_str = talloc_asprintf (notmuch, "lastmod: %zu\n", lastmod));
    wr_data (lastmod_str);
    if (lastmod > 0)
	puts("from refs/notmuch/master^0");
    puts("deleteall");

    status = notmuch_query_create_with_syntax (notmuch,
					       "",
					       NOTMUCH_QUERY_SYNTAX_XAPIAN,
					       &query);

    if (print_status_database ("git-remote-nm", notmuch, status))
	exit(EXIT_FAILURE);

    if (debug_flags && strchr (debug_flags, 's'))
	notmuch_query_set_sort (query, NOTMUCH_SORT_NEWEST_FIRST);
    else
	notmuch_query_set_sort (query, NOTMUCH_SORT_UNSORTED);

    status = notmuch_query_search_messages (query, &messages);
    if (print_status_query ("git-remote-nm", query, status))
	exit(EXIT_FAILURE);

    for (;
	 notmuch_messages_valid (messages);
	 notmuch_messages_move_to_next (messages)) {

	const char* tag_buf = "";
	const char* mid;

	const char* hash;

	notmuch_message_t *message = notmuch_messages_get (messages);
	mid = notmuch_message_get_message_id (message);

	if (hex_encode (notmuch, mid, &mid_buf, &mid_buf_len) != HEX_SUCCESS) {
	    fprintf (stderr, "Error: failed to hex-encode message-id %s\n", mid);
	    exit(EXIT_FAILURE);
	}

	/* we can't use _notmuch_sha1_from_string because we don't want
	 * to include the null terminator */
	GChecksum *sha1;
	sha1 = g_checksum_new (G_CHECKSUM_SHA1);
	g_checksum_update (sha1, (const guchar *) mid, strlen (mid));
	hash = g_checksum_get_string (sha1);
	printf ("M 644 inline %2.2s/%2.2s/%s/tags\n", hash, hash+2, mid_buf);

	g_checksum_free (sha1);

	for (notmuch_tags_t *tags = notmuch_message_get_tags (message);
	     notmuch_tags_valid (tags);
	     notmuch_tags_move_to_next (tags)) {
	    const char *tag_str = notmuch_tags_get (tags);
	    ASSERT(tag_buf=talloc_asprintf (message, "%s%s\n", tag_buf, tag_str));
	}
	wr_data (tag_buf);
	notmuch_message_destroy (message);
    }
    puts("");
    puts("done");
    fflush (stdout);
    store_lastmod(notmuch, nm_dir);
}

int
main (int argc, char *argv[])
{
  notmuch_status_t status;
  char *status_string = NULL;
  const char* git_dir;
  ssize_t nread;
  size_t len = 0;
  const char *log_file_name;

  char *line = NULL;

  debug_flags = getenv ("GIT_REMOTE_NM_DEBUG");
  log_file_name = getenv ("GIT_REMOTE_NM_LOG");

  if (log_file_name)
      log_file = fopen (log_file_name, "w");

  if (argc != 3)
    usage();
  /* setup globals */
  alias = argv[1];
  url = argv[2];

  status = notmuch_database_open_with_config (NULL,
					      NOTMUCH_DATABASE_MODE_READ_WRITE,
					      NULL,
					      NULL,
					      &db,
					      &status_string);
  if (status) {
      if (status_string) {
	  fputs (status_string, stderr);
	  free (status_string);
	  status_string = NULL;
      }
      return EXIT_FAILURE;
  }

  git_dir = getenv ("GIT_DIR");
  if (! git_dir) {
      fprintf (stderr, "GIT_DIR not set\n");
      exit(EXIT_FAILURE);
  }
  flog ("GIT_DIR=%s\n", git_dir);

  ASSERT(nm_dir = talloc_asprintf(db, "%s/%s", git_dir, "notmuch"));

  status = mkdir_recursive (db, nm_dir, 0700, &status_string);
  if (status) {
      if (status_string)
	  fputs(status_string, stderr);

      exit (EXIT_FAILURE);
  }

  lastmod = read_lastmod (db, nm_dir);

  while ((nread = getline(&line, &len, stdin)) != -1) {
      size_t count=0;
      char *s = line;
      flog ("command = %s\n", line);

      /* skip leading space */
      while (*s && isspace(*s))  s++;
      while (s[count]  && ! isspace(s[count])) count++;

      if (count == 0)
	  break;

      if (STRNCMP_LITERAL (s, "capabilities")== 0)
	  cmd_capabilities ();
      else if (STRNCMP_LITERAL (s, "import") == 0)
	  cmd_import (db);
      else if (STRNCMP_LITERAL (s, "list") == 0)
	  cmd_list ();

      fflush(stdout);
      flog ("finished command = %s\n", s);
  }
  flog ("finished loop\n");

  notmuch_database_destroy (db);
}