/* builder-source-patch.c

 *

 * Copyright (C) 2015 Red Hat, Inc

 *

 * This file is free software; you can redistribute it and/or modify it

 * under the terms of the GNU Lesser General Public License as

 * published by the Free Software Foundation; either version 2 of the

 * License, or (at your option) any later version.

 *

 * This file 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

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public License

 * along with this program.  If not, see <http://www.gnu.org/licenses/>.

 *

 * Authors:

 *       Alexander Larsson <alexl@redhat.com>

 */

#include "config.h"

#include <string.h>

#include <fcntl.h>

#include <stdio.h>

#include <stdlib.h>

#include <sys/statfs.h>

#include "builder-flatpak-utils.h"

#include "builder-utils.h"

#include "builder-source-patch.h"

struct BuilderSourcePatch

{

  BuilderSource parent;

  char         *path;

  char        **paths;

  guint         strip_components;

  gboolean      use_git;

  gboolean      use_git_am;

  char        **options;

};

typedef struct

{

  BuilderSourceClass parent_class;

} BuilderSourcePatchClass;

G_DEFINE_TYPE (BuilderSourcePatch, builder_source_patch, BUILDER_TYPE_SOURCE);

enum {

  PROP_0,

  PROP_PATH,

  PROP_PATHS,

  PROP_STRIP_COMPONENTS,

  PROP_USE_GIT,

  PROP_OPTIONS,

  PROP_USE_GIT_AM,

  LAST_PROP

};

static void

builder_source_patch_finalize (GObject *object)

{

  BuilderSourcePatch *self = (BuilderSourcePatch *) object;

  g_free (self->path);

  g_strfreev (self->paths);

  g_strfreev (self->options);

  G_OBJECT_CLASS (builder_source_patch_parent_class)->finalize (object);

}

static void

builder_source_patch_get_property (GObject    *object,

                                   guint       prop_id,

                                   GValue     *value,

                                   GParamSpec *pspec)

{

  BuilderSourcePatch *self = BUILDER_SOURCE_PATCH (object);

  switch (prop_id)

    {

    case PROP_PATH:

      g_value_set_string (value, self->path);

      break;

    case PROP_PATHS:

      g_value_set_boxed (value, self->paths);

      break;

    case PROP_STRIP_COMPONENTS:

      g_value_set_uint (value, self->strip_components);

      break;

    case PROP_USE_GIT:

      g_value_set_boolean (value, self->use_git);

      break;

    case PROP_OPTIONS:

      g_value_set_boxed (value, self->options);

      break;

    case PROP_USE_GIT_AM:

      g_value_set_boolean (value, self->use_git_am);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

    }

}

static void

builder_source_patch_set_property (GObject      *object,

                                   guint         prop_id,

                                   const GValue *value,

                                   GParamSpec   *pspec)

{

  BuilderSourcePatch *self = BUILDER_SOURCE_PATCH (object);

  gchar **tmp;

  switch (prop_id)

    {

    case PROP_PATH:

      g_free (self->path);

      self->path = g_value_dup_string (value);

      break;

    case PROP_PATHS:

      tmp = self->paths;

      self->paths = g_strdupv (g_value_get_boxed (value));

      g_strfreev (tmp);

      break;

    case PROP_STRIP_COMPONENTS:

      self->strip_components = g_value_get_uint (value);

      break;

    case PROP_USE_GIT:

      self->use_git = g_value_get_boolean (value);

      break;

    case PROP_OPTIONS:

      tmp = self->options;

      self->options = g_strdupv (g_value_get_boxed (value));

      g_strfreev (tmp);

      break;

    case PROP_USE_GIT_AM:

      self->use_git_am = g_value_get_boolean (value);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

    }

}

static GPtrArray *

get_source_files (BuilderSourcePatch *self,

                 BuilderContext     *context,

                 GError            **error)

{

  g_autoptr(GPtrArray) res = g_ptr_array_new_with_free_func (g_object_unref);

  GFile *base_dir = BUILDER_SOURCE (self)->base_dir;

  int i;

  if ((self->path != NULL && self->path[0] != 0))

    g_ptr_array_add (res, g_file_resolve_relative_path (base_dir, self->path));

  if (self->paths != NULL)

    {

      for (i = 0; self->paths[i] != NULL; i++)

        g_ptr_array_add (res, g_file_resolve_relative_path (base_dir, self->paths[i]));

    }

  if (res->len == 0)

    {

      g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "path not specified");

      return NULL;

    }

  return g_steal_pointer (&res;;

}

