//
// $Id: SIevents.hpp,v 1.29 2008/08/16 19:23:18 seife Exp $
//
// classes SIevent and SIevents (dbox-II-project)
//
//    Homepage: http://dbox2.elxsi.de
//
//    Copyright (C) 2001 fnbrd (fnbrd@gmx.de)
//
//    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., 675 Mass Ave, Cambridge, MA 02139, USA.
//
#ifndef SIEVENTS_HPP
#define SIEVENTS_HPP

#include <vector>
#include <map>
#include <set>
#include <algorithm>
#include <string>

#include <sectionsdclient/sectionsdtypes.h>
#include <dvbsi++/event_information_section.h>
#include "edvbstring.h"

class SIlinkage {
public:
	unsigned char linkageType;
	std::string name;
	t_transport_stream_id transportStreamId;
	t_original_network_id originalNetworkId;
	t_service_id          serviceId;

	SIlinkage(void) {
		linkageType = 0;
		transportStreamId = 0;
		originalNetworkId = 0;
		serviceId = 0;
	}
	

	void dump(void) const {
		printf("Linakge Type: 0x%02hhx\n", linkageType);
		if (name.length())
			printf("Name: %s\n", name.c_str());
		printf("Transport Stream Id: 0x%04hhx\n", transportStreamId);
		printf("Original Network Id: 0x%04hhx\n", originalNetworkId);
		printf("Service Id: 0x%04hhx\n", serviceId);
	}
	
	int saveXML(FILE *file) const {
		fprintf(file, "\t\t\t<linkage type=\"%02x\" linkage_descriptor=\"", linkageType);
		saveStringToXMLfile(file, name.c_str());
		fprintf(file, "\" transport_stream_id=\"%04x\" original_network_id=\"%04x\" service_id=\"%04x\" />\n", transportStreamId, originalNetworkId, serviceId);
//		%s, , name.c_str())<0)
//			return 1;
		return 0;
	}
	// Der Operator zum sortieren
	bool operator < (const SIlinkage& l) const {
		return name < l.name;
	}
	bool operator==(const SIlinkage& s) const {
		return (linkageType == s.linkageType) &&
			(transportStreamId == s.transportStreamId) &&
			(originalNetworkId == s.originalNetworkId) &&
			(serviceId == s.serviceId) &&
			(name == s.name);
	}
	bool operator!=(const SIlinkage& s) const {
		return (linkageType != s.linkageType) ||
			(transportStreamId != s.transportStreamId) ||
			(originalNetworkId != s.originalNetworkId) ||
			(serviceId != s.serviceId) ||
			(name != s.name);
	}
};
typedef std::vector<class SIlinkage> SIlinkage_descs;

// Fuer for_each
struct printSIlinkage : public std::unary_function<class SIlinkage, void>
{
	void operator() (const SIlinkage &l) { l.dump();}
};

// Fuer for_each
struct saveSIlinkageXML : public std::unary_function<class SIlinkage, void>
{
	FILE *f;
	saveSIlinkageXML(FILE *fi) { f=fi;}
	void operator() (const SIlinkage &l) { l.saveXML(f);}
};

class SIcomponent 
{
	public:
		std::string component;
		unsigned char componentType;
		unsigned char componentTag;
		unsigned char streamContent;

		SIcomponent(void) {
			streamContent=0;
			componentType=0;
			componentTag=0;      
		}
		void dump(void) const {
			if(component.length())
				printf("Component: %s\n", component.c_str());
			printf("Stream Content: 0x%02hhx\n", streamContent);
			printf("Component type: 0x%02hhx\n", componentType);
			printf("Component tag: 0x%02hhx\n", componentTag);
		}
		int saveXML(FILE *file) const {
			fprintf(file, "\t\t\t<component tag=\"%02x\" type=\"%02x\" stream_content=\"%02x\" text=\"", componentTag, componentType, streamContent);
			saveStringToXMLfile(file,component.c_str());
			fprintf(file, "\"/>\n");
			return 0;
		}
		// Der Operator zum sortieren
		bool operator < (const SIcomponent& c) const {
			return streamContent < c.streamContent;
		}
		bool operator==(const SIcomponent& c) const {
			return (componentType == c.componentType) &&
				(componentTag == c.componentTag) &&
				(streamContent == c.streamContent) &&
				(component == c.component);
		}
		bool operator!=(const SIcomponent& c) const {
			return (componentType != c.componentType) ||
				(componentTag != c.componentTag) ||
				(streamContent != c.streamContent) ||
				(component != c.component);
		}
};

