/*

 * filetransfer.c

 *

 * Copyrigth (C) 2010 Nicolas Cornu <nicolas.cornu@ensi-bourges.fr>

 *

 * 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 2 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

 */

#include "config.h"

#include <glib.h>

#include <glib/gstdio.h>

#include <string.h>

#include <mcabber/modules.h>

#include <mcabber/utils.h>

#include <mcabber/xmpp_helper.h>

#include <mcabber/settings.h>

#include <mcabber/logprint.h>

#include <mcabber/compl.h>

#include <mcabber/commands.h>

#include <mcabber/roster.h>

#include <jingle/jingle.h>

#include <jingle/check.h>

#include <jingle/register.h>

#include <jingle/sessions.h>

#include <jingle/send.h>

#include "filetransfer.h"

static gconstpointer newfrommessage(JingleContent *cn, GError **err);

static JingleHandleStatus handle(JingleAction action, gconstpointer data,

                                 LmMessageNode *node, GError **err);

static void tomessage(gconstpointer data, LmMessageNode *node);

static gboolean handle_data(gconstpointer data, const gchar *data2, guint len);

static void start(session_content *sc);

static void send(session_content *sc);

static void stop(gconstpointer data);

static gchar* info(gconstpointer data);

static void jingle_ft_init(void);

static void jingle_ft_uninit(void);

// Return must be free

static gchar *_convert_size(guint64 size);

static int _next_index(void);

static void _free(JingleFT *jft);

static gboolean _check_hash(const gchar *hash1, GChecksum *md5);

static gboolean _is_md5_hash(const gchar *hash);

static void _jft_send(char **args, JingleFT *jft);

static void _jft_info(char **args);

static void _jft_flush(char **args);

static JingleFT* _new(const gchar *name);

const gchar *deps[] = { "jingle", NULL };

static GSList *info_list = NULL;

static guint jft_cid = 0;

const gchar* strstate[] = {

  "PENDING",

  "STARTING",

  "ENDING",

  "REJECT",

  "ERROR"

};

static JingleAppFuncs funcs = {

  .newfrommessage   = newfrommessage,

  .handle           = handle,

  .tomessage        = tomessage,

  .handle_data      = handle_data,

  .start            = start,

  .send             = send,

  .stop             = stop,

  .info             = info

};

module_info_t info_jingle_ft = {

  .branch          = MCABBER_BRANCH,

  .api             = MCABBER_API_VERSION,

  .version         = PROJECT_VERSION,

  .description     = "Jingle File Transfer (XEP-0234)\n",

  .requires        = deps,

  .init            = jingle_ft_init,

  .uninit          = jingle_ft_uninit,

  .next            = NULL,

};

#ifdef MCABBER_API_HAVE_CMD_ID

static gpointer jft_cmdid;

#endif

/**

 * @brief Check if a node description with xmlns of JFT is correct

 *

 * @param cn the jinglecontent a node description

 * @param err contain an error of the domain JINGLE_CHECK_ERROR

 * @return a gconstpointer, which is a new allocated JingleFT

 */

static gconstpointer newfrommessage(JingleContent *cn, GError **err)