static gboolean

builder_source_patch_show_deps (BuilderSource  *source,

                                GError        **error)

{

  BuilderSourcePatch *self = BUILDER_SOURCE_PATCH (source);

  int i;

  if (self->path && self->path[0] != 0)

    g_print ("%s\n", self->path);

  for (i = 0; self->paths != NULL && self->paths[i] != NULL; i++)

    g_print ("%s\n", self->paths[i]);

  return TRUE;

}

static gboolean

builder_source_patch_download (BuilderSource  *source,

                               gboolean        update_vcs,

                               BuilderContext *context,

                               GError        **error)

{

  BuilderSourcePatch *self = BUILDER_SOURCE_PATCH (source);

  g_autoptr(GPtrArray) srcs = NULL;

  int i;

  srcs = get_source_files (self, context, error);

  if (srcs == NULL)

    return FALSE;

  for (i = 0; i < srcs->len; i++)

    {

      GFile *src = g_ptr_array_index (srcs, i);

      if (!g_file_query_exists (src, NULL))

        {

          g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Can't find file at %s", self->path);

          return FALSE;

        }

    }

  return TRUE;

}

static gboolean

patch (GFile      *dir,

       gboolean    use_git,

       gboolean    use_git_am,

       const char *patch_path,

       char      **extra_options,

       GError    **error,

       ...)

{

  gboolean res;

  GPtrArray *args;

  const gchar *arg;

  va_list ap;

  int i;

  va_start(ap, error);

  args = g_ptr_array_new ();

  if (use_git) {

    g_ptr_array_add (args, "git");

    g_ptr_array_add (args, "apply");

    g_ptr_array_add (args, "-v");

  } else if (use_git_am) {

    g_ptr_array_add (args, "git");

    g_ptr_array_add (args, "am");

    g_ptr_array_add (args, "--keep-cr");

  } else {

    g_ptr_array_add (args, "patch");

  }

  for (i = 0; extra_options != NULL && extra_options[i] != NULL; i++)

    g_ptr_array_add (args, (gchar *) extra_options[i]);

  while ((arg = va_arg (ap, const gchar *)))

    g_ptr_array_add (args, (gchar *) arg);

  if (use_git || use_git_am) {

    g_ptr_array_add (args, (char *) patch_path);

  } else {

    g_ptr_array_add (args, "-i");

    g_ptr_array_add (args, (char *) patch_path);

  }

  g_ptr_array_add (args, NULL);

  res = flatpak_spawnv (dir, NULL, 0, error, (const char **) args->pdata);

  g_ptr_array_free (args, TRUE);

  va_end (ap);

  return res;

}

static gboolean

builder_source_patch_extract (BuilderSource  *source,

                              GFile          *dest,

                              BuilderOptions *build_options,

                              BuilderContext *context,

                              GError        **error)

{

  BuilderSourcePatch *self = BUILDER_SOURCE_PATCH (source);

  g_autofree char *strip_components = NULL;

  g_autoptr(GPtrArray) srcs = NULL;

  int i;

  if (self->use_git && self->use_git_am)

    {

      g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,

                   "Patch '%s' cannot be applied: Both 'use-git' and 'use-git-am' are set. Only one can be set at a time",

                   self->path);

      return FALSE;

    }

  srcs = get_source_files (self, context, error);

  if (srcs == NULL)

    return FALSE;

  strip_components = g_strdup_printf ("-p%u", self->strip_components);

  for (i = 0; i < srcs->len; i++)

    {

      GFile *patchfile = g_ptr_array_index (srcs, i);

      g_autofree char *basename = g_file_get_basename (patchfile);

      g_autofree char *patch_path = g_file_get_path (patchfile);

      g_print ("Applying patch %s\n", basename);

      if (!patch (dest, self->use_git, self->use_git_am, patch_path, self->options, error, strip_components, NULL))

        return FALSE;

    }

  return TRUE;

}

static gboolean

