/*
 * Copyright (C) 2000  Red Hat, Inc.,  Jonathan Blandford <jrb@redhat.com>
 * Copyright (C) 2023  J. Ali Harlow <ali@juiblex.co.uk>
 *
 * 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.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#include "config.h"
#include <stdlib.h>
#include <string.h>
#include <glib-object.h>
#include <gtk/gtk.h>
#include <plover/plover.h>
#include "localdistributions.h"

#define VALID_ITER(iter,local) ((iter) && (iter)->user_data && \
	PLOVER_LOCAL_DISTRIBUTIONS_GET_PRIVATE(local)->stamp==(iter)->stamp)

static GType column_types[PLOVER_LOCAL_DISTRIBUTIONS_NO_COLUMNS];

static void
  plover_local_distributions_tree_model_init(GtkTreeModelIface *iface);

G_DEFINE_TYPE_WITH_CODE(PloverLocalDistributions,plover_local_distributions,
  G_TYPE_OBJECT,G_IMPLEMENT_INTERFACE(GTK_TYPE_TREE_MODEL,
  plover_local_distributions_tree_model_init));

typedef struct _PloverLocalDistribution {
    gchar *vendor,*distribution,*prefix,*user_friendly,*database_uri;
} PloverLocalDistribution;

typedef struct _PloverLocalDistributionsPrivate {
    GList *distributions;
    int stamp;
} PloverLocalDistributionsPrivate;

#define PLOVER_LOCAL_DISTRIBUTIONS_GET_PRIVATE(obj)\
				G_TYPE_INSTANCE_GET_PRIVATE(obj,\
				  PLOVER_TYPE_LOCAL_DISTRIBUTIONS,\
				  PloverLocalDistributionsPrivate)

PloverLocalDistribution *plover_local_distribution_new(const char *vendor,
  const char *distribution)
{
    gchar *s;
    struct comps *comps;
    PloverLocalDistribution *ld;
    ld=g_new0(PloverLocalDistribution,1);
    ld->vendor=g_strdup(vendor);
    if (distribution)
    {
	ld->distribution=g_strdup(distribution);
	ld->user_friendly=g_strdup_printf("%s (%s)",distribution,vendor);
    }
    else
	ld->user_friendly=g_strdup(vendor);
    comps=plover_comps_new();
    plover_comps_set_vendor(comps,vendor);
    if (distribution)
	plover_comps_set_distribution(comps,distribution);
    ld->prefix=plover_comps_get_default_prefix(comps);
    plover_comps_free(comps);
    s=g_build_filename(ld->prefix,"var","lib","razor",NULL);
    ld->database_uri=razor_path_to_uri(s);
    g_free(s);
    return ld;
}

void plover_local_distribution_free(PloverLocalDistribution *ld)
{
    if (ld)
    {
	g_free(ld->vendor);
	g_free(ld->distribution);
	g_free(ld->prefix);
	g_free(ld->user_friendly);
	g_free(ld->database_uri);
	g_free(ld);
    }
}

static void plover_local_distributions_finalize(GObject *obj)
{
    PloverLocalDistributionsPrivate *priv;
    priv=PLOVER_LOCAL_DISTRIBUTIONS_GET_PRIVATE(obj);
    g_list_foreach(priv->distributions,(GFunc)plover_local_distribution_free,
      NULL);
    g_list_free(priv->distributions);
    if (G_OBJECT_CLASS(plover_local_distributions_parent_class)->finalize)
	G_OBJECT_CLASS(plover_local_distributions_parent_class)->finalize(obj);
}

static void
  plover_local_distributions_class_init(PloverLocalDistributionsClass *klass)
{
    GObjectClass *oclass=G_OBJECT_CLASS(klass);
    oclass->finalize=plover_local_distributions_finalize;
    g_type_class_add_private(klass,sizeof(PloverLocalDistributionsPrivate));
    column_types[PLOVER_LOCAL_DISTRIBUTIONS_VENDOR_COLUMN]=G_TYPE_STRING;
    column_types[PLOVER_LOCAL_DISTRIBUTIONS_DISTRIBUTION_COLUMN]=G_TYPE_STRING;
    column_types[PLOVER_LOCAL_DISTRIBUTIONS_PREFIX_COLUMN]=G_TYPE_STRING;
    column_types[PLOVER_LOCAL_DISTRIBUTIONS_USER_FRIENDLY_COLUMN]=G_TYPE_STRING;
    column_types[PLOVER_LOCAL_DISTRIBUTIONS_DATABASE_URI_COLUMN]=G_TYPE_STRING;
}

static GtkTreeModelFlags
plover_local_distributions_get_flags(GtkTreeModel *tree_model)
{
    return GTK_TREE_MODEL_ITERS_PERSIST|GTK_TREE_MODEL_LIST_ONLY;
}

static gint plover_local_distributions_get_n_columns(GtkTreeModel *tree_model)
{
    return PLOVER_LOCAL_DISTRIBUTIONS_NO_COLUMNS;
}

static GType
  plover_local_distributions_get_column_type(GtkTreeModel *tree_model,gint indx)
{
    g_return_val_if_fail(indx>=0 && indx<PLOVER_LOCAL_DISTRIBUTIONS_NO_COLUMNS,
      G_TYPE_INVALID);
    return column_types[indx];
}

static gboolean plover_local_distributions_get_iter(GtkTreeModel *tree_model,
  GtkTreeIter *iter,GtkTreePath *path)
{
    int i;
    PloverLocalDistributionsPrivate *priv;
    PloverLocalDistributions *local=(PloverLocalDistributions *)tree_model;
    PloverLocalDistribution *ld;
    priv=PLOVER_LOCAL_DISTRIBUTIONS_GET_PRIVATE(local);
    i=gtk_tree_path_get_indices(path)[0];
    ld=g_list_nth_data(priv->distributions,i);
    if (!ld)
	return FALSE;
    iter->stamp=priv->stamp;
    iter->user_data=ld;
    return TRUE;
}

static GtkTreePath *
  plover_local_distributions_get_path(GtkTreeModel *tree_model,
  GtkTreeIter *iter)
{
    GtkTreePath *path;
    PloverLocalDistributionsPrivate *priv;
    PloverLocalDistributions *local=(PloverLocalDistributions *)tree_model;
    g_return_val_if_fail(VALID_ITER(iter,tree_model),NULL);
    priv=PLOVER_LOCAL_DISTRIBUTIONS_GET_PRIVATE(local);
    path=gtk_tree_path_new();
    gtk_tree_path_append_index(path,
      g_list_index(priv->distributions,iter->user_data));
    return path;
}

static void plover_local_distributions_get_value(GtkTreeModel *tree_model,
  GtkTreeIter *iter,gint column,GValue *value)
{
    gchar *s;
    PloverLocalDistributions *local=(PloverLocalDistributions *)tree_model;
    PloverLocalDistribution *ld;
    g_return_if_fail(column>=0 && column<PLOVER_LOCAL_DISTRIBUTIONS_NO_COLUMNS);
    g_return_if_fail(VALID_ITER(iter,local));
    ld=iter->user_data;
    g_value_init(value,column_types[column]);
    switch((PloverLocalDistributionsColumn)column)
    {
	case PLOVER_LOCAL_DISTRIBUTIONS_VENDOR_COLUMN:
	    g_value_set_string(value,ld->vendor);
	    break;
	case PLOVER_LOCAL_DISTRIBUTIONS_DISTRIBUTION_COLUMN:
	    g_value_set_string(value,ld->distribution);
	    break;
	case PLOVER_LOCAL_DISTRIBUTIONS_PREFIX_COLUMN:
	    g_value_set_string(value,ld->prefix);
	    break;
	case PLOVER_LOCAL_DISTRIBUTIONS_USER_FRIENDLY_COLUMN:
	    g_value_set_string(value,ld->user_friendly);
	    break;
	case PLOVER_LOCAL_DISTRIBUTIONS_DATABASE_URI_COLUMN:
	    g_value_set_string(value,ld->database_uri);
	    break;
	case PLOVER_LOCAL_DISTRIBUTIONS_NO_COLUMNS:
	    /* Quieten compiler warning */
	    break;
    }
}