{

  JingleFT *ft = NULL;

  LmMessageNode *node;

  gint64 tmpsize;

  const gchar *datestr, *sizestr;

  node = lm_message_node_get_child(cn->description, "offer");

  if (!node) {

    g_set_error(err, JINGLE_CHECK_ERROR, JINGLE_CHECK_ERROR_MISSING,

                "the offer element is missing");

    return NULL;

  }

  node = lm_message_node_get_child(node, "file");

  if (!node) {

    g_set_error(err, JINGLE_CHECK_ERROR, JINGLE_CHECK_ERROR_MISSING,

                "the file element is missing");

    return NULL;

  }

  if (g_strcmp0(lm_message_node_get_attribute(node, "xmlns"), NS_SI_FT)) {

    g_set_error(err, JINGLE_CHECK_ERROR, JINGLE_CHECK_ERROR_MISSING,

                "the file transfer offer has an invalid/unsupported namespace");

    return NULL;

  }

  ft = g_new0(JingleFT, 1);

  datestr  = lm_message_node_get_attribute(node, "date");

  ft->hash = (gchar *) lm_message_node_get_attribute(node, "hash");

  ft->name = (gchar *) lm_message_node_get_attribute(node, "name");

  sizestr  = lm_message_node_get_attribute(node, "size");

  ft->transmit = 0;

  ft->dir = JINGLE_FT_INCOMING;

  if (!ft->name || !sizestr) {

    g_set_error(err, JINGLE_CHECK_ERROR, JINGLE_CHECK_ERROR_MISSING,

                "an attribute of the file element is missing");

    g_free(ft);

    return NULL;

  }

  ft->date = from_iso8601(datestr, 1);

  tmpsize = g_ascii_strtoll(sizestr, NULL, 10);

  // the size attribute is a xs:integer an therefore can be negative.

  if (tmpsize < 0) {

    g_set_error(err, JINGLE_CHECK_ERROR, JINGLE_CHECK_ERROR_BADVALUE,

                "the offered file has a negative size");

    g_free(ft);

    return NULL;

  }

  ft->size = tmpsize;

  ft->name = g_path_get_basename(ft->name);

  if (settings_opt_get("jingle_ft_dir") != NULL)

    ft->name = g_build_filename(settings_opt_get("jingle_ft_dir"), ft->name, NULL);

  else

    ft->name = g_build_filename("/tmp", ft->name, NULL);

  if (!g_strcmp0(ft->name, ".")) {

    g_set_error(err, JINGLE_CHECK_ERROR, JINGLE_CHECK_ERROR_BADVALUE,

                "the offered file has an invalid filename");

    g_free(ft->name);

    g_free(ft);

    return NULL;

  }

  // check if the md5 hash is valid ([a-fA-F0-9){32})

  if (ft->hash != NULL && (strlen(ft->hash) != 32 || !_is_md5_hash(ft->hash))) {

    g_set_error(err, JINGLE_CHECK_ERROR, JINGLE_CHECK_ERROR_BADVALUE,

                "the offered file has an invalid hash");

    g_free(ft->name);

    g_free(ft);

    return NULL;

  }

  ft->hash = g_strndup(ft->hash, 32);

  {

    JingleFTInfo *jfti = g_new0(JingleFTInfo, 1);

    jfti->index = _next_index();

    jfti->jft = ft;

    info_list = g_slist_append(info_list, jfti);

  }

  return (gconstpointer) ft;

}

/**

 * @brief A function to handle incoming jingle action

 * @param action The action which have been received

 * @param data   Contain the JingleFT of the content concerned

 * @param node   The node himself

 * @return       TRUE if the action was handled, FALSE otherwise

 */

static JingleHandleStatus handle(JingleAction action, gconstpointer data,

                                 LmMessageNode *node, GError **err)

{

  if (action == JINGLE_SESSION_INFO) {

    if (!g_strcmp0(lm_message_node_get_attribute(node, "xmlns"),

                   NS_JINGLE_APP_FT_INFO)

        && !g_strcmp0(node->name, "hash")) {

      ((JingleFT *)data)->hash = g_strdup(lm_message_node_get_value(node));

      return JINGLE_STATUS_HANDLED;

    }

    return JINGLE_STATUS_NOT_HANDLED;

  }

  return JINGLE_STATUS_NOT_HANDLED;

}

static gboolean _is_md5_hash(const gchar *hash)

{

  int i = 0;

  for (i = 0; i < 32 && hash[i]; i++)

    if (!g_ascii_isxdigit(hash[i])) break;

  if (i == 32)

    return TRUE;

  else

    return FALSE;

}

static gboolean handle_data(gconstpointer jingleft, const gchar *data, guint len)

