/*

  * PremiereEpg plugin to VDR (C++)

  *

  * (C) 2005-2008 Stefan Huelswitt <s.huelswitt@gmx.de>

  *

  * This code is base on the commandline tool premiereepg2vdr

  * (C) 2004-2005 by Axel Katzur software@katzur.de

  * but has been rewritten from scratch

  *

  * This code 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 code 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

  * Or, point your browser to http://www.gnu.org/copyleft/gpl.html

  */

 #include <stdarg.h>

 #include <vdr/plugin.h>

 #include <vdr/filter.h>

 #include <vdr/epg.h>

 #include <vdr/channels.h>

 #include <vdr/dvbdevice.h>

 #include <vdr/i18n.h>

 #include <vdr/config.h>

 #include <libsi/section.h>

 #include <libsi/descriptor.h>

 #include "i18n.h"

 #include "version.h"

 #if APIVERSNUM < 10401

 #error You need at least VDR API version 1.4.1 for this plugin

 #endif

 //#define DEBUG

 //#define DEBUG2

 #ifdef DEBUG

 #define d(x) { (x); }

 #else

 #define d(x) ; 

 #endif

 #ifdef DEBUG2

 #define d2(x) { (x); }

 #else

 #define d2(x) ; 

 #endif

 #define PMT_SCAN_TIMEOUT  10  // seconds

 #define PMT_SCAN_IDLE     300 // seconds

 // --- cSetupPremiereEpg -------------------------------------------------------

 const char *optPats[] = {

   "%s",

   "%s (Option %d)",

   "%s (O%d)",

   "#%2$d %1$s",

   "[%2$d] %1$s"

   };

 #define NUM_PATS (sizeof(optPats)/sizeof(char *))

 class cSetupPremiereEpg {

 public:

   int OptPat;

   int OrderInfo;

   int RatingInfo;

   int FixEpg;

 public:

   cSetupPremiereEpg(void);

   };

 cSetupPremiereEpg SetupPE;

 cSetupPremiereEpg::cSetupPremiereEpg(void)

 {

   OptPat=1;

   OrderInfo=1;

   RatingInfo=1;

   FixEpg=0;

 }

 // --- cMenuSetupPremiereEpg ------------------------------------------------------------

 class cMenuSetupPremiereEpg : public cMenuSetupPage {

 private:

   cSetupPremiereEpg data;

   const char *optDisp[NUM_PATS];

   char buff[NUM_PATS][32];

 protected:

   virtual void Store(void);

 public:

   cMenuSetupPremiereEpg(void);

   };

 cMenuSetupPremiereEpg::cMenuSetupPremiereEpg(void)

 {

   data=SetupPE;

   SetSection(tr("PremiereEPG"));

   optDisp[0]=tr("off");

   for(unsigned int i=1; i<NUM_PATS; i++) {

     snprintf(buff[i],sizeof(buff[i]),optPats[i],"Event",1);

     optDisp[i]=buff[i];

     }

   Add(new cMenuEditStraItem(tr("Tag option events"),&data.OptPat,NUM_PATS,optDisp));

   Add(new cMenuEditBoolItem(tr("Show order information"),&data.OrderInfo));

   Add(new cMenuEditBoolItem(tr("Show rating information"),&data.RatingInfo));

   Add(new cMenuEditBoolItem(tr("Fix EPG data"),&data.FixEpg));

 }

 void cMenuSetupPremiereEpg::Store(void)

 {

   SetupPE=data;

   SetupStore("OptionPattern",SetupPE.OptPat);

   SetupStore("OrderInfo",SetupPE.OrderInfo);

   SetupStore("RatingInfo",SetupPE.RatingInfo);

   SetupStore("FixEpg",SetupPE.FixEpg);

 }

 // --- CRC16 -------------------------------------------------------------------

 #define POLY 0xA001 // CRC16

 unsigned int crc16(unsigned int crc, unsigned char const *p, int len)

 {

   while(len--) {

     crc^=*p++;

     for(int i=0; i<8; i++)

       crc=(crc&1) ? (crc>>1)^POLY : (crc>>1);

     }

   return crc&0xFFFF;

 }

 // --- cStrBuff ----------------------------------------------------------------

 class cStrBuff {

 private:

   char *buff;

   int size, pos;

 public:

   cStrBuff(int Size);

   ~cStrBuff();

   void Printf(const char *fmt, ...) __attribute__ ((format (printf,2,3)));

   char *Buff(void) { return (buff && pos>0) ? strdup(buff):0; }

   };

 cStrBuff::cStrBuff(int Size)

 {

   size=Size; pos=0;

   buff=MALLOC(char,size);

 }

 cStrBuff::~cStrBuff()

 {

   free(buff);

 }

 void cStrBuff::Printf(const char *fmt, ...)

 {

   int s=size-pos;

   if(buff && s>0) {

     va_list ap;

     va_start(ap,fmt);

     int q=vsnprintf(buff+pos,s,fmt,ap);

     va_end(ap);

     if(q>0) pos+=q;

     }

 }

 // --- cFilterPremiereEpg ------------------------------------------------------

 #define STARTTIME_BIAS (20*60)

 class cFilterPremiereEpg : public cFilter {

 private:

   int pmtpid, pmtsid, pmtidx, pmtnext;

   //

   void NextPmt(void);

 protected:

   virtual void Process(u_short Pid, u_char Tid, const u_char *Data, int Length);

 public:

   cFilterPremiereEpg(void);

   virtual void SetStatus(bool On);

   void Trigger(void);

   };

 cFilterPremiereEpg::cFilterPremiereEpg(void)

 {

   Trigger();

   Set(0x00,0x00);

 }

 void cFilterPremiereEpg::Trigger(void)

 {

   d(printf("trigger\n"))

   pmtpid=0; pmtidx=0; pmtnext=0;

 }

 void cFilterPremiereEpg::SetStatus(bool On)

 {

   d(printf("setstatus %d\n",On))

   cFilter::SetStatus(On);

   Trigger();

 }

 void cFilterPremiereEpg::NextPmt(void)

 {

   Del(pmtpid,0x02);

   pmtpid=0;

   pmtidx++;

   d(printf("PMT next\n"))

 }

 void cFilterPremiereEpg::Process(u_short Pid, u_char Tid, const u_char *Data, int Length)

 {

   int now=time(0);

   if(Pid==0 && Tid==SI::TableIdPAT) {

     if(!pmtnext || now>pmtnext) {

       if(pmtpid) NextPmt();

       if(!pmtpid) {

         SI::PAT pat(Data,false);

         if(pat.CheckCRCAndParse()) {

           SI::PAT::Association assoc;

           int idx=0;

           for(SI::Loop::Iterator it; pat.associationLoop.getNext(assoc,it);) {

             if(!assoc.isNITPid()) {

               if(idx++==pmtidx) {

                 pmtpid=assoc.getPid();

                 pmtsid=assoc.getServiceId();

                 Add(pmtpid,0x02);

                 pmtnext=now+PMT_SCAN_TIMEOUT;

                 d(printf("PMT pid now 0x%04x (idx=%d)\n",pmtpid,pmtidx))

                 break;

                 }

               }

             }

           if(!pmtpid) {

             pmtidx=0;

             pmtnext=now+PMT_SCAN_IDLE;

             d(printf("PMT scan idle\n"))

             }

           }

         }

       }

     }

   else if(pmtpid>0 && Pid==pmtpid && Tid==SI::TableIdPMT && Source() && Transponder()) {

     SI::PMT pmt(Data,false);

     if(pmt.CheckCRCAndParse() && pmt.getServiceId()==pmtsid) {

       SI::PMT::Stream stream;

       for(SI::Loop::Iterator it; pmt.streamLoop.getNext(stream,it); ) {

         if(stream.getStreamType()==0x05) {

           SI::CharArray data=stream.getData();

           if((data[1]&0xE0)==0xE0 && (data[3]&0xF0)==0xF0) {

             bool prvData=false, usrData=false;

             SI::Descriptor *d;

             for(SI::Loop::Iterator it; (d=stream.streamDescriptors.getNext(it)); ) {

               switch(d->getDescriptorTag()) {

                 case SI::PrivateDataSpecifierDescriptorTag:

                   d(printf("prv: %d %08x\n",d->getLength(),d->getData().FourBytes(2)))

                   if(d->getLength()==6 && d->getData().FourBytes(2)==0x000000be)

                     prvData=true;

                   break;

                 case 0x90:

                   d(printf("usr: %d %08x\n",d->getLength(),d->getData().FourBytes(2)))

                   if(d->getLength()==6 && d->getData().FourBytes(2)==0x0000ffff)

                     usrData=true;

                   break;

                 default:

                   break;

                 }

               delete d;

               }

             if(prvData && usrData) {

               int pid=stream.getPid();

               d(printf("found citpid 0x%04x",pid))

               if(!Matches(pid,0xA0)) {

                 Add(pid,0xA0);

                 d(printf(" (added)"))

                 }

               d(printf("\n"))

               }

             }

           }

         }

       NextPmt(); pmtnext=0;

       }

     }

   else if(Tid==0xA0 && Source()) {

     SI::PremiereCIT cit(Data,false);

     if(cit.CheckCRCAndParse()) {

       cSchedulesLock SchedulesLock(true,10);

       cSchedules *Schedules=(cSchedules *)cSchedules::Schedules(SchedulesLock);

       if(Schedules) {

         int nCount=0;

         SI::ExtendedEventDescriptors *ExtendedEventDescriptors=0;

         SI::ShortEventDescriptor *ShortEventDescriptor=0;

         char *order=0, *rating=0;

         {

         time_t firstTime=0;

         SI::Descriptor *d;

         bool UseExtendedEventDescriptor=false;

         int LanguagePreferenceShort=-1;

         int LanguagePreferenceExt=-1;

         for(SI::Loop::Iterator it; (d=cit.eventDescriptors.getNext(it)); ) {

           switch(d->getDescriptorTag()) {

             case 0xF0: // order information

               if(SetupPE.OrderInfo) {

                 static const char *text[] = {

                   trNOOP("Ordernumber"),

                   trNOOP("Price"),

                   trNOOP("Ordering"),

                   trNOOP("SMS"),

                   trNOOP("WWW")

                   };

                 cStrBuff str(1024);

                 const unsigned char *data=d->getData().getData()+2;

                 for(int i=0; i<5; i++) {

                   int l=data[0]; 

                   if(l>0) str.Printf("\n%s: %.*s",tr(text[i]),l,&data[1]);

                   data+=l+1;

                   }

                 order=str.Buff();

                 }

               break;

             case 0xF1: // parental rating

               if(SetupPE.RatingInfo) {

                 cStrBuff str(1024);

                 const unsigned char *data=d->getData().getData()+2;

                 str.Printf("\n%s: %d %s",tr("Rating"),data[0]+3,tr("years"));

                 data+=7;

                 int l=data[0]; 

                 if(l>0) str.Printf(" (%.*s)",l,&data[1]);

                 rating=str.Buff();

                 }

               break;

             case SI::PremiereContentTransmissionDescriptorTag:

               if(nCount>=0) {

                 SI::PremiereContentTransmissionDescriptor *pct=(SI::PremiereContentTransmissionDescriptor *)d;

                 nCount++;

                 SI::PremiereContentTransmissionDescriptor::StartDayEntry sd;

                 SI::Loop::Iterator it;

                 if(pct->startDayLoop.getNext(sd,it)) {

                   SI::PremiereContentTransmissionDescriptor::StartDayEntry::StartTimeEntry st;

                   SI::Loop::Iterator it2;

                   if(sd.startTimeLoop.getNext(st,it2)) {

                     time_t StartTime=st.getStartTime(sd.getMJD());

                     if(nCount==1) firstTime=StartTime;

                     else if(firstTime<StartTime-5*50 || firstTime>StartTime+5*60)

                       nCount=-1;

                     }

                   }

                 }

               break;

             case SI::ExtendedEventDescriptorTag:

               {

               SI::ExtendedEventDescriptor *eed=(SI::ExtendedEventDescriptor *)d;

               if(I18nIsPreferredLanguage(Setup.EPGLanguages,eed->languageCode, LanguagePreferenceExt) || !ExtendedEventDescriptors) {

                  delete ExtendedEventDescriptors;

                  ExtendedEventDescriptors=new SI::ExtendedEventDescriptors;

                  UseExtendedEventDescriptor=true;

                  }

               if(UseExtendedEventDescriptor) {

                  ExtendedEventDescriptors->Add(eed);

                  d=NULL; // so that it is not deleted

                  }

               if(eed->getDescriptorNumber()==eed->getLastDescriptorNumber())

                  UseExtendedEventDescriptor=false;

               }

               break;

             case SI::ShortEventDescriptorTag:

               {

               SI::ShortEventDescriptor *sed=(SI::ShortEventDescriptor *)d;

               if(I18nIsPreferredLanguage(Setup.EPGLanguages,sed->languageCode, LanguagePreferenceShort) || !ShortEventDescriptor) {

                  delete ShortEventDescriptor;

                  ShortEventDescriptor=sed;

                  d=NULL; // so that it is not deleted

                  }

               }

               break;

             default:

               break;

             }

           delete d;

           }

         }

         {

         bool Modified=false;

         int optCount=0;

         unsigned int crc[3];

         crc[0]=cit.getContentId();

         SI::PremiereContentTransmissionDescriptor *pct;

         for(SI::Loop::Iterator it; (pct=(SI::PremiereContentTransmissionDescriptor *)cit.eventDescriptors.getNext(it,SI::PremiereContentTransmissionDescriptorTag)); ) {

           int nid=pct->getOriginalNetworkId();

           int tid=pct->getTransportStreamId();

           int sid=pct->getServiceId();

           if(SetupPE.FixEpg) {

             if(nid==133) {

 	      if     (tid==0x03 && sid==0xf0) { tid=0x02; sid=0xe0; }

 	      else if(tid==0x03 && sid==0xf1) { tid=0x02; sid=0xe1; }

 	      else if(tid==0x03 && sid==0xf5) { tid=0x03; sid=0xdc; }

 	      else if(tid==0x04 && sid==0xd2) { tid=0x11; sid=0xe2; }

 	      else if(tid==0x11 && sid==0xd3) { tid=0x11; sid=0xe3; }

 	      else if(tid==0x01 && sid==0xd4) { tid=0x04; sid=0xe4; }

               }

             }

           tChannelID channelID(Source(),nid,tid,sid);

           cChannel *channel=Channels.GetByChannelID(channelID,true);

           if(!channel) continue;

           cSchedule *pSchedule=(cSchedule *)Schedules->GetSchedule(channelID);

           if(!pSchedule) {

              pSchedule=new cSchedule(channelID);

              Schedules->Add(pSchedule);

              }

           optCount++;

           SI::PremiereContentTransmissionDescriptor::StartDayEntry sd;

           int index=0;

           for(SI::Loop::Iterator it; pct->startDayLoop.getNext(sd,it); ) {

             int mjd=sd.getMJD();

             SI::PremiereContentTransmissionDescriptor::StartDayEntry::StartTimeEntry st;

             for(SI::Loop::Iterator it2; sd.startTimeLoop.getNext(st,it2); ) {

               time_t StartTime=st.getStartTime(mjd);

               time_t EndTime=StartTime+cit.getDuration();

               int runningStatus=(StartTime<now && now<EndTime) ? SI::RunningStatusRunning : ((StartTime-30<now && now<StartTime) ? SI::RunningStatusStartsInAFewSeconds : SI::RunningStatusNotRunning);

               bool isOpt=false;

               if(index++==0 && nCount>1) isOpt=true;

               crc[1]=isOpt ? optCount : 0;

               crc[2]=StartTime / STARTTIME_BIAS;

               tEventID EventId=((('P'<<8)|'W')<<16) | crc16(0,(unsigned char *)crc,sizeof(crc));

               d2(printf("%s R%d %04x/%.4x %d %d/%d %s +%d ",*channelID.ToString(),runningStatus,EventId&0xFFFF,cit.getContentId(),index,isOpt,optCount,stripspace(ctime(&StartTime)),(int)cit.getDuration()/60))

               if(EndTime+Setup.EPGLinger*60<now) {

                 d2(printf("(old)\n"))

                 continue;

                 }

               bool newEvent=false;

               cEvent *pEvent=(cEvent *)pSchedule->GetEvent(EventId,-1);

               if(!pEvent) {

                 d2(printf("(new)\n"))

                 pEvent=new cEvent(EventId);

                 if(!pEvent) continue;

                 newEvent=true;

                 }

               else {

                 d2(printf("(upd)\n"))

                 pEvent->SetSeen();

                 if(pEvent->TableID()==0x00 || pEvent->Version()==cit.getVersionNumber()) {

                   if(pEvent->RunningStatus()!=runningStatus)

                     pSchedule->SetRunningStatus(pEvent,runningStatus,channel);

                   continue;

                   }

                 }

               pEvent->SetEventID(EventId);

               pEvent->SetTableID(Tid);

               pEvent->SetVersion(cit.getVersionNumber());

               pEvent->SetStartTime(StartTime);

               pEvent->SetDuration(cit.getDuration());

               if(ShortEventDescriptor) {

                 char buffer[256];

                 ShortEventDescriptor->name.getText(buffer,sizeof(buffer));

                 if(isOpt) {

                   char buffer2[sizeof(buffer)+32];

                   snprintf(buffer2,sizeof(buffer2),optPats[SetupPE.OptPat],buffer,optCount);

                   pEvent->SetTitle(buffer2);

                   }

                 else

                   pEvent->SetTitle(buffer);

                 d2(printf("title: %s\n",pEvent->Title()))

                 pEvent->SetShortText(ShortEventDescriptor->text.getText(buffer,sizeof(buffer)));

                 }

               if(ExtendedEventDescriptors) {

                 char buffer[ExtendedEventDescriptors->getMaximumTextLength(": ")+1];

                 pEvent->SetDescription(ExtendedEventDescriptors->getText(buffer,sizeof(buffer),": "));

                 }

               if(order || rating) {

                 int len=(pEvent->Description() ? strlen(pEvent->Description()) : 0) +

                         (order                 ? strlen(order) : 0) +

                         (rating                ? strlen(rating) : 0);

                 char buffer[len+32];

                 buffer[0]=0;

                 if(pEvent->Description()) strcat(buffer,pEvent->Description());

                 if(rating)                strcat(buffer,rating);

                 if(order)                 strcat(buffer,order);

                 pEvent->SetDescription(buffer);

                 }

               if(newEvent) pSchedule->AddEvent(pEvent);

               pEvent->SetComponents(NULL);

               pEvent->FixEpgBugs();

               if(pEvent->RunningStatus()!=runningStatus)

                 pSchedule->SetRunningStatus(pEvent,runningStatus,channel);

               pSchedule->DropOutdated(StartTime,EndTime,Tid,cit.getVersionNumber());

               Modified=true;

               }

             }

           if(Modified) {

             pSchedule->Sort();

             Schedules->SetModified(pSchedule);

             }

           delete pct;

           }

         }

         delete ExtendedEventDescriptors;

         delete ShortEventDescriptor;

         free(order);

         free(rating);

         }

       }

     }

 }

 // --- cPluginPremiereEpg ------------------------------------------------------

 static const char *DESCRIPTION    = trNOOP("Parses extended Premiere EPG data");

 class cPluginPremiereEpg : public cPlugin {

 private:

   struct {

     cFilterPremiereEpg *filter;

     cDevice *device;

     } epg[MAXDVBDEVICES];

 public:

   cPluginPremiereEpg(void);

   virtual const char *Version(void) { return PluginVersion; }

   virtual const char *Description(void) { return tr(DESCRIPTION); }

   virtual bool Start(void);

   virtual void Stop(void);

   virtual cMenuSetupPage *SetupMenu(void);

   virtual bool SetupParse(const char *Name, const char *Value);

   };

 cPluginPremiereEpg::cPluginPremiereEpg(void)

 {

   memset(epg,0,sizeof(epg));

 }

 bool cPluginPremiereEpg::Start(void)

 {

 #if APIVERSNUM < 10507

   RegisterI18n(Phrases);

 #endif

   for(int i=0; i<MAXDVBDEVICES; i++) {

     cDevice *dev=cDevice::GetDevice(i);

     if(dev) {

       epg[i].device=dev;

       dev->AttachFilter(epg[i].filter=new cFilterPremiereEpg);

       isyslog("Attached premiere EPG filter to device %d",i);

       }

     }

   return true;

 }

 void cPluginPremiereEpg::Stop(void)

 {

   for(int i=0; i<MAXDVBDEVICES; i++) {

     cDevice *dev=epg[i].device;

     if(dev) dev->Detach(epg[i].filter);

     delete epg[i].filter;

     epg[i].device=0;

     epg[i].filter=0;

     }

 }

 cMenuSetupPage *cPluginPremiereEpg::SetupMenu(void)

 {

   return new cMenuSetupPremiereEpg;

 }

 bool cPluginPremiereEpg::SetupParse(const char *Name, const char *Value)

 {

   if      (!strcasecmp(Name, "OptionPattern")) SetupPE.OptPat     = atoi(Value);

   else if (!strcasecmp(Name, "OrderInfo"))     SetupPE.OrderInfo  = atoi(Value);

   else if (!strcasecmp(Name, "RatingInfo"))    SetupPE.RatingInfo = atoi(Value);

   else if (!strcasecmp(Name, "FixEpg"))        SetupPE.FixEpg     = atoi(Value);

   else return false;

   return true;

 }

 VDRPLUGINCREATOR(cPluginPremiereEpg); // Don't touch this!