/*
Copyright (C) 2003 Antoine Rousseau

This library 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.1 of the License, or (at your option) any later version.

This library 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 library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

*/

/* a shared symbol list, ala "value" .*/

#include <m_pd.h>
#include <stdlib.h>
#include <string.h>

static t_class *slist_class, *scommon_class;

typedef struct _sitem t_sitem;

struct _sitem
{
    t_sitem *next;
    t_symbol *s;
};

typedef struct scommon
{
    t_pd c_pd;
    t_symbol *c_sym;
    int c_refcount;
    t_sitem *first;
} t_scommon;

typedef struct _slist
{
    t_object x_obj;
    t_symbol *x_sym;
    t_scommon *x_c;
    t_outlet *x_symout;
    t_outlet *x_lenout;
} t_slist;


static void sitem_delete(t_sitem **x)
{
    t_sitem *next=(*x)->next;

    //freebytes((*x)->name,strlen((*x)->name)+1);
    freebytes(*x,sizeof(t_sitem));
    (*x)=next;
}

static void sitem_add(t_sitem **x,t_symbol *s)
{
    t_int l;
    t_sitem *newone=getbytes(sizeof(t_sitem));

    //newone->name=getbytes(l=(strlen(s->s_name)+1));
    //strncpy(newone->name,s->s_name,l);
    newone->s=s;
    newone->next=0;

    while(*x) x=&((*x)->next);

    *x=newone;
}

static void *scommon_new(t_symbol *s)
{
    t_scommon *x = (t_scommon *)pd_new(scommon_class);

    x->c_refcount = 0;
    x->c_sym=s;
    pd_bind((t_pd *)x, s);

    x->first=0;

    return (x);
}

static int scommon_find(t_scommon *x, t_symbol *s)
{
    t_sitem *si=x->first;
    t_int i=1;

    while(si)
    {
        if(!strcmp(si->s->s_name,s->s_name)) return i;
        si=si->next;
        i++;
    }
    return 0;
}

static void scommon_add(t_scommon *x, t_symbol *s)
{
    sitem_add(&x->first,s);
}

static void scommon_reset(t_scommon *x)
{
    while(x->first) sitem_delete(&x->first);
}

static void scommon_ff(t_scommon *x)
{
    scommon_reset(x);
    pd_unbind((t_pd *)x, x->c_sym);
}


/* get a pointer to a named symbol list (a "scommon" object),
which is created if necessary. */
t_scommon *slist_get(t_symbol *s)
{
    t_scommon *c = (t_scommon *)pd_findbyclass(s, scommon_class);

    if (!c) c = (t_scommon *)scommon_new(s);
    c->c_refcount++;
    return (c);
}

/* release a variable.  This only frees the "scommon" resource when the
last interested party releases it. */
void slist_release(t_scommon *c)
{
    if (!--c->c_refcount) scommon_ff(c);
}


static void *slist_new(t_symbol *s)
{
    t_slist *x = (t_slist *)pd_new(slist_class);
    x->x_sym = s;
    x->x_c = slist_get(s);
    outlet_new(&x->x_obj, &s_float);
    x->x_symout=outlet_new(&x->x_obj, &s_symbol);
    x->x_lenout=outlet_new(&x->x_obj, &s_float);
    return (x);
}

static void slist_ff(t_slist *x)
{
    slist_release(x->x_c);
}

static void slist_print(t_slist *x)
{
    t_sitem *t=x->x_c->first;
    int i=0;

    while(t)
    {
        post("item %d: %s",++i,t->s->s_name);
        t=t->next;
    }
}

static void slist_reset(t_slist *x)
{
    scommon_reset(x->x_c);
}

static void slist_add(t_slist *x,t_symbol *s)
{
    scommon_add(x->x_c,s);
}

static void slist_find(t_slist *x,t_symbol *s)
{
    outlet_float(x->x_obj.ob_outlet,scommon_find(x->x_c,s));
}

static void slist_setlist(t_slist *x,t_symbol *s)
{
    slist_release(x->x_c);
    x->x_c = slist_get(s);
}

static void slist_float(t_slist *x, t_float f)
{
    t_sitem *t=x->x_c->first;
    int i=0;

    if(!f) return;

    while(t&&((++i)!=f))
    {
        t=t->next;
    }

    if(t) outlet_symbol(x->x_symout,t->s);
}

static void slist_len(t_slist *x)
{
    t_sitem *t=x->x_c->first;
    int i=0;

    while(t)
    {
        t=t->next;
        i++;
    }

    outlet_float(x->x_lenout,i);
}


void slist_setup(void)
{
    slist_class = class_new(gensym("slist"), (t_newmethod)slist_new,
                            (t_method)slist_ff,
                            sizeof(t_slist), 0, A_DEFSYM, 0);

    //class_addbang(slist_class, slist_bang);
    class_addfloat(slist_class, slist_float);
    class_addmethod(slist_class,(t_method)slist_add, gensym("add"),A_SYMBOL,0);
    class_addmethod(slist_class,(t_method)slist_find, gensym("find"),A_SYMBOL,0);
    class_addmethod(slist_class,(t_method)slist_setlist, gensym("setlist"),A_SYMBOL,0);
    class_addmethod(slist_class,(t_method)slist_reset, gensym("reset"),0);
    class_addmethod(slist_class,(t_method)slist_print, gensym("print"),0);
    class_addmethod(slist_class,(t_method)slist_len, gensym("len"),0);
    scommon_class = class_new(gensym("slist"), 0, 0,
                              sizeof(t_scommon), CLASS_PD, 0);
}