typedef std::multiset <SIcomponent, std::less<SIcomponent> > SIcomponents;

// Fuer for_each
struct printSIcomponent : public std::unary_function<class SIcomponent, void>
{
	void operator() (const SIcomponent &c) { c.dump();}
};

// Fuer for_each
struct saveSIcomponentXML : public std::unary_function<class SIcomponent, void>
{
	FILE *f;
	saveSIcomponentXML(FILE *fi) { f=fi;}
	void operator() (const SIcomponent &c) { c.saveXML(f);}
};

class SIparentalRating 
{
	public:
		std::string countryCode;
		unsigned char rating; // Bei 1-16 -> Minumim Alter = rating +3

		SIparentalRating(const std::string &cc, unsigned char rate) {
			rating=rate;
			countryCode=cc;
		}

		// Der Operator zum sortieren
		bool operator < (const SIparentalRating& c) const {
			return countryCode < c.countryCode;
		}
		void dump(void) const {
			printf("Rating: %s %hhu (+3)\n", countryCode.c_str(), rating);
		}
		int saveXML(FILE *file) const {
			if(fprintf(file, "\t\t\t<parental_rating country=\"%s\" rating=\"%hhu\"/>\n", countryCode.c_str(), rating)<0)
				return 1;
			return 0;
		}
		bool operator==(const SIparentalRating& p) const {
			return (rating == p.rating) &&
				(countryCode == p.countryCode);
		}
		bool operator!=(const SIparentalRating& p) const {
			return (rating != p.rating) ||
				(countryCode != p.countryCode);
		}
};
typedef std::set <SIparentalRating, std::less<SIparentalRating> > SIparentalRatings;

// Fuer for_each
struct printSIparentalRating : public std::unary_function<SIparentalRating, void>
{
	void operator() (const SIparentalRating &r) { r.dump();}
};

// Fuer for_each
struct saveSIparentalRatingXML : public std::unary_function<SIparentalRating, void>
{
	FILE *f;
	saveSIparentalRatingXML(FILE *fi) { f=fi;}
	void operator() (const SIparentalRating &r) { r.saveXML(f);}
};

class SItime {
	public:
		time_t startzeit;  // lokale Zeit, 0 -> time shifted (cinedoms)
		unsigned dauer; // in Sekunden, 0 -> time shifted (cinedoms)

		SItime(time_t s, unsigned d) {
			startzeit=s;
			dauer=d; // in Sekunden, 0 -> time shifted (cinedoms)
		}

		// Der Operator zum sortieren
		bool operator < (const SItime& t) const {
			return startzeit < t.startzeit;
		}
		void dump(void) const {
			printf("Startzeit: %s", ctime(&startzeit));
			printf("Dauer: %02u:%02u:%02u (%umin, %us)\n", dauer/3600, (dauer%3600)/60, dauer%60, dauer/60, dauer);
		}
		int saveXML(FILE *file) const { // saves the time
			fprintf(file, "\t\t\t<time start_time=\"%u\" duration=\"%u\"/>\n", (unsigned int) startzeit, dauer);
			return 0;
		}
		bool operator==(const SItime& t) const {
			return (dauer == t.dauer) &&
				(startzeit == t.startzeit);
		}
		bool operator!=(const SItime& t) const {
			return (dauer != t.dauer) ||
				(startzeit != t.startzeit);
		}
};

typedef std::set <SItime, std::less<SItime> > SItimes;

// Fuer for_each
struct printSItime : public std::unary_function<SItime, void>
{
	void operator() (const SItime &t) { t.dump();}
};

// Fuer for_each
struct saveSItimeXML : public std::unary_function<SItime, void>
{
	FILE *f;
	saveSItimeXML(FILE *fi) { f=fi;}
	void operator() (const SItime &t) { t.saveXML(f);}
};

class SIevent
{
	private:
		std::map<std::string, std::string> langName;
		std::map<std::string, std::string> langText;
		std::map<std::string, std::string> langExtendedText;
		int running;

	protected:
		int saveXML0(FILE *f) const;
		int saveXML2(FILE *f) const;

	public:
		t_service_id          service_id;
		t_original_network_id original_network_id;
		t_transport_stream_id transport_stream_id;
		unsigned short eventID;
		time_t vps;
		unsigned char table_id;
		unsigned char version;

