/*
 *  Tvheadend - idnode (class) system
 *
 *  Copyright (C) 2013 Andreas Öman
 *
 *  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 <http://www.gnu.org/licenses/>.
 */

#ifndef __TVH_IDNODE_H__
#define __TVH_IDNODE_H__

#include "tvheadend.h"
#include "prop.h"

#include <regex.h>

#define UUID_STR_LEN 33 // inc NUL char
#define UUID_BIN_LEN 16

struct htsmsg;
typedef struct idnode idnode_t;

/*
 * Node set
 */
typedef struct idnode_set
{
  idnode_t **is_array;  ///< Array of nodes
  size_t     is_alloc;  ///< Size of is_array
  size_t     is_count;  ///< Current usage of is_array
} idnode_set_t;

/*
 * Class definition
 */
typedef struct idclass {
  const struct idclass  *ic_super;      /// Parent class
  const char            *ic_class;      /// Class name
  const char            *ic_caption;    /// Class description
  const property_t      *ic_properties; /// Property list
  const char            *ic_event;      /// Events to fire on add/delete/title

  /* Callbacks */
  idnode_set_t   *(*ic_get_childs)(idnode_t *self);
  const char     *(*ic_get_title) (idnode_t *self);
  void            (*ic_save)      (idnode_t *self);
  void            (*ic_delete)    (idnode_t *self);
} idclass_t;

/*
 * Node definition
 */
struct idnode {
  uint8_t           in_uuid[UUID_BIN_LEN]; ///< Unique ID
  RB_ENTRY(idnode)  in_link;               ///< Global hash
  const idclass_t  *in_class;              ///< Class definition
};

/*
 * Sorting definition
 */
typedef struct idnode_sort {
  const char *key;  ///< Sort key
  enum {
    IS_ASC,
    IS_DSC
  }           dir;  ///< Sort direction
} idnode_sort_t;

/*
 * Filter definition
 */
typedef struct idnode_filter_ele
{
  LIST_ENTRY(idnode_filter_ele) link; ///< List link

  char *key;                          ///< Filter key
  enum {
    IF_STR,
    IF_NUM,
    IF_BOOL
  } type;                             ///< Filter type
  union {
    int      b;
    char    *s;
    int64_t  n;
    regex_t  re;
  } u;                                ///< Filter data
  enum {
    IC_EQ, ///< Equals
    IC_LT, ///< LT
    IC_GT, ///< GT
    IC_IN, ///< contains (STR only)
    IC_RE, ///< regexp (STR only)
  } comp;                             ///< Filter comparison
} idnode_filter_ele_t;

typedef LIST_HEAD(,idnode_filter_ele) idnode_filter_t;

void idnode_init(void);

int  idnode_insert(idnode_t *in, const char *uuid, const idclass_t *idc);
void idnode_unlink(idnode_t *in);

uint32_t      idnode_get_short_uuid (const idnode_t *in);
const char   *idnode_uuid_as_str0 (const idnode_t *in, char *b);
const char   *idnode_uuid_as_str  (const idnode_t *in);
idnode_set_t *idnode_get_childs   (idnode_t *in);
const char   *idnode_get_title    (idnode_t *in);
int           idnode_is_leaf      (idnode_t *in);
int           idnode_is_instance  (idnode_t *in, const idclass_t *idc);
void          idnode_delete       (idnode_t *in);

void         *idnode_find    (const char *uuid, const idclass_t *idc);
idnode_set_t *idnode_find_all(const idclass_t *idc);

#define idnode_updated(in) idnode_notify(in, NULL, 0, 0)
void idnode_notify
  (idnode_t *in, const char *chn, int force, int event);
void idnode_notify_simple (void *in);
void idnode_notify_title_changed (void *in);

const idclass_t *idclass_find ( const char *name );
htsmsg_t *idclass_serialize0 (const idclass_t *idc, int optmask);
htsmsg_t *idnode_serialize0  (idnode_t *self, int optmask);
void      idnode_read0  (idnode_t *self, htsmsg_t *m, int optmask);
int       idnode_write0 (idnode_t *self, htsmsg_t *m, int optmask, int dosave);

#define idclass_serialize(idc) idclass_serialize0(idc, 0)
#define idnode_serialize(in)   idnode_serialize0(in, 0)
#define idnode_load(in, m)     idnode_write0(in, m, 0, 0)
#define idnode_save(in, m)     idnode_read0(in, m, PO_NOSAVE | PO_USERAW)
#define idnode_update(in, m)   idnode_write0(in, m, PO_RDONLY | PO_WRONCE, 1)

const char *idnode_get_str (idnode_t *self, const char *key );
int         idnode_get_u32 (idnode_t *self, const char *key, uint32_t *u32);
int         idnode_get_bool(idnode_t *self, const char *key, int *b);

void idnode_filter_add_str
  (idnode_filter_t *f, const char *k, const char *v, int t);
void idnode_filter_add_num
  (idnode_filter_t *f, const char *k, int64_t s64, int t);
void idnode_filter_add_bool
  (idnode_filter_t *f, const char *k, int b, int t);
void idnode_filter_clear
  (idnode_filter_t *f);
int  idnode_filter
  ( idnode_t *in, idnode_filter_t *filt );
#define idnode_set_create() calloc(1, sizeof(idnode_set_t))
void idnode_set_add
  ( idnode_set_t *is, idnode_t *in, idnode_filter_t *filt );
void idnode_set_sort    ( idnode_set_t *is, idnode_sort_t *s );
void idnode_set_sort_by_title ( idnode_set_t *is );
void idnode_set_free    ( idnode_set_t *is );

#endif /* __TVH_IDNODE_H__ */

/******************************************************************************
 * Editor Configuration
 *
 * vim:sts=2:ts=2:sw=2:et
 *****************************************************************************/