/*                                                                  -*- c++ -*-
Copyright (C) 2004-2013 Christian Wieninger

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
Or, point your browser to http://www.gnu.org/licenses/old-licenses/gpl-2.0.html

The author can be reached at cwieninger@gmx.de

The project's page is at http://winni.vdr-developer.org/epgsearch
*/

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <getopt.h>

#define MINAPPEARANCE 100 // the minimum appearance of a category
#define MAXVALUES 60 // the maximum of values for a category
#define MAXNAMELENGTH 30 // the maximum length of a category name or value


// some helping stuff copied from VDR sources
#define KILOBYTE(n) ((n) * 1024)
#define MAXPARSEBUFFER KILOBYTE(10)

#ifdef __FreeBSD__
#ifdef isnumber
#undef isnumber
#endif
#endif

bool isnumber(const char *s)
{
  if (!*s)
     return false;
  while (*s) {
        if (!isdigit(*s))
           return false;
        s++;
        }
  return true;
}

// --- cReadLine -------------------------------------------------------------
class cReadLine {
 private:
    char buffer[MAXPARSEBUFFER];
 public:
    cReadLine() { buffer[0]=0; }
    char *Read(FILE *f);
};

char *cReadLine::Read(FILE *f)
{
    if (fgets(buffer, sizeof(buffer), f) > 0) {
	int l = strlen(buffer) - 1;
	if (l >= 0 && buffer[l] == '\n')
	    buffer[l] = 0;
	return buffer;
    }
    return NULL;
}

char *skipspace(const char *s)
{
    while (*s && isspace(*s))
        s++;
    return (char *)s;
}

int comparevalue( const void *arg1, const void *arg2 )
{
    char* value1 = *(char**) arg1;
    char* value2 = *(char**) arg2;
    return strcmp(value1, value2);
}

// --- cCat -------------------------------------------------------------
class cCat {
 public:
    int appeared;
    char name[MAXPARSEBUFFER];
    int numvalues;
    char** values;

    cCat(char* n)
	:appeared(0), numvalues(0), values(NULL)
	{
	    strcpy(name, n);
	}
    void addvalue(char* value)
	{
	    if (valueexists(value))
		return;
	    char* newvalue = (char*) malloc(sizeof(char) * (strlen(value)+1));
	    strcpy(newvalue, value);
	    char **tmp = (char**) realloc(values, sizeof(char*)*(numvalues+1));
	    if (tmp) {
                 values=tmp;
   	         values[numvalues++] = newvalue;
	    } else {
                 free(newvalue);
            }
	}
    bool valueexists(char* value)
	{
	    for(int i=0; i<numvalues; i++)
		if (strcmp(values[i], value) == 0)
		    return true;
	    return false;
	}
    void sort()
	{
	    qsort(values, numvalues, sizeof(char*), comparevalue );
	}
};

int comparecat( const void *arg1, const void *arg2 )
{
    cCat* cat1 = *(cCat**) arg1;
    cCat* cat2 = *(cCat**) arg2;
    if (cat1->appeared == cat2->appeared) return 0;
    if (cat1->appeared < cat2->appeared) return 1; else return -1;
}

// --- cCats -------------------------------------------------------------
class cCats {
 private:
    int numcats;
    cCat** cats;
 public:
    cCats():numcats(0), cats(NULL) {}

    int num() {return numcats;}

    cCat* add(char* name)
	{
	    cCat* newCat = new cCat(name);
	    cCat **tmp = (cCat**) realloc(cats, sizeof(cCat*)*(numcats+1));
            if (tmp) 
            {
               cats=tmp;
	       cats[numcats++] = newCat;
	       return newCat;
            } else {
               delete newCat;
               return NULL;
            }
	}

    cCat* get(int i)
	{
	    if (i>=0 && i<numcats)
		return cats[i];
	    else
		return NULL;
	}

    cCat* exists(char* name)
	{
	    for(int i=0; i<numcats; i++)
		if (strcmp(cats[i]->name, name) == 0)
		    return cats[i];
	    return NULL;
	}
    void sort()
	{
	    for(int i=0; i<numcats; i++)
		cats[i]->sort();
	    qsort(cats, numcats, sizeof( cCat* ), comparecat );
	}
};

int main(int argc, char *argv[])
{
    FILE* f = NULL;
    cCats catlist;
    unsigned int minappearance = MINAPPEARANCE;
    unsigned int maxvalues = MAXVALUES;
    unsigned int maxlength = MAXNAMELENGTH;

    static const struct option long_options[] = {
      { "minappearance", required_argument, NULL, 'm' },
      { "maxvalues",   required_argument, NULL, 'v' },
      { "maxlength",   required_argument,       NULL, 'l' },
      { "help",     no_argument,       NULL, 'h' },
      { NULL,     no_argument,       NULL, 0 }
    };

    int c;
    while ((c = getopt_long(argc, argv, "m:v:l:h", long_options, NULL)) != -1)
    {
        switch (c)
	{
	    case 'm':
		if (isnumber(optarg))
		{
		    minappearance = atoi(optarg);
		    break;
		}
		fprintf(stderr, "invalid parameter minappearance: %s\n", optarg);
		return 2;
		break;
	    case 'v':
		if (isnumber(optarg))
		{
		    maxvalues = atoi(optarg);
		    break;
		}
		fprintf(stderr, "invalid parameter maxvalues: %s\n", optarg);
		return 2;
		break;
	    case 'l':
		if (isnumber(optarg))
		{
		    maxlength = atoi(optarg);
		    break;
		}
		fprintf(stderr, "invalid parameter maxlength: %s\n", optarg);
		return 2;
		break;
	    case 'h':
		printf("usage: createcats [OPTIONS] /path_to/epg.data\n\n");
		printf("-m N, --minappearance=N    the minimum number a category has to appear\n");
		printf("                           to be used\n");
		printf("-v N, --maxvalues=N        values of a category are omitted if they exceed\n");
		printf("                           this number\n");
		printf("-l N, --maxlength=N        the maximum length of a text to be accepted\n");
		printf("                           as a category value\n");
		printf("-h, --help                 this help\n\n");
		return 0;
	     default:
	        break;
	}
    }

    if (argc < 2)
    {
	fprintf(stderr, "ERROR: please pass your epg.data\nusage: createcats epg.data\n");
	return 1;
    }

    f = fopen(argv[argc-1], "r");
    if (f == NULL)
    {
	fprintf(stderr, "ERROR: could not open: %s\n", argv[1]);
	return 1;
    }

    char *s;
    cReadLine ReadLine;
    while ((s = ReadLine.Read(f)) != NULL)
    {
        if (*s == 'D')
	{
	    s = strchr(s,'|'); // jump to possibly first category
	    if (!s)
		continue;
	    s++;
	    char *pstrSearchToken;
	    char *pstrSearch=strdup(s);
	    pstrSearchToken=strtok(pstrSearch, "|");

	    while(pstrSearchToken)
	    {
		// must have a ':'
		char* szPos = NULL;
		if ((szPos = strchr(pstrSearchToken, ':')) == NULL)
		{
		    pstrSearchToken=strtok(NULL, "|");
		    continue;
		}

		char catname[MAXPARSEBUFFER] = "";
		char catvalue[MAXPARSEBUFFER] = "";

		strncpy(catname, pstrSearchToken, szPos - pstrSearchToken);
		catname[szPos - pstrSearchToken] = 0;
		strcpy(catvalue, skipspace(szPos+1));

		cCat* cat = catlist.exists(catname);
		if (!cat && strlen(catname) < maxlength) // accept only names up to 30 chars
		    cat = catlist.add(catname);

		if (cat)
		{
		    cat->appeared++;
		    if (strlen(catvalue) < maxlength) // accept only values up to 30 chars
			cat->addvalue(catvalue);
		}

		pstrSearchToken=strtok(NULL, "|");
	    }
	    free(pstrSearch);
        }
    }
    fclose(f);

    catlist.sort();

    f = fopen("epgsearchcats.conf", "w");
    if (f == NULL)
    {
	fprintf(stderr, "ERROR: could not open outputfile\n");
	return 1;
    }
    fprintf(f, "# -----------------------------------------------------------------------------\n");
    fprintf(f, "# This is just a template based on your current epg.data. Please edit!\n");
    fprintf(f, "# Perhaps a category or its value list should be removed. Also the\n");
    fprintf(f, "# 'name in menu' should be adjusted to your language.\n");
    fprintf(f, "# The order of items determines the order listed in epgsearch. It does not\n");
    fprintf(f, "# depend on the ID, which is used by epgsearch.\n");
    fprintf(f, "# Format:\n");
    fprintf(f, "# ID|category name|name in menu|values separated by ',' (option)|searchmode(option)\n");
    fprintf(f, "# - 'ID' should be a unique positive integer\n");
    fprintf(f, "#   (changing the id later on will force you to reedit your search timers!)\n");
    fprintf(f, "# - 'category name' is the name in your epg.data\n");
    fprintf(f, "# - 'name in menu' is the name displayed in epgsearch.\n");
    fprintf(f, "# - 'values' is an optional list of possible values\n");
    fprintf(f, "#   if you omit the list, the entry turns to an edit field in epgsearch,\n");
    fprintf(f, "#   else it's a list of items to select from\n");
    fprintf(f, "# - 'searchmode' is an optional parameter specifying the mode of search:\n");
    fprintf(f, "#     text comparison:\n");
    fprintf(f, "#     0 - the whole term must appear as substring\n");
    fprintf(f, "#     1 - all single words (delimiters are ',', ';', '|' or '~')\n");
    fprintf(f, "#         must exist as substrings. This is the default search mode.\n");
    fprintf(f, "#     2 - at least one word (delimiters are ',', ';', '|' or '~')\n");
    fprintf(f, "#         must exist as substring.\n");
    fprintf(f, "#     3 - matches exactly\n");
    fprintf(f, "#     4 - regular expression\n");
    fprintf(f, "#     numerical comparison:\n");
    fprintf(f, "#     10 - less\n");
    fprintf(f, "#     11 - less or equal\n");
    fprintf(f, "#     12 - greater\n");
    fprintf(f, "#     13 - greater or equal\n");
    fprintf(f, "#     14 - equal\n");
    fprintf(f, "#     15 - not equal\n");
    fprintf(f, "# -----------------------------------------------------------------------------\n\n");
    int id = 1;
    for(int i=0; i<catlist.num(); i++)
    {
	cCat* cat = catlist.get(i);
	if (cat->appeared > (int)minappearance && cat->numvalues > 1) // accept only category, that have at least 2 values and appear more than MINAPPEARANCE timers
	{
	    fprintf(f, "# '%s' found %d times with %d different values %s\n", cat->name, cat->appeared, cat->numvalues, cat->numvalues>=(int)maxvalues?"(values omitted, too much)":"");
	    fprintf(f, "%d|%s|%s|", id++, cat->name, cat->name);
	    for(int j=0; cat->numvalues < (int)maxvalues && j<cat->numvalues; j++)
		fprintf(f, "%s%s", cat->values[j], (j == cat->numvalues-1?"":","));
	    fprintf(f, "|1\n\n");
	}
    }
    fclose(f);

    printf("epgsearchcats.conf created!\n");
    return 0;
}
