/* PIKA - Photo and Image Kooker Application
 * a rebranding of The GNU Image Manipulation Program (created with heckimp)
 * A derived work which may be trivial. However, any changes may be (C)2023 by Aldercone Studio
 *
 * Original copyright, applying to most contents (license remains unchanged): 
 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
 *
 * pikafileprocedure.c
 * Copyright (C) 2019 Michael Natterer <mitch@gimp.org>
 *
 * 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/>.
 */

#include "config.h"

#include "pika.h"
#include "pikafileprocedure.h"


struct _PikaFileProcedurePrivate
{
  gchar    *format_name;
  gchar    *mime_types;
  gchar    *extensions;
  gchar    *prefixes;
  gchar    *magics;
  gint      priority;
  gboolean  handles_remote;
};


static void   pika_file_procedure_constructed (GObject *object);
static void   pika_file_procedure_finalize    (GObject *object);


G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (PikaFileProcedure, pika_file_procedure,
                                     PIKA_TYPE_PROCEDURE)

#define parent_class pika_file_procedure_parent_class


static void
pika_file_procedure_class_init (PikaFileProcedureClass *klass)
{
  GObjectClass *object_class = G_OBJECT_CLASS (klass);

  object_class->constructed  = pika_file_procedure_constructed;
  object_class->finalize     = pika_file_procedure_finalize;
}

static void
pika_file_procedure_init (PikaFileProcedure *procedure)
{
  procedure->priv = pika_file_procedure_get_instance_private (procedure);
}

static void
pika_file_procedure_constructed (GObject *object)
{
  PikaProcedure *procedure = PIKA_PROCEDURE (object);

  G_OBJECT_CLASS (parent_class)->constructed (object);

  PIKA_PROC_ARG_ENUM (procedure, "run-mode",
                      "Run mode",
                      "The run mode",
                      PIKA_TYPE_RUN_MODE,
                      PIKA_RUN_NONINTERACTIVE,
                      G_PARAM_READWRITE);
}

static void
pika_file_procedure_finalize (GObject *object)
{
  PikaFileProcedure *procedure = PIKA_FILE_PROCEDURE (object);

  g_clear_pointer (&procedure->priv->format_name, g_free);
  g_clear_pointer (&procedure->priv->mime_types, g_free);
  g_clear_pointer (&procedure->priv->extensions, g_free);
  g_clear_pointer (&procedure->priv->prefixes,   g_free);
  g_clear_pointer (&procedure->priv->magics,     g_free);

  G_OBJECT_CLASS (parent_class)->finalize (object);
}


/*  public functions  */

/**
 * pika_file_procedure_set_format_name:
 * @procedure: A file procedure.
 * @format_name: A public-facing name for the format, e.g. "PNG".
 *
 * Associates a format name with a file handler procedure.
 *
 * This name can be used for any public-facing strings, such as
 * graphical interface labels. An example usage would be
 * %PikaSaveProcedureDialog title looking like "Export Image as %s".
 *
 * Note that since the format name is public-facing, it is recommended
 * to localize it at runtime, for instance through gettext, like:
 *
 * ```c
 * pika_file_procedure_set_format_name (procedure, _("JPEG"));
 * ```
 *
 * Some language would indeed localize even some technical terms or
 * acronyms, even if sometimes just to rewrite them with the local
 * writing system.
 *
 * Since: 3.0
 **/
void
pika_file_procedure_set_format_name (PikaFileProcedure *procedure,
                                     const gchar       *format_name)
{
  g_return_if_fail (PIKA_IS_FILE_PROCEDURE (procedure));

  g_free (procedure->priv->format_name);
  procedure->priv->format_name = g_strdup (format_name);
}

/**
 * pika_file_procedure_get_format_name:
 * @procedure: A file procedure object.
 *
 * Returns the procedure's format name, as set with
 * [method@FileProcedure.set_format_name].
 *
 * Returns: The procedure's format name.
 *
 * Since: 3.0
 **/