{

  JingleFT *jft = (JingleFT *) jingleft;

  GError *err = NULL;

  GIOStatus status;

  gsize bytes_written = 0;

  if (jft->dir != JINGLE_FT_INCOMING)

    return FALSE;

  if (jft->md5 == NULL) {

    jft->md5 = g_checksum_new(G_CHECKSUM_MD5);

  }

  g_checksum_update(jft->md5, (guchar*)data, (gsize)len);

  // TODO: check if the file already exist or if it was created

  // during the call to jingle_ft_check and handle_data

  if (jft->outfile == NULL) {

    jft->outfile = g_io_channel_new_file(jft->name, "w", &err);

    if (jft->outfile == NULL || err != NULL) {

      scr_LogPrint(LPRINT_LOGNORM, "Jingle File Transfer: %s %s", err->message,

                   jft->name);

    //TODO: propagate the GError ?

      g_error_free(err);

      return FALSE;

    }

    jft->state = JINGLE_FT_STARTING;

    status = g_io_channel_set_encoding(jft->outfile, NULL, &err);

    if (status != G_IO_STATUS_NORMAL || err != NULL) {

     scr_LogPrint(LPRINT_LOGNORM, "Jingle File Transfer: %s %s", err->message,

                  jft->name);

     g_error_free(err);

     return FALSE;

   }

  }

  jft->state = JINGLE_FT_STARTING;

  status = g_io_channel_write_chars(jft->outfile, data, (gssize) len,

                                    &bytes_written, &err);

  if (status != G_IO_STATUS_NORMAL || err != NULL) {

     scr_LogPrint(LPRINT_LOGNORM, "Jingle File Transfer: %s %s", err->message,

                  jft->name);

    g_error_free(err);

    return FALSE;

  }

  status = g_io_channel_flush(jft->outfile, &err);

  if (status != G_IO_STATUS_NORMAL || err != NULL) {

    scr_LogPrint(LPRINT_LOGNORM, "Jingle File Transfer: %s %s", err->message,

                 jft->name);

    g_error_free(err);

    return FALSE;

  }

  if (bytes_written != len) {

    // not supposed to happen if status is normal, unless outfile is non-blocking

    return FALSE;

  }

  jft->transmit += len;

  return TRUE;

}

static int _next_index(void)

{

  static int a = 0;

  return ++a;

}

static void _jft_info(char **args)

{

  GSList *el = info_list;

  if (!info_list)

    scr_LogPrint(LPRINT_LOGNORM, "JFT: no file");

  for (el = info_list; el; el = el->next) {

    JingleFTInfo *jftio = el->data;

    JingleFT *jft = jftio->jft;

    gchar *strsize = _convert_size(jft->size);

    const gchar *dir = (jft->dir == JINGLE_FT_INCOMING) ? "<==" : "-->";

    gfloat percent = (gfloat)jft->size ? 

                       ((gfloat)jft->transmit / (gfloat)jft->size) * 100 :

                       0;

    const gchar *state = strstate[jft->state];

    const gchar *desc = jft->desc ? jft->desc : "";

    const gchar *hash = "";

    if (jft->dir == JINGLE_FT_INCOMING &&

        jft->state == JINGLE_FT_ENDING) {

      if (_check_hash(jft->hash, jft->md5) == FALSE)

        hash = "corrupt";

      else

        hash = "checked";

    }

    scr_LogPrint(LPRINT_LOGNORM, "[%i]%s %s %s %.2f%%: %s %s %s", jftio->index, 

                 dir, jftio->jft->name, strsize, percent, desc, state, hash);

    g_free(strsize);

  }

}

static void _jft_flush(char **args)

{

  GSList *el, *el2 = info_list;

  int count = 0;

  el = info_list;

  while (el) {

    JingleFTInfo *jftinf;

    jftinf = el->data;

    if (jftinf->jft->state == JINGLE_FT_ERROR ||

        jftinf->jft->state == JINGLE_FT_REJECT ||

        jftinf->jft->state == JINGLE_FT_ENDING) {

      count++;

      _free(jftinf->jft);

      info_list = g_slist_delete_link(info_list, el);

      if (info_list == NULL)

        break;

      el = el2;

      continue;

    }

    el2 = el;

    el = el->next;

  }

  scr_LogPrint(LPRINT_LOGNORM, "JFT: %i file%s removed", count, (count>1) ? "s" : "");

}

static JingleFT* _new(const gchar *name)

{

  struct stat fileinfo;

  GError *err = NULL;

  gchar *filename = expand_filename(name); // expand ~ to HOME

  JingleFT *jft = g_new0(JingleFT, 1);

  jft->desc = g_strdup(name);

  jft->type = JINGLE_FT_OFFER;

  jft->name = g_path_get_basename(filename);

  jft->transmit = 0;

  jft->hash = NULL;

  jft->md5 = NULL;

  jft->state = JINGLE_FT_PENDING;

  jft->dir = JINGLE_FT_OUTGOING;

  jft->date = 0;

  jft->size = 0;

  // Add the jft to the list

  JingleFTInfo *jftinf = g_new0(JingleFTInfo, 1);

  jftinf->index = _next_index();

  jftinf->jft = jft;

  info_list = g_slist_append(info_list, jftinf);

  if (g_stat(filename, &fileinfo) != 0) {

    scr_LogPrint(LPRINT_LOGNORM, "Jingle File Transfer: unable to stat %s",

                 filename);