static gboolean
  plover_local_distributions_iter_next(GtkTreeModel *tree_model,
  GtkTreeIter *iter)
{
    GList *lnk;
    PloverLocalDistributions *local=(PloverLocalDistributions *)tree_model;
    PloverLocalDistributionsPrivate *priv;
    g_return_val_if_fail(VALID_ITER(iter,tree_model),FALSE);
    priv=PLOVER_LOCAL_DISTRIBUTIONS_GET_PRIVATE(local);
    lnk=g_list_find(priv->distributions,iter->user_data);
    iter->user_data=lnk->next?lnk->next->data:NULL;
    return !!iter->user_data;
}

static gboolean
  plover_local_distributions_iter_children(GtkTreeModel *tree_model,
  GtkTreeIter *iter,GtkTreeIter *parent)
{
    PloverLocalDistributionsPrivate *priv;
    priv=PLOVER_LOCAL_DISTRIBUTIONS_GET_PRIVATE(tree_model);
    /* this is a list, nodes have no children */
    if (parent)
	return FALSE;
    if (priv->distributions)
    {
	iter->stamp=priv->stamp;
	iter->user_data=priv->distributions->data;
	return TRUE;
    }
    else
	return FALSE;
}

static gboolean
  plover_local_distributions_iter_has_child(GtkTreeModel *tree_model,
  GtkTreeIter *iter)
{
    PloverLocalDistributionsPrivate *priv;
    priv=PLOVER_LOCAL_DISTRIBUTIONS_GET_PRIVATE(tree_model);
    return !!priv->distributions;
}

