#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <sys/time.h> // benchmarking
#include <inttypes.h> // benchmarking
#include <Ecore.h>
#include <Ecore_Data.h>

enum parser_states
{
   PS_QUIET = -1,
   PS_RSS_TAG_START,
   PS_RSS_TAG_END,
   PS_RSS_TAG_FOUND,
   PS_GENERATOR_FOUND,
   PS_ITEM_FOUND,
   PS_XSM_LINK_FOUND,
   PS_XSM_ENCLOSURE_FOUND,
   PS_MEDIA_CONTENT_FOUND,
   PS_MEDIA_THUMB_FOUND
};

typedef struct 
{
   Ecore_List *thumbs;
   Ecore_List *medias;
   char *file;
   int have_ns_media;
   int xsm_generator;
} Feed;

static void parse_feed (void *data);

int
main (int argc, char **argv)
{
   Feed *feed;

   if (argc < 2)
   {
      printf ("Usage:\n");
      printf ("feed_parser <feed>\n");
      return 1;
   }

   ecore_init ();

   feed = (Feed *) malloc( sizeof(Feed));
   if (!feed)
   {
      printf ("Unable to allocate memory for Feed\n");
      return 1;
   }

   feed->file = argv[1];
   feed->thumbs = ecore_list_new ();
   feed->medias = ecore_list_new ();

   parse_feed (feed);

   ecore_list_clear (feed->thumbs);
   ecore_list_clear (feed->medias);
   ecore_list_destroy (feed->thumbs);
   ecore_list_destroy (feed->medias);
   free (feed);
   ecore_shutdown ();
   return 0;
}

static void
parse_feed (void *data)
{
   FILE *fh;
   char instr[255];
   int state = PS_QUIET;
   char *ttbuf;
   char *tbuf;
   char *media;
   char *img;
   static int iterator = 0;
   Feed *feed;

   struct timeval tv; //benchmarking
   uintmax_t start, end; //benchmarking


   feed = data;

   gettimeofday(&tv, NULL); 
   start = (uintmax_t)(tv.tv_sec * 1000000 + tv.tv_usec);

   fh = fopen (feed->file, "r");
   while (fgets (instr, 255, fh) != NULL)
   {
      switch (state)
      {
         case PS_QUIET:
            {
               iterator++;
               if (strstr (instr, "<rss ") != NULL)
               {
                  if (strstr (instr, ">") != NULL)
                  {
                     if (strstr (instr, "xmlns:media") != NULL)
                        feed->have_ns_media = 1;
                     state = PS_RSS_TAG_FOUND;
                  }
                  else
                  {
                     if (strstr (instr, "xmlns:media") != NULL)
                        feed->have_ns_media = 1;
                     tbuf = strdup (instr);
                     state = PS_RSS_TAG_START;
                  }
               }
               break;
            }
         case PS_RSS_TAG_START:
         {
            iterator++;
            ttbuf = strdup (tbuf);
            free (tbuf);
            asprintf (&tbuf, "%s%s", ttbuf, instr);
            free (ttbuf);
            if (strstr (tbuf, ">") != NULL)
            {
               if (strstr (tbuf, "xmlns:media") != NULL)
                  feed->have_ns_media = 1;
               else
                  feed->have_ns_media = 0;
               state = PS_RSS_TAG_FOUND;
               free (tbuf);
            }
            break;
         }
         case PS_RSS_TAG_FOUND:
         {
            iterator++;
            if ((strstr (instr, "<generator>") != NULL))
            {
               if ((strstr (instr, "XSM") != NULL))
                  feed->xsm_generator = 1;
               else
                  feed->xsm_generator = 0;
               state = PS_GENERATOR_FOUND;
            }
            break;
         }
         case PS_GENERATOR_FOUND:
         {
            iterator++;
            if (strstr (instr, "<item>") != NULL)
               {
                  state = PS_ITEM_FOUND;
                  media = NULL;
                  img = NULL;
               }
            break;
         }
         case PS_ITEM_FOUND:
         {
            iterator++;
            if (feed->xsm_generator)
            {
               if (strstr (instr, "<link>") != NULL)
               {
                  tbuf = strdup (instr);
                  media = strtok (tbuf, ">");
                  media = strtok (NULL, "<");
                  if (strstr (strrchr (media, '.'), "edj"))
                     state = PS_XSM_LINK_FOUND;
                  //free (tbuf);
               }
            }
            else if (feed->have_ns_media)
            {
               if (strstr (instr, "media:content") != NULL)
               {
                  tbuf = strdup (instr);
                  media = strtok (tbuf, "=\"");
                  media = strtok (NULL, "\"");
                  state = PS_MEDIA_CONTENT_FOUND;
                  free (tbuf);
               }
            }
            break;
         }
         case PS_XSM_LINK_FOUND:
         {
            iterator++;
            if (strstr (instr, "<enclosure") != NULL)
            {
               tbuf = strdup (instr);
               img = strtok (tbuf, "\"");
               img = strtok (NULL, "\"");
               strcat (img, "\n");
               state = PS_XSM_ENCLOSURE_FOUND;
            }
            break;
         }
         case PS_MEDIA_THUMB_FOUND:
         case PS_XSM_ENCLOSURE_FOUND:
         {
            iterator++;
            if (strstr (instr, "</item>") != NULL)
            {
               if (!isalnum (img[strlen (img) -1]))
                  img[strlen (img) -1] = 0;
               ecore_list_append (feed->thumbs, img);
               ecore_list_append (feed->medias, media);
               state = PS_GENERATOR_FOUND;
            }
            break;
         }
         case PS_MEDIA_CONTENT_FOUND:
         {
            iterator++;
            if (strstr (instr, "media:thumbnail") != NULL)
            {
               tbuf = strdup (instr);
               img = strtok (tbuf, "=\"");
               img = strtok (NULL, "\"");
               state = PS_MEDIA_THUMB_FOUND;
            }
            break;
         }
         default:
            break;
      }
   }

   fclose (fh);
   //printf ("Iterations: %d\n", iterator);
   printf ("*** Counts ***\n");
   printf ("medias -> %d\n", ecore_list_count (feed->medias));
   printf ("thumbs -> %d\n", ecore_list_count (feed->thumbs));

   printf ("*** Dumps ***\n");
   char *mdump;
   ecore_list_first_goto(feed->medias);
   while ((mdump = ecore_list_next (feed->medias)))
   {
      printf ("medias [%d] %s\n", ecore_list_index (feed->medias), mdump);
   }
   char *tdump;
   ecore_list_first_goto(feed->thumbs);
   while ((tdump = ecore_list_next (feed->thumbs)))
   {
      printf ("thumbs [%d] %s\n", ecore_list_index (feed->thumbs), tdump);
   }

   free (tbuf);

   gettimeofday(&tv, NULL);
   end = (uintmax_t)(tv.tv_sec * 1000000 + tv.tv_usec);
   printf ("*** Benchmark ***\n");
   printf("Iterations: %d , elapsed %ju usec\n", iterator, end - start);
}