		SIcomponents components;
		SIparentalRatings ratings;
		SIlinkage_descs linkage_descs;
		SItimes times;

		std::string itemDescription; // Aus dem Extended Descriptor
		std::string item; // Aus dem Extended Descriptor
		std::string contentClassification; // Aus dem Content Descriptor, als String, da mehrere vorkommen koennen
		std::string userClassification; // Aus dem Content Descriptor, als String, da mehrere vorkommen koennen

		SIevent(const t_original_network_id, const t_transport_stream_id, const t_service_id, const unsigned short);
		SIevent(void) {
			service_id = 0;
			original_network_id = 0;
			transport_stream_id = 0;
			eventID    = 0;
			vps = 0;
			table_id = 0xFF; /* 0xFF means "not set" */
			version = 0xFF;
		}
		void parse(Event &event);

		// Name aus dem Short-Event-Descriptor
		std::string getName() const;
		void setName(const std::string &lang, const std::string &name);

		// Text aus dem Short-Event-Descriptor
		std::string getText() const;
		void setText(const std::string &lang, const std::string &text);

		// Aus dem Extended Descriptor
		std::string getExtendedText() const;
		void appendExtendedText(const std::string &lang, const std::string &text);
		void setExtendedText(const std::string &lang, const std::string &text);

		t_channel_id get_channel_id(void) const {
			return CREATE_CHANNEL_ID;
		}

		event_id_t uniqueKey(void) const {
			return CREATE_EVENT_ID(CREATE_CHANNEL_ID, eventID);
		}
		int runningStatus(void) const {
			return running;
		}
		// Der Operator zum sortieren
		bool operator < (const SIevent& e) const {
			return uniqueKey()<e.uniqueKey();
		}
		int saveXML(FILE *file) const { // saves the event
			return saveXML0(file) || saveXML2(file);
		}
		int saveXML(FILE *file, const char *serviceName) const; // saves the event
		char getFSK() const;

		void dump(void) const; // dumps the event to stdout
		void dumpSmall(void) const; // dumps the event to stdout (not all information)
};

typedef std::set <SIevent, std::less<SIevent> > SIevents;

// Fuer for_each
struct printSIevent : public std::unary_function<SIevent, void>
{
	void operator() (const SIevent &e) { e.dump();}
};

// Fuer for_each
struct saveSIeventXML : public std::unary_function<SIevent, void>
{
	FILE *f;
	saveSIeventXML(FILE *fi) { f=fi;}
	void operator() (const SIevent &e) { e.saveXML(f);}
};

#if 0
// Fuer for_each
struct saveSIeventXMLwithServiceName : public std::unary_function<SIevent, void>
{
  FILE *f;
  const SIservices *s;
  saveSIeventXMLwithServiceName(FILE *fi, const SIservices &svs) {f=fi; s=&svs;}
  void operator() (const SIevent &e) {
    SIservices::iterator k=s->find(SIservice(e.service_id, e.original_network_id, e.transport_stream_id));
    if(k!=s->end()) {
      if(k->serviceName.length())
      e.saveXML(f, k->serviceName.c_str());
    }
    else
      e.saveXML(f);
  }
};
#endif

#if 0
// Fuer for_each
struct printSIeventWithService : public std::unary_function<SIevent, void>
{
  printSIeventWithService(const SIservices &svs) { s=&svs;}
  void operator() (const SIevent &e) {
    SIservices::iterator k=s->find(SIservice(e.service_id, e.original_network_id, e.transport_stream_id));
    if(k!=s->end()) {
      char servicename[50];
      strncpy(servicename, k->serviceName.c_str(), sizeof(servicename)-1);
      servicename[sizeof(servicename)-1]=0;
      removeControlCodes(servicename);
      printf("Service-Name: %s\n", servicename);
//      printf("Provider-Name: %s\n", k->providerName.c_str());
    }
    e.dump();
//    e.dumpSmall();
    printf("\n");
  }
  const SIservices *s;
};

class SIevents : public std::set <SIevent, std::less<SIevent> >
{
  public:
    // Entfernt anhand der Services alle time shifted events (Service-Typ 0)
    // und sortiert deren Zeiten in die Events mit dem Text ein.
    void mergeAndRemoveTimeShiftedEvents(const SIservices &);
    // Loescht alte Events (aufgrund aktueller Zeit - seconds und Zeit im Event)
    void removeOldEvents(long seconds);
};
#endif

#endif // SIEVENTS_HPP