static gint plover_local_distributions_iter_n_children(GtkTreeModel *tree_model,
  GtkTreeIter *iter)
{
    PloverLocalDistributionsPrivate *priv;
    priv=PLOVER_LOCAL_DISTRIBUTIONS_GET_PRIVATE(tree_model);
    if (!iter)
	return g_list_length(priv->distributions);
    g_return_val_if_fail(VALID_ITER(iter,tree_model),-1);
    return 0;
}

static gboolean
  plover_local_distributions_iter_nth_child(GtkTreeModel *tree_model,
  GtkTreeIter *iter,GtkTreeIter *parent,gint n)
{
    GList *lnk;
    PloverLocalDistributionsPrivate *priv;
    priv=PLOVER_LOCAL_DISTRIBUTIONS_GET_PRIVATE(tree_model);
    if (parent)
	return FALSE;
    lnk=g_list_nth(priv->distributions,n);
    if (!lnk)
	return FALSE;
    iter->stamp=priv->stamp;
    iter->user_data=lnk->data;
    return TRUE;
}

static gboolean plover_local_distributions_iter_parent(GtkTreeModel *tree_model,
  GtkTreeIter *iter,GtkTreeIter *child)
{
    return FALSE;
}

static void plover_local_distributions_tree_model_init(GtkTreeModelIface *iface)
{
    iface->get_flags=plover_local_distributions_get_flags;
    iface->get_n_columns=plover_local_distributions_get_n_columns;
    iface->get_column_type=plover_local_distributions_get_column_type;
    iface->get_iter=plover_local_distributions_get_iter;
    iface->get_path=plover_local_distributions_get_path;
    iface->get_value=plover_local_distributions_get_value;
    iface->iter_next=plover_local_distributions_iter_next;
    iface->iter_children=plover_local_distributions_iter_children;
    iface->iter_has_child=plover_local_distributions_iter_has_child;
    iface->iter_n_children=plover_local_distributions_iter_n_children;
    iface->iter_nth_child=plover_local_distributions_iter_nth_child;
    iface->iter_parent=plover_local_distributions_iter_parent;
}

static void plover_local_distributions_init(PloverLocalDistributions *store)
{
    gchar *s;
    const char *vendor_prefix,*vendor,*distribution;
    GDir *vendor_dir,*distribution_dir,*database_dir;
    PloverLocalDistributionsPrivate *priv;
    PloverLocalDistribution *ld;
    priv=PLOVER_LOCAL_DISTRIBUTIONS_GET_PRIVATE(store);
    /*
     * local distribution databases may be found in
     * <vendor-prefix>/$VENDOR/$DISTRIBUTION/var/lib/razor and
     * <vendor-prefix>/$VENDOR/var/lib/razor
     */
    vendor_prefix=plover_get_vendor_prefix();
    g_message("Vendor prefix is %s",vendor_prefix);
    vendor_dir=g_dir_open(vendor_prefix,0,NULL);
    if (!vendor_dir)
    {
	g_warning("Failed to open %s",vendor_prefix);
	return;
    }
    while((vendor=g_dir_read_name(vendor_dir)))
    {
	g_message("Candidate for vendor is %s",vendor);
	s=g_build_filename(vendor_prefix,vendor,NULL);
	distribution_dir=g_dir_open(s,0,NULL);
	g_free(s);
	if (!distribution_dir)
	{
	    g_warning("Failed to open %s/%s",vendor_prefix,vendor);
	    continue;
	}
	while((distribution=g_dir_read_name(distribution_dir)))
	{
	    g_message("Candidate for distribution is %s",distribution);
	    if (!strcmp(distribution,"var"))
	    {
		s=g_build_filename(vendor_prefix,vendor,"var","lib","razor",
		  NULL);
		database_dir=g_dir_open(s,0,NULL);
		g_free(s);
		if (database_dir)
		{
		    ld=plover_local_distribution_new(vendor,NULL);
		    g_message("Found vendor-specific razor database at %s",
		      ld->database_uri);
		    priv->distributions=g_list_prepend(priv->distributions,ld);
		    g_dir_close(database_dir);
		}
		else
		    g_warning("Failed to open %s/%s/var/lib/razor",
		      vendor_prefix,vendor);
	    }
	    s=g_build_filename(vendor_prefix,vendor,distribution,
	      "var","lib","razor",NULL);
	    database_dir=g_dir_open(s,0,NULL);
	    g_free(s);
	    if (database_dir)
	    {
		ld=plover_local_distribution_new(vendor,distribution);
		g_message("Found local-distribution razor database at %s",
		  ld->database_uri);
		priv->distributions=g_list_prepend(priv->distributions,ld);
		g_dir_close(database_dir);
	    }
	    else
		g_warning("Failed to open %s/%s/%s/var/lib/razor",
		  vendor_prefix,vendor,distribution);
	}
	g_dir_close(distribution_dir);
    }
    g_dir_close(vendor_dir);
    priv->stamp=g_random_int();
}

PloverLocalDistributions *plover_local_distributions_new(void)
{
    return g_object_new(PLOVER_TYPE_LOCAL_DISTRIBUTIONS,NULL);
}