builder_source_patch_bundle (BuilderSource  *source,

                             BuilderContext *context,

                             GError        **error)

{

  BuilderSourcePatch *self = BUILDER_SOURCE_PATCH (source);

  GFile *manifest_base_dir = builder_context_get_base_dir (context);

  g_autoptr(GPtrArray) srcs = NULL;

  int i;

  srcs = get_source_files (self, context, error);

  if (srcs == NULL)

    return FALSE;

  for (i = 0; i < srcs->len; i++)

    {

      GFile *src = g_ptr_array_index (srcs, i);

      g_autofree char *rel_path = NULL;

      g_autoptr(GFile) destination_file = NULL;

      g_autoptr(GFile) destination_dir = NULL;

      rel_path = g_file_get_relative_path (manifest_base_dir, src);

      if (rel_path == NULL)

        {

          g_warning ("Patch %s is outside manifest tree, not bundling", flatpak_file_get_path_cached (src));

          return TRUE;

        }

      destination_file = flatpak_build_file (builder_context_get_app_dir (context),

                                             "sources/manifest", rel_path, NULL);

      destination_dir = g_file_get_parent (destination_file);

      if (!flatpak_mkdir_p (destination_dir, NULL, error))

        return FALSE;

      if (!g_file_copy (src, destination_file,

                        G_FILE_COPY_OVERWRITE,

                        NULL,

                        NULL, NULL,

                        error))

        return FALSE;

    }

  return TRUE;

}

static void

builder_source_patch_checksum (BuilderSource  *source,

                               BuilderCache   *cache,

                               BuilderContext *context)

{

  BuilderSourcePatch *self = BUILDER_SOURCE_PATCH (source);

  g_autoptr(GPtrArray) srcs = NULL;

  int i;

  srcs = get_source_files (self, context, NULL);

  for (i = 0; srcs != NULL && i < srcs->len; i++)

    {

      GFile *src = g_ptr_array_index (srcs, i);

      g_autofree char *data = NULL;

      gsize len;

      if (g_file_load_contents (src, NULL, &data, &len, NULL, NULL))

        builder_cache_checksum_data (cache, (guchar *) data, len);

    }

  builder_cache_checksum_str (cache, self->path);

  builder_cache_checksum_compat_strv (cache, self->paths);

  builder_cache_checksum_uint32 (cache, self->strip_components);

  builder_cache_checksum_strv (cache, self->options);

}

static void

builder_source_patch_class_init (BuilderSourcePatchClass *klass)

{

  GObjectClass *object_class = G_OBJECT_CLASS (klass);

  BuilderSourceClass *source_class = BUILDER_SOURCE_CLASS (klass);

  object_class->finalize = builder_source_patch_finalize;

  object_class->get_property = builder_source_patch_get_property;

  object_class->set_property = builder_source_patch_set_property;

  source_class->show_deps = builder_source_patch_show_deps;

  source_class->download = builder_source_patch_download;

  source_class->extract = builder_source_patch_extract;

  source_class->bundle = builder_source_patch_bundle;

  source_class->checksum = builder_source_patch_checksum;

  g_object_class_install_property (object_class,

                                   PROP_PATH,

                                   g_param_spec_string ("path",

                                                        "",

                                                        "",

                                                        NULL,

                                                        G_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_PATHS,

                                   g_param_spec_boxed ("paths",

                                                       "",

                                                       "",

                                                       G_TYPE_STRV,

                                                       G_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_STRIP_COMPONENTS,

                                   g_param_spec_uint ("strip-components",

                                                      "",

                                                      "",

                                                      0, G_MAXUINT,

                                                      1,

                                                      G_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_USE_GIT,

                                   g_param_spec_boolean ("use-git",

                                                         "",

                                                         "",

                                                         FALSE,

                                                         G_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_OPTIONS,

                                   g_param_spec_boxed ("options",

                                                       "",

                                                       "",

                                                       G_TYPE_STRV,

                                                       G_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_USE_GIT_AM,

                                   g_param_spec_boolean ("use-git-am",

                                                         "",

                                                         "",

                                                         FALSE,

                                                         G_PARAM_READWRITE));

}

static void

builder_source_patch_init (BuilderSourcePatch *self)

{

  self->strip_components = 1;

}