const gchar *
pika_file_procedure_get_format_name (PikaFileProcedure *procedure)
{
  g_return_val_if_fail (PIKA_IS_FILE_PROCEDURE (procedure), NULL);

  return procedure->priv->format_name;
}

/**
 * pika_file_procedure_set_mime_types:
 * @procedure: A file procedure object.
 * @mime_types: A comma-separated list of MIME types, such as "image/jpeg".
 *
 * Associates MIME types with a file handler procedure.
 *
 * Registers MIME types for a file handler procedure. This allows PIKA
 * to determine the MIME type of the file opened or saved using this
 * procedure. It is recommended that only one MIME type is registered
 * per file procedure; when registering more than one MIME type, PIKA
 * will associate the first one with files opened or saved with this
 * procedure.
 *
 * Since: 3.0
 **/
void
pika_file_procedure_set_mime_types (PikaFileProcedure *procedure,
                                    const gchar       *mime_types)
{
  g_return_if_fail (PIKA_IS_FILE_PROCEDURE (procedure));

  g_free (procedure->priv->mime_types);
  procedure->priv->mime_types = g_strdup (mime_types);
}

/**
 * pika_file_procedure_get_mime_types:
 * @procedure: A file procedure.
 *
 * Returns the procedure's mime-type as set with
 * [method@FileProcedure.set_mime_types].
 *
 * Returns: The procedure's registered mime-types.
 *
 * Since: 3.0
 **/
const gchar *
pika_file_procedure_get_mime_types (PikaFileProcedure *procedure)
{
  g_return_val_if_fail (PIKA_IS_FILE_PROCEDURE (procedure), NULL);

  return procedure->priv->mime_types;
}

/**
 * pika_file_procedure_set_extensions:
 * @procedure:  A file procedure.
 * @extensions: A comma separated list of extensions this procedure can
 *              handle (i.e. "jpg,jpeg").
 *
 * Registers the given list of extensions as something this procedure can
 * handle.
 *
 * Since: 3.0
 **/
void
pika_file_procedure_set_extensions (PikaFileProcedure *procedure,
                                    const gchar       *extensions)
{
  g_return_if_fail (PIKA_IS_FILE_PROCEDURE (procedure));

  g_free (procedure->priv->extensions);
  procedure->priv->extensions = g_strdup (extensions);
}

/**
 * pika_file_procedure_get_extensions:
 * @procedure: A file procedure object.
 *
 * Returns the procedure's extensions as set with
 * [method@FileProcedure.set_extensions].
 *
 * Returns: The procedure's registered extensions.
 *
 * Since: 3.0
 **/
const gchar *
pika_file_procedure_get_extensions (PikaFileProcedure *procedure)
{
  g_return_val_if_fail (PIKA_IS_FILE_PROCEDURE (procedure), NULL);

  return procedure->priv->extensions;
}

/**
 * pika_file_procedure_set_prefixes:
 * @procedure: A file procedure object.
 * @prefixes:  A comma separated list of prefixes this procedure can
 *             handle (i.e. "http:,ftp:").
 *
 * It should almost never be necessary to register prefixes with file
 * procedures, because most sorts of URIs should be handled by GIO.
 *
 * Since: 3.0
 **/
void
pika_file_procedure_set_prefixes (PikaFileProcedure *procedure,
                                  const gchar       *prefixes)
{
  g_return_if_fail (PIKA_IS_FILE_PROCEDURE (procedure));

  g_free (procedure->priv->prefixes);
  procedure->priv->prefixes = g_strdup (prefixes);
}

/**
 * pika_file_procedure_get_prefixes:
 * @procedure: A file procedure object.
 *
 * Returns the procedure's prefixes as set with
 * [method@FileProcedure.set_prefixes].
 *
 * Returns: The procedure's registered prefixes.
 *
 * Since: 3.0
 **/
const gchar *
pika_file_procedure_get_prefixes (PikaFileProcedure *procedure)
{
  g_return_val_if_fail (PIKA_IS_FILE_PROCEDURE (procedure), NULL);

  return procedure->priv->prefixes;
}

/**
 * pika_file_procedure_set_magics:
 * @procedure: A file procedure object.
 * @magics:    A comma-separated list of magic file information (i.e. "0,string,GIF").
 *
 * Registers the list of magic file information this procedure can handle.
 *
 * Since: 3.0
 **/
void
pika_file_procedure_set_magics (PikaFileProcedure *procedure,
                                const gchar       *magics)
{
  g_return_if_fail (PIKA_IS_FILE_PROCEDURE (procedure));

  g_free (procedure->priv->magics);
  procedure->priv->magics = g_strdup (magics);
}

/**
 * pika_file_procedure_get_magics:
 * @procedure: A file procedure object.
 *
 * Returns the procedure's magics as set with [method@FileProcedure.set_magics].
 *
 * Returns: The procedure's registered magics.
 *
 * Since: 3.0
 **/
const gchar *
pika_file_procedure_get_magics (PikaFileProcedure *procedure)
{
  g_return_val_if_fail (PIKA_IS_FILE_PROCEDURE (procedure), NULL);

  return procedure->priv->magics;
}

/**
 * pika_file_procedure_set_priority:
 * @procedure: A file procedure object.
 * @priority: The procedure's priority.
 *
 * Sets the priority of a file handler procedure.
 *
 * When more than one procedure matches a given file, the procedure with the
 * lowest priority is used; if more than one procedure has the lowest priority,
 * it is unspecified which one of them is used. The default priority for file
 * handler procedures is 0.
 *
 * Since: 3.0
 **/
void
pika_file_procedure_set_priority (PikaFileProcedure *procedure,
                                  gint               priority)
{
  g_return_if_fail (PIKA_IS_FILE_PROCEDURE (procedure));

  procedure->priv->priority = priority;
}

/**
 * pika_file_procedure_get_priority:
 * @procedure: A file procedure object.
 *
 * Returns the procedure's priority as set with
 * [method@FileProcedure.set_priority].
 *
 * Returns: The procedure's registered priority.
 *
 * Since: 3.0
 **/
gint
pika_file_procedure_get_priority (PikaFileProcedure *procedure)
{
  g_return_val_if_fail (PIKA_IS_FILE_PROCEDURE (procedure), 0);

  return procedure->priv->priority;
}

/**
 * pika_file_procedure_set_handles_remote:
 * @procedure:      A #PikaFileProcedure.
 * @handles_remote: The procedure's 'handles remote' flag.
 *
 * Registers a file procedure as capable of handling arbitrary remote
 * URIs via GIO.
 *
 * When @handles_remote is set to %TRUE, the procedure will get a
 * #GFile passed that can point to a remote file.
 *
 * When @handles_remote is set to %FALSE, the procedure will get a
 * local [iface@Gio.File] passed and can use [method@Gio.File.get_path] to get
 * to a filename that can be used with whatever non-GIO means of dealing with
 * the file.
 *
 * Since: 3.0
 **/
void
pika_file_procedure_set_handles_remote (PikaFileProcedure *procedure,
                                        gint               handles_remote)
{
  g_return_if_fail (PIKA_IS_FILE_PROCEDURE (procedure));

  procedure->priv->handles_remote = handles_remote;
}

/**
 * pika_file_procedure_get_handles_remote:
 * @procedure: A file procedure object.
 *
 * Returns the procedure's 'handles remote' flags as set with
 * [method@FileProcedure.set_handles_remote].
 *
 * Returns: The procedure's 'handles remote' flag
 *
 * Since: 3.0
 **/
gint
pika_file_procedure_get_handles_remote (PikaFileProcedure *procedure)
{
  g_return_val_if_fail (PIKA_IS_FILE_PROCEDURE (procedure), 0);

  return procedure->priv->handles_remote;
}