#!/usr/bin/ruby -w

require 'optparse'
require 'ostruct'
require 'net/http'
require 'uri'
require 'rexml/document'

include REXML

NOW = Time.now
ONE_DAY = 86400

class Grabber
  PROGRAM = $0.sub( /^.*\//, '' )
  VERSION = '0.9.9'
  RELEASE = '$Id: tv_grab_nl_upc,v 1.133 2008/06/17 05:26:30 ianmacd Exp $'
  GUIDE = 'http://epg.upc.nl/Entertainment/TV_gids/'
  DESC = 'UPC Cable TV, The Netherlands (%s)' % [ GUIDE ]
  URL = 'http://www.caliban.org/ruby/xmltv_upc.shtml'
  CAPABILITIES = %w[ baseline manualconfig ]
  WORKING_DIR = File.expand_path( '~/.xmltv' )
end

class Rating
  IMDB_URL = 'http://uk.imdb.com'
  RATINGS_FILE = File.join( Grabber::WORKING_DIR, 'ratings.list' )
  RATINGS_FILE_GZ = File.join( Grabber::WORKING_DIR, 'ratings.list.gz' )
  RATINGS_CACHE_FILE = 'ratings_cache.yaml'

  @@rated = 0
  @@not_rated = 0
  @@cache = {}
  @@cache_positives = 0
  @@cache_negatives = 0
  @@ratings = {}

  attr_reader :timestamp
  attr_accessor :rating, :ctime, :mtime

  def Rating.get_ratings_list( options )

    # Download the ratings file if it doesn't exist or is older than 7 days.
    # See http://www.imdb.com/interfaces#plain for more information.
    #
    if ! File.exist?( RATINGS_FILE ) ||
	   ( NOW - File.mtime( RATINGS_FILE ) ) / ONE_DAY > 7
      if options.verbose
	$stderr.puts 'Attempting to download IMDB ratings list via FTP...'
      end

      require 'net/ftp'

      Net::FTP.open( 'ftp.funet.fi' ) do |ftp|
	ftp.debug_mode = true if options.debug
	ftp.login
	ftp.chdir( '/pub/mirrors/ftp.imdb.com/pub' )
	ftp.passive = true
	ftp.getbinaryfile( 'ratings.list.gz', RATINGS_FILE_GZ, 1024 )
      end

      require 'shell'

      begin
	gunzip = Shell::CommandProcessor.new( Shell.new ).
		 find_system_command( 'gunzip' )
      
      # If we don't have gunzip in our PATH, an exception will be raised.
      #
      rescue Shell::Error::CommandNotFound
	$stderr.puts 'Please gunzip %s and then rerun.' % [ RATINGS_FILE_GZ ]
	exit
      end

      # Decompress ratings file.
      #
      $stderr.puts 'Decompressing ratings file...' if options.verbose
      system( gunzip, '-f', RATINGS_FILE_GZ )
    end
  end

  def Rating.cache_rating( title, options, rating )
    if rating
      $stderr.puts '      Succeeded: %s.' % [ rating ] if options.verbose
  
      # Cache the result and return a rating, e.g. 7/10.
      #
      @@cache[title] = Rating.new( rating )
      @@rated += 1

      @@cache[title].rating
    else
      $stderr.puts '      Failed.' if options.verbose

      # Cache a negative result and return nil.
      #
      @@cache[title] = Rating.new( false )
      @@not_rated += 1

      nil
    end
  end
  
  def Rating.imdb_rating( title, options )

    # Titles come from UPC as UTF-8, so we check for any accented alpha
    # characters in the title and, if we find them, convert the title to
    # Latin-1 (ISO-8859-1).
    #
    if title =~ /\xC3[\x80-\xBF]/
      title = title.unpack( 'U*' ).pack( 'c*' )
    end

    if options.verbose
      $stderr.puts '      Attempting to rate "%s"...' % [ title ]
    end

    if @@cache.key?( title )

      # Update timestamp on cache entry.
      #
      @@cache[title].mtime = Time.now

      if @@cache[title].rating
	if options.verbose
	  $stderr.puts '      Found in cache: %s.' % [ @@cache[title].rating ]
	end
	@@cache_positives += 1

	return @@cache[title].rating

      elsif @@cache[title].rating == false
	$stderr.puts '      Negative result found in cache.' if options.verbose
	@@cache_negatives += 1

	return nil
      end
    end

    if options.static_ratings
      rating = nil

      # If static ratings are desired, create the hash of titles and ratings
      # from the static IMDB ratings file.
      #
      if @@ratings.empty?
	$stderr.puts '        Reading ratings file...' if options.verbose

	File.open( RATINGS_FILE ) do |f|
	  rating = nil
	  body = false

	  f.each_line do |l|

	    # Get to the right point in the file.
	    #
	    body = true if l =~ /^MOVIE RATINGS REPORT/
	    next unless body

	    if m = l.match( /^\s+\S{10}\s+\d+\s+(\d+\.\d+)\s+(.+)$/ )

	      # Remove year and any other trailing stuff from film title and
	      # convert it to lower case.
	      #
	      t = m[2].sub( /\s*\(\d+\).*$/, '' ).downcase

	      # Store the rating.
	      #
	      @@ratings[t] = m[1]
	    end

	  end

	  if options.verbose
	    $stderr.puts '        Read %d ratings.' % [ @@ratings.size ]
	  end
	end
      end

      l_title = title.downcase
      rating = @@ratings[l_title] + '/10' if @@ratings.key?( l_title )
      return Rating.cache_rating( title, options, rating )
    end

    #
    # Otherwise, grab the rating dynamically from IMDB.
    #
    guide_title = title.clone
    res = nil

    loop do
      # When parsing the URL, we have to remove any ampersand entities in the
      # title.
      #
      url = URI.parse( IMDB_URL + '/find?q=%s;s=tt' %
          	     [ url_encode( title.gsub( /&/, '&' ) ) ] )
      req = Net::HTTP::Get.new( url.path + '?' + url.query )
      res = get_page( url, req, options )
  
      # This version of the title will be used for matching. It has all
      # non-alphanumeric characters made optional and all accented alpha
      # characters (and ampersand entities) replaced by a regex that will match
      # any HTML entity at that position in the string.
      #
      # Note that the # character must be escaped, as we will be interpolating
      # it into the /x style regex that follows.
      #
      mod_title = title.gsub( /&/, '&' ).
          	      gsub( /[^&[:alnum:]\xA0-\xFF]/, '.?' ).
          	      gsub( /[&\xA0-\xFF]/, '&(?:\#\d+|[[:alpha:]]+);' )

      if m = res.match( /
	  # Most film titles return 'Popular Titles', but occasionally one
	  # will return just 'Exact Matches' (or even 'Approx Matches', which
	  # we ignore).
	  #
          <p><b>(?:Popular\sTitles |
          	 Titles\s\(Exact\sMatches\)
                )<\/b>\s+
          
	  # Now we can grab the URL path of the first film in the list, which
	  # may not actually be the right one if the film has been remade.
          #
	  \(Displaying\s\d+\sResults?\).+?<a\shref="([^"]+)">
          
          # But we must also make sure that we really did match the same title,
          # not a substring of some other title. To achieve a slightly fuzzy
          # match, we match case-insensitively, using an embedded pattern-match
          # modifier (i.e. (?i:pattern) ) and a modified version of the title.
          #
          # This can be done, because the interpolation of the result from the
          # code below takes place before the regex is matched.
          #
          (?i:#{mod_title})<\/a>
        /x )

	# Now we follow the URL path to get the ratings page.
        #
        url = URI.parse( IMDB_URL + m[1] )
        req = Net::HTTP::Get.new( url.path )
        res = get_page( url, req, options )

	# Extract the rating from the page.
	#
        break

      elsif res !~ /<b>[\d\.]+\/\d+<\/b>(?:.{0,32}\(<a href="ratings">[\d,]+ votes<\/a>\))/m && title.sub!( /, The$/, '' )
	# If we haven't just fetched the film's ratings page and its title
	# ends with ', The', we can try again with 'The' at the beginning of
	# the title instead.
	#
        title = 'The ' + title
        if options.debug
          $stderr.puts '        Reattempting as "%s"...' % [ title ]
        end

	redo
      else
	# We must be on the ratings page.
	#
        break
      end

    end
  
    # At this point, we should have a page that contains a rating for this
    # film.
    #
    m = res.match( /<b>([\d\.]+\/\d+)<\/b>(?:.{0,32}\(<a href="ratings">[\d,]+ votes<\/a>\))/m )
    Rating.cache_rating( guide_title, options, m ? m[1] : nil )
  
  end

  def Rating.load_cache( options )
    require 'yaml'

    if File.exist?( options.ratings )
      $stderr.puts 'Loading ratings cache file...' if options.verbose
      @@cache = File.open( options.ratings ) { |f| YAML.load( f ) } || {}

      # Expire any cache entries older than a week.
      #
      orig_size = @@cache.size
      positive = 0
      negative = 0

      $stderr.puts 'Expiring ratings cache entries...' if options.debug
      @@cache.delete_if do |title, entry|

	# Legacy: @mtime used to be @timestamp.
	#
	if entry.timestamp
	  entry.mtime ||= entry.timestamp
	  entry.ctime ||= entry.mtime

	  # Remove old attribute using a temporary singleton method.
	  #
	  def entry.clean
	    remove_instance_variable( '@timestamp' )
	  end
	  entry.clean

	  # Remove the singleton method we just created.
	  #
	  # class << entry; undef :clean; end
	end

	# Delete on this basis:
	#
	if ( NOW - entry.mtime ) / ONE_DAY > 7
	  true
	else
	  # Or count the positive/negative cache entries.
	  #
	  entry.rating ? positive += 1 : negative += 1
	  false
	end
      end

      if options.verbose
	$stderr.puts '%d rating(s) expired. %d remaining, of which %d positive and %d negative.' %
	  [ orig_size - @@cache.size, @@cache.size, positive, negative ]
      end

    else
      $stderr.puts 'No ratings cache file found.'
      nil
    end
  end

  def Rating.dump_cache( options )
    $stderr.puts 'Dumping ratings cache file...' if options.verbose
    File.open( options.ratings, 'w' ) { |f| YAML.dump( @@cache, f ) }

    if options.verbose
      $stderr.puts '%d ratings cache entries written.' % [ @@cache.size ]
    end
  end

  def Rating.rated
    @@rated
  end

  def Rating.not_rated
    @@not_rated
  end

  def Rating.cache_positives
    @@cache_positives
  end

  def Rating.cache_negatives
    @@cache_negatives
  end

  def initialize( rating )
    @rating = rating
    @ctime = @mtime = Time.now
  end
end

class ProgramOptions

  def self.parse( args )
    o = OpenStruct.new

    op = OptionParser.new do |opt|
      opt.banner = "Usage: #{Grabber::PROGRAM} [options]"
      opt.version = VERSION

      opt.define( "\n  All options may be specified using the shortest " +
		  'unique string.' )
      opt.define( '  For example, --output-file may be abbreviated to ' +
		  "--output or even --out.\n")
      opt.define( "  See #{Grabber::URL} for further details.\n" )

      # Capabilities are defined here:
      #
      # http://www.xmltv.org/wiki/xmltvcapabilities.html
      #
      opt.define( '--capabilities',
		  "List this grabber's capabilities and exit." ) do
	puts Grabber::CAPABILITIES
	exit
      end

      o.cattrans = true
      opt.define( '--[no-]cattrans', 'Perform category translation.',
		  "(default: #{o.cattrans})" ) do |trans|
	o.cattrans = trans
      end

      o.config = File.join( Grabber::WORKING_DIR, 'tv_grab_nl_upc.conf' )
      opt.define( '--config-file FILE',
		  'File containing channel numbers and names.',
		  '(default:',
		  o.config + ')' ) do |file|
	o.config = File.expand_path( file )
      end

      o.configure = false
      opt.define( '--configure', 'Create a configuration file',
		  '(will overwrite existing file).' ) do |config|
	o.configure = config
      end

      o.days = 7
      opt.define( '--days NUMBER',
		  'Fetch data for NUMBER days (1 = today only)',
		  "(default: #{o.days})",
		  Integer ) do |days|
	o.days = days
      end

      o.debug = false
      opt.define( '--debug', 'Print debugging messages. Debugging can',
		  'be dynamically toggled with SIGUSR1.' ) do |debug|
	o.debug = debug
      end

      opt.define( '--description', 'Describe this grabber and exit.' ) do
	puts Grabber::DESC
	exit
      end

      opt.define( '--help', 'Display this usage message and exit.' ) do
	puts opt
	exit
      end

      o.icons = false
      opt.define( '--icons',
		  'Include icon links for the channels.' ) do |icons|
	o.icons = icons
      end
      opt.define( '--logos', 'Alias for --icons.' ) { |icons| o.icons = icons }

      o.offset = 0
      opt.define( '--offset DAYS',
		  'Start day from which to start fetching.',
		  "(default: #{o.offset})", Integer ) do |days|
	o.offset = days
      end

      o.output = nil
      opt.define( '--output-file FILE',
		  '(N.B. Filled in by mythfilldatabase.)' ) do |file|
	o.output = file
      end

      o.quiet = false
      opt.define( '--quiet', 'Suppress warnings and errors.' ) do |quiet|
	o.quiet = quiet
      end

      o.ratings = false
      opt.define( '--[no-]ratings [DIR]',
		  'Attempt to dynamically rate films via IMDB',
		  'and cache results (in DIR, if given).',
		  "(default: #{o.ratings})" ) do |ratings|
	if ratings.nil?
	  o.ratings = File.join( Grabber::WORKING_DIR,
				 Rating::RATINGS_CACHE_FILE )
	elsif ratings
	  o.ratings = File.join( File.expand_path( ratings ),
				 Rating::RATINGS_CACHE_FILE )
	end
      end

      o.sanity = false
      opt.define( '--sanity-check',
		  'Perform sanity checks before pulling data.' ) do |sanity|
	o.sanity = sanity
      end

      opt.define( '--schema SCHEMA', [ '1', '2' ],
		  'Choose which programme schema to use.',
		  '(This option no longer has any effect.)',
		  Integer ) do |schema|
      end

      o.sleep = 1.0
      opt.define( '--sleep SECONDS',
		  'Sleep this many seconds between each page',
		  "fetch. (default: #{o.sleep})",
		  Float ) do |secs|
	o.sleep = secs
      end

      o.static_ratings = false
      opt.define( '--static-ratings',
		  'Attempt to statically rate films via IMDB.',
		  "(default: #{o.static_ratings})" ) do |ratings|
	o.static_ratings = ratings
      end

      o.threads = false
      opt.define( '--threads',
		  'Use threads to fetch channel data in',
		  'parallel. (experimental) ' +
		  "(default: #{o.threads})" ) do |threads|
	o.threads = threads
      end

      o.tries = 3
      opt.define( '--tries TRIES',
		  'Number of times to try each page fetch.',
		  "(default: #{o.tries})",
		  Integer ) do |tries|
	o.tries = tries
      end

      o.verbose = false
      opt.define( '--verbose', 'Print informational messages. Verbosity',
		  'can be dynamically toggled with SIGUSR2.' ) do |verbose|
	o.verbose = verbose
      end

      opt.define( '--version', 'Display program version and exit.' ) do
	puts '%s v%s  (C) 2006-2007 Ian Macdonald' %
	  [ Grabber::PROGRAM, Grabber::VERSION ]
	exit
      end

      o.xmltvid_suffix = '.chello.nl'
      opt.define( '--xmltvid-suffix STRING',
		  'Suffix to add to channel number to form',
		  'XMLTV ID. (default: .chello.nl)' ) do |suf|
	o.xmltvid_suffix = suf
      end

    end

    options = op.parse!( args )
    return o

  end
end

BASE_URL = 'http://epg.upc.nl'

# Category translations.
#
CATEGORIES = { 'Actie'		  => 'Action',
	       'Algemeen'	  => 'Misc',
	       'Atletiek'	  => 'Sports',
	       'Avontuur'	  => 'Action',
	       'Beeldende kunst'  => 'Arts/Culture',
	       'Detective'	  => 'Crime/Mystery',
	       'Documentaire'	  => 'Documentary',
	       'Drama'		  => 'Drama',
	       'Educatie'	  => 'Educational',
	       'Erotiek'	  => 'Adult',
	       'Extreme'	  => 'Sports',
	       'Gevechtssport'	  => 'Sports',
	       'Gezondheid'	  => 'Health/Medical',
	       'Historisch'	  => 'History',
	       'Kids / jeugd'	  => 'Children',
	       'Kids/jeugd'       => 'Children',
	       'Klussen'	  => 'HowTo',
	       'Koken'		  => 'Food',
	       'Komedie'	  => 'Comedy',
	       'Kunst / cultuur'  => 'Arts/Culture',
	       'Kunst/cultuur'    => 'Arts/Culture',
	       'Lifestyle'	  => 'Educational',
	       'Melodrama'	  => 'Soaps',
	       'Militair'	  => 'War',
	       'Mode'		  => 'Educational',
	       'Motorsport'	  => 'Sports',
	       'Musical'	  => 'Movies',
	       'Muziek'		  => 'Art/Music',
	       'Nieuws'		  => 'News',
	       'Paardensport'	  => 'Sports',
	       'Religie'	  => 'Spiritual',
	       'Romantiek'	  => 'Romance',
	       'Sci-fi'		  => 'SciFi/Fantasy',
	       'Show'		  => 'Game',
	       'Show/spelshow'	  => 'Game',
	       'Speelfilm'	  => 'Movies',
	       'Sport'		  => 'Sports',
	       'Sportmagazine'	  => 'Sports',
	       'Talkshow'	  => 'Talk',
	       'Teamsporten'	  => 'Sports',
	       'Technologie'	  => 'Science/Nature',
	       'Tekenfilms'	  => 'Children',
	       'Tennis / squash'  => 'Sports',
	       'Theater / dans'	  => 'Arts/Culture',
	       'Thriller'	  => 'Crime/Mystery',
	       'Tuinieren'	  => 'HowTo',
	       'Voetbal'	  => 'Sports',
	       'Watersport'	  => 'Sports',
	       'Wintersport'	  => 'Sports',
	       'Vrije tijd'	  => 'Educational' }

def pre_checks( options )
  # Check that we're not running as root.
  #
  if Process.euid == 0
    $stderr.puts 'This program should not be run as root. Aborting...'
    exit 6
  end

  # Check for correct locale. Character classes in regular expressions behave
  # differently, depending on the locale.
  #
  if ( lang = ENV['LANG'] ) != 'nl_NL'
    lang = 'unset' if lang == '' || lang.nil?
    unless options.quiet
      $stderr.puts \
	'Warning: Your locale ($LANG) is %s, but nl_NL is recommended.' %
	[ lang ]
    end
  end
end

def get_page(url, req, options)
  excepts = 0
  res = nil

  loop do
    begin
      res = Net::HTTP.start( url.host, url.port ) do |http|
	      http.request( req )
	    end

      break unless res.key?( 'location' )

      # If we get an HTTP 3xx redirect, we need to follow it.
      #
      if options.debug
	$stderr.puts '	Following HTTP %s redirection...' % [ res.code ]
      end
      
      url = URI.parse( res['location'] )
      req = Net::HTTP::Get.new( url.path )
      redo

    rescue EOFError, Errno::ECONNREFUSED, Errno::ECONNRESET,
	   Timeout::Error => e
      if ( excepts += 1 ) < options.tries
	unless options.quiet
	  $stderr.puts "  '%s' whilst fetching page. Retry #%d..." %
	    [ e, excepts ]
	end
	retry
      end

      return nil
    end
  end

  res.body
end

def get_available_channels(options)
  url = URI.parse( BASE_URL + '/Entertainment/TV_gids/Vergelijk_zenders/Favorieten/' )

  req = Net::HTTP::Get.new( url.path )
  page = get_page( url, req, options )

  if page.nil?
    unless options.quiet
      $stderr.puts 'Failed to fetch channel list from UPC. Aborting...'
    end

    exit 5
  end

  # Create an array of channel names.
  #
  # Channels are recognisable on the page, because the literal name appears
  # twice, according to the following example:
  #
  # <option value="Foo">Foo</option>
  #
  # Unfortunately, the exception to this is:
  #
  # <option value="Foo&Bar">Foo&amp;Bar</option>
  #
  # so we have to have a fuzzy match for those, too.
  #
  upc_channels = page.scan(
		   /<option value="([^"]+)">(?:\1|.*amp;.*)<\/option>/).
		     flatten.sort.uniq

  if options.verbose
    $stderr.puts \
      "UPC nominally has data for %d channels." % [ upc_channels.size ]

    if options.debug
      $stderr.puts "Those channels are:\n\n"
      upc_channels.each { |channel| $stderr.puts channel }
      $stderr.puts
    end

  end

  upc_channels
end

def create_directory(dir, options)
  if File.exist?( dir )
    return if File.directory?( dir )
    $stderr.puts '%s exists, but is not a directory.' % [ dir ]
    exit 7
  end

  unless File.exist?( dir )
    require 'fileutils'
    $stderr.puts 'Creating %s...' % [ dir ] if options.verbose
    FileUtils.mkdir_p( dir )
  end
end
 
def configure_grabber(options)
  $stderr.puts 'Using config file %s.' % [ options.config ]

  # Create config file directory if necessary.
  #
  config_dir = File.dirname( options.config )
  create_directory( config_dir, options )
 
  if File.exist?( options.config )
    unless File.file?( options.config )
      $stderr.puts '%s exists, but is not a regular file.' % [ options.config ]
      exit 7
    end

    # Deal with the case of an existing, non-zero byte config file.
    #
    unless File.zero?( options.config )
      print <<"EOF"
The file #{options.config} already exists
and is non-empty. There is currently no support for altering an existing
configuration, so you will have to reconfigure from scratch.

Do you wish to overwrite the old configuration? [yes, no (default = no)] ?
EOF

      loop do
	case answer = $stdin.gets
	when /^(y|ye|yes)$/i
	  break
	when /^(no?|\n)$/i	# 'No' is the default.
	  puts 'Configuration aborted.'
	  return
	else
	  puts "Invalid response. Please choose either 'yes' or 'no'."
	  redo
	end
      end
    end

  end
 
  opts = options.clone
  opts.verbose = false
  opts.quiet = false

  $stderr.print 'Obtaining list of channel names and numbers (may take ~3 minutes)...'
  channels = get_available_channels( opts )

  chan = {}
  channels.each do |channel|
    chan_num = get_channel_number( channel, opts )

    if chan_num
      chan[channel] = chan_num
      $stderr.print '.' if options.verbose
    else
      $stderr.print 'x' if options.verbose
    end

  end
  $stderr.puts

  # Write a new configuration file.
  #
  count = 0
  File.open( options.config, 'w' ) do |f|
    all = false

    # Work through channels in ascending channel number order.
    #
    chan.sort { |a, b| a[1].to_i <=> b[1].to_i }.each do |name, num|

      unless all
	print 'Add channel %s (%s) [yes, no, all, none (default = yes)] ? ' %
	  [ name, num ]

	case answer = $stdin.gets
	when /^(y|ye|yes|\n)$/i
	when /^no$/i
	  next
	when /^(a|al|all)$/i
	  all = true
	when /^none?$/i
	  break
	else
	  puts "Invalid response. Please choose one of 'yes', 'no', 'all' and 'none'."
	  redo
	end

      end

      f.puts 'channel %s %s' % [ num, name ]
      count += 1
    end
  end

  puts 'Finished configuration of %d channel(s).' % [ count ]
end

def check_channel(desired_channel, upc_channels)
  if ! upc_channels.include?( desired_channel )
    $stderr.puts 'Warning: UPC may not know of the channel called %s.' %
      	   [ desired_channel ]

    stub = desired_channel.sub( /[^[:alpha:]].*$/, '' )
    upc_channels.each do |channel|
      if stub.length > 0 && channel.index( stub )
	$stderr.puts 'Perhaps you mean %s.' % [ channel ]
      end
    end
  end
end

def read_config(file, verbose)
  $stderr.puts 'Parsing channel file...' if verbose

  channels = Hash.new

  file.each do |line|
    next if line =~ /^(#|$)/
    number, name = line.match( /^(?i:channel )?(\d+)\s+(.+)$/ )[1..2]

    channels[number.to_i] = name.rstrip
  end

  channels
end

def get_tvguide(channel, day, options)
  url = '/Entertainment/TV_gids/Zenders/Algemeen/Gids/?channels=%s&timescope=%s_all' % [ url_encode( channel ), day ]

  url = URI.parse( BASE_URL + url )

  if options.verbose
    $stderr.puts '  Fetching URL %s?%s ...' % [ url.path, url.query ]
  end

  req = Net::HTTP::Get.new( url.path + '?' + url.query )
  get_page( url, req, options )
end

def get_programmes(guide)
  return [] if guide.nil?

  # Return an array of [ time, title, category, description ] arrays.
  #
  guide.scan( /
	      <div\s+class="col8">
	      ([^<]+)				# Time
	      <\/div>[^<]*
	      <div\s+class="col2">.+?<\/div>[^<]*
	      <div\s+class="col7">[^<]*<a[^>]+>
	      ([^<]+)				# Title
	      <\/a>[^<]*<\/div>[^<]*
	      <div\s+class="col9">[^<]*<a[^>]+>
	      ([^<]+)				# Category
	      <\/a>[^<]*<\/div>[^<]*
	      <div\s+class="info_color">
	      ([^<]+)				# Description
	      <br\s+\/>
	      /mx )
end

def get_channel_number(channel, options)
  guide = get_tvguide( channel, 'today', options )
  ch = guide.match( /Zendernummer (\d+)/m )

  if ch
    ch[1]
  else
    if options.debug
      $stderr.puts "Can't determine a channel number for %s." % [ channel ]
    end
    nil
  end
end

def url_encode( string )
  string.gsub( /([^ a-zA-Z0-9_.-]+)/n ) do
    '%' + $1.unpack( 'H2' * $1.size ).join( '%' ).upcase
  end.tr( ' ', '+' )
end

def clean(time, title, desc, category)

  # Strip leading and trailing whitespace from the description.
  #
  desc.strip!

  # Remove any unhelpful text from the end of the description.
  #
  desc.sub!( / ?Niet beschikbaar$/, '' )

  # If the title features a colon, make the left-hand side the title and the
  # right-hand side the subtitle, except when the colon appears to be the
  # separator in a time, i.e. HH:MM. Otherwise, keep the title as is.
  #
  title, subtitle = title.split( /:\s*(?!\d)\s*/, 2 )

  unless subtitle

    # We still don't have a subtitle, so check whether the first sentence of
    # the description contains only words that begin with a capital letter.
    #
    # We also allow digits and punctuation, so that we can recognise cardinal
    # and ordinal numbers, complex sentences, names containing initials, etc.
    #
    # The desc.match pattern is a short-circuit operation that quickly enables
    # us to determine whether the description can possibly contain a usable
    # description. This saves time by not applying the complex regex unless
    # necessary. Otherwise, there's a chance the program will get stuck
    # performing exponential backtracking.
    #
    # An example of a problematic description that would cause the program to
    # get stuck is the following:
    #
    # 1300BST: US PGA Tour Golf, 1400BST: Challenge Series Golf, 1530BST: WTA
    # Tennis, 1600BST: ICC Cricket, 1630BST: ATP Tennis.
    #
    # This is the unformatted regular expression used for matching subtitles:
    #
    # /^((?:(?:[\d[:upper:]](?:(?:[[:alpha:]\d"\#$%'),\-\/:;\]\}]|(?:\xC3[\x80-\xBF]))*(?:\.? \d+)?|\.?)|[ &(*+\-<=>\[{]+))+[.!?]\s+)/
    #
    if desc.match( /[.!?]+\s+/ ) &&
       subtitle = desc.match(
      /^(
	 (?:
	    (?:
	       # Start with a single digit or capital letter...
	       #
	       [\d[:upper:]]

	       (?:
		  (?:
		     # ...followed by zero or more of:
		     #
		     # - alphanumeric characters
		     # - various punctuation characters, or...
		     #
		     [[:alpha:]\d"\#$%'),\-\/:;\]\}] |

		     # - a UTF-8 accented alpha character. See:
		     #   www.utf8-chartable.de unicode-utf8-table.pl
		     #
		     (?:\xC3[\x80-\xBF])
		  )*
		  (?:
		     # Alternatively, this may catch Ep. 27 style episode
		     # numbering...
		     #
		     \.?\s\d+

		  )? |

		  # ...and this might catch initials in names.
		  #
		  \.?
	       ) |
	       (?:
		  # If it's not a word, these are the likely word
		  # separators...
		  #
		  [\s&(*+\-<=>\[{] |

		  # or we may find some HTML entities, lower-case articles,
		  # conjunctions or prepositions.
		  #
		  &amp;|a|an|and|de|en|for|het|in|of|or|the|to|tot|van|voor
	       )+
	    )
	 )+

	 # End with one or more full-stops, exclamation marks or question
	 # marks, followed by one or more spaces.
	 #
	 [.!?]+\s+
       )
      /x )

      # Remove the subtitle from the start of the description.
      #
      desc.slice!( subtitle[1] )
      subtitle = subtitle[1].rstrip
    end

  end

  # Sometimes, the subtitle will simply duplicate the title (except, perhaps,
  # for a trailing full-stop). In this case, we abandon the subtitle.
  #
  subtitle = nil if subtitle && subtitle.chomp( '.' ) == title

  # Detect trailing episode number in the description and use this as subtitle
  # if available. If we already have a subtitle, append the episode number to
  # increase the likelihood of uniqueness.
  #
  if episode = desc.match( /( (?:deel|part|episode) (\d+)\.?)$/i )
    desc.slice!( episode[1] )
    subtitle = ( ( subtitle || '' ) + episode[1] ).lstrip

    # Remember just the episode number.
    #
    episode = episode[2].to_i
  end

  [ time, title, subtitle, episode, desc, category ]
end

# Parse options.
#
options = ProgramOptions.parse( ARGV )

# Trap ^C.
#
Signal.trap( 'INT' ) { puts 'Interrupted.' unless options.quiet; exit 255 }

# Toggle debug flag if we catch a USR1 signal. This allows us to dynamically
# enable debugging output.
#
Signal.trap( 'USR1' ) { options.debug = options.debug ? false : true }

# Toggle verbose flag if we catch a USR2 signal. This allows us to dynamically
# enable verbose output.
#
Signal.trap( 'USR2' ) { options.verbose = options.verbose ? false : true }

# Determine whether to send output to a file or stdout.
#
output = options.output ? File.new( options.output, 'w' ) : $stdout

# Perform pre-execution checks if desired.
#
pre_checks( options ) if options.sanity
 
# Create working directory if necessary.
#
create_directory( Grabber::WORKING_DIR, options )

if options.configure
  configure_grabber( options )
  exit
end

# Check for config file.
#
begin
  channel_file = File.open( options.config )
rescue Errno::ENOENT
  $stderr.puts 'Please create the config file %s.' % [ options.config ]
  exit 1
end

upc_channels = get_available_channels( options )

# Read config file.
#
channels = read_config( channel_file, options.verbose )
if channels.size == 0
  $stderr.puts 'No channels defined in %s.' % [ options.config ]
  exit 2
end

if options.days > 8
  if options.verbose
    $stderr.puts \
      'Warning: UPC carries a maximum of 8 days of data only. Adjusting...'
  end

  options.days = 8
end

if options.ratings && ! options.static_ratings
  unless options.quiet
    $stderr.puts 'Warning: Use of --ratings violates IMDB terms of use:',
		 '	   http://www.imdb.com/help/show_leaf?usedatasoftware',
		 '	   Consider using --static-ratings instead.'
  end

  Rating.load_cache( options )
end

if options.static_ratings
  Rating.get_ratings_list( options )
  options.ratings = true
end

if options.sanity && options.verbose
  channels.each_value do |name|
    check_channel( name, upc_channels )
  end
end

# Create XML document for XMLTV output.
#
doc = Document.new( '<!DOCTYPE tv SYSTEM "xmltv.dtd">' )
el_tv = doc.add_element( 'tv' )

# Data concerning TV listings source and this program.
#
el_tv.attributes['source-info-url'] = Grabber::GUIDE
el_tv.attributes['source-info-name'] = 'UPC TV Guide'
el_tv.attributes['generator-info-name'] = "#{Grabber::PROGRAM} $Id: tv_grab_nl_upc,v 1.133 2008/06/17 05:26:30 ianmacd Exp $"
el_tv.attributes['generator-info-url'] = Grabber::URL

start_day = 0
now = NOW

if options.sanity

  # Check to ensure that today's listing actually does correspond with the day 
  # on which we're running the program. Between 00:00 and 01:00, for example,
  # we may be given the listing of the previous day.

  # The channel is unimportant, so we'll just use Nederland 1.
  #
  opts = options.clone
  opts.verbose = false
  opts.quiet = false
  page1 = get_tvguide( 'Nederland 1', 'today', opts )
  page2 = get_tvguide( 'RTL 4', 'today', opts )

  if page1.nil? && page2.nil?
    unless options.quiet
      $stderr.puts 'Sample channel guide page fetch failed. Aborting...'
    end

    exit 5
  end

  if ( nr_progs = ( get_programmes( page1 ).size +
		    get_programmes( page2 ).size ) ) < 10
    $stderr.puts <<"EOF"
A sample fetch of today's data for Nederland 1 and RTL 4 returned just #{nr_progs}
programme(s). This almost certainly indicates a problem with the TV guide.
EOF
    exit 3
  end

  # Get the schedule date.
  #
  date = page1.match( /<span>(.+?dag \d+ \w+)<\/span>/ )[1]
  weekday, dom, month = date.split

  WEEKDAYS = %w[ zondag maandag dinsdag woensdag donderdag vrijdag zaterdag ]

  if ( today = NOW.wday ) != WEEKDAYS.index( weekday )

    # Weekday on which we're being run doesn't match guide day.

    if ( today - 1 ) % 7 == WEEKDAYS.index( weekday )

      # It looks like yesterday's guide is still in place. We're probably
      # being run shortly after midnight.
      #
      $stderr.puts <<"EOF" unless options.quiet
It looks like yesterday's guide is still in place. You could try running the
program later, at which time the guide will hopefully have been rotated.

EOF
      max_hour = 5 

      if now.hour >= max_hour
	$stderr.puts <<"EOF" unless options.quiet
It's now after #{"%02d" % max_hour}:00 and the guide should really have been
rotated for today. Please investigate this matter, as it may not be safe to
continue.
EOF
	exit 4

      else

	$stderr.puts <<"EOF" unless options.quiet
In the meantime, I'll make the necessary chronological adjustments and
continue. The danger here, however, is that the guide may yet be updated
whilst I'm still running. Continue at your own risk.
EOF
      end

      # Make the necessary time adjustments, so that we don't put guide data
      # for e.g. Saturday into the timetable for Sunday.
      #
      # N.B. There's a very bad race condition here, as the guide may still be
      #      rotated during execution, which would result in:
      #
      #      - some channels having no data fetched for the new day (day 0)
      #      - programme data for days 1 and higher on those same channels
      #	       would be off by -24 hours, i.e. a programme that should be
      #	       inserted on Monday afternoon would instead be inserted on
      #	       Sunday afternoon.
      #
      now -= ONE_DAY
      start_day += 1

    else

      $stderr.puts <<"EOF" unless options.quiet
The guide is not today's, but it's not yesterday's either. It's for
'#{date}'. I don't know how to deal with this situation.

Please have a look at this page to figure out what's going on:

  #{url}

to figure out what's going on.
EOF

      exit 4

    end
  end
end

# Calculate midnight today, adjusting for offset from UTC.
#
midnight_today = now - ( ( now + now.utc_offset ).to_i % ONE_DAY )

# Set up channels.
#
channels.each_key do |channum|

  # Add channel.
  #
  el_chan = el_tv.add_element( 'channel' )

  # Add XMLTV ID.
  #
  el_chan.attributes['id'] = channum.to_s + options.xmltvid_suffix

  # Add channel name.
  #
  el_display_name = el_chan.add_element( 'display-name' )
  el_display_name.attributes['lang'] = 'nl'
  el_display_name.text = channels[channum]

  # el_icon = el_chan.add_element( 'icon' )
end

# Remember which channels have no programming data on certain days.
#
missing = Array.new( options.days ) { Array.new }

# Create an array containing the English days of the week, starting with today.
#
DAYS_OF_WEEK = Array.new( 7 ) do |day|
  ( NOW + ONE_DAY * day ).strftime( '%A' ).downcase
end

categories = Hash.new { |hash, key| hash[key] = [] }
programme_total = 0
rating_total = 0
fetches = 0

# Iterate over all channels.
#
data_fetcher = Proc.new do |channum|
  ch_prog_total = 0
  ch_rating_total = 0

  if options.verbose
    $stderr.puts 'Fetching data for %s (%d)...' %
      [ channels[channum], channum ]
  end

  first_fetch = true

  # Iterate over days, starting at today + any offset, and go the required
  # number of days + any offset.
  #
  ( start_day + options.offset ).
    upto( start_day + options.days - 1 + options.offset ) do |day|

    if options.verbose
      $stderr.puts '  Fetching day %d for %s...' %
	[ day, channels[channum] ]
    end

    # Get the channel theme.
    #
    # theme = upc_channels[channels[channum]] || 'Algemeen'

    # Theme is currently unreliable, but apparently any theme will
    # work for any channel, as long as it's a valid theme, so always
    # use 'Algemeen'.
    #
    theme = 'Algemeen'

    # Figure out which string we need for the day.
    #
    timescope = case day
		  when 0 then 'today'
       	 	  when 1 then 'tomorrow'
       	 	  else DAYS_OF_WEEK[day % 7]
       	 	end

    page = get_tvguide( channels[channum], timescope, options )

    if page.nil?
      $stderr.puts '  Failed to fetch day %d.' % [ day ] unless options.quiet
    end

    # If this is the first page fetch for this channel and --icons or --logos
    # was given, insert a link to the channel's icon.
    #
    if ! page.nil? && options.icons && first_fetch
      begin
	icon_path =
	  page.match( /<img.+?alt="#{channels[channum]}".+?src="([^"]+)"/ )[1]

	el_tv.elements["channel[@id='#{channum}#{options.xmltvid_suffix}']"].
  	add_element( 'icon' )
	el_tv.elements["channel[@id='#{channum}#{options.xmltvid_suffix}']/icon"].
  	attributes['src'] = BASE_URL + icon_path

      # A failed match will result in an attempt to call NilClass#[], which
      # doesn't exist.
      #
      rescue NoMethodError
	unless options.quiet
	  $stderr.puts '    Failed to determine an icon path.'
	end
      end

      first_fetch = false
    end

    #############################################################
    #    Screen-scraping sucks. I'd rather have an XML feed.    #
    #############################################################

    # Create an array of all programmes.
    #
    programmes = get_programmes( page )

    if options.verbose
      $stderr.puts '    Found %d programme(s) for day %d on %s.' %
	[ programmes.size, day, channels[channum] ]
    end

    ch_prog_total += programmes.size
    fetches += 1
    day_rating_total = 0

    # Remember this channel if it has no programme data for today.
    #
    if programmes.size == 0

      # Record this as a failure.
      #
      missing[day + start_day - options.offset] << channum.to_i
    end

    after_midnight = nil

    # Calculate midnight on day that has just been fetched.
    # 
    midnight_on_day = midnight_today + day * ONE_DAY

    # Iterate over all programmes.
    #
    programmes.each do |programme|

      time, title, category, desc = programme

      # Get the start and stop times.
      #
      start, stop = time.scan( /\d+:\d+/ )
      start_hours, start_mins = start.split( /:/ )
      stop_hours, stop_mins = stop.split( /:/ )

      # Remove junk from fields.
      #
      time, title, subtitle, episode, desc, category =
	clean( time, title, desc, category )

      # Each page contains programmes that start in the early hours of the
      # morning. However, those at the top of the page start after midnight
      # today, whereas those at the bottom start after midnight tonight and
      # therefore technically belong to tomorrow's programmming.
      #
      after_midnight ||= false if start_hours.to_i > 9
      after_midnight = true if start_hours.to_i < 10 && after_midnight == false

      # Prepare XMLTV ID of the form channum + suffix.
      #
      el_prog = el_tv.add_element( 'programme' )
      el_prog.attributes['channel'] = channum.to_s + options.xmltvid_suffix

      # Calculate programme start and stop times in UNIX time.
      #
      start_time =
	midnight_on_day + start_hours.to_i * 3600 + start_mins.to_i * 60
      stop_time =
	midnight_on_day + stop_hours.to_i * 3600 + stop_mins.to_i * 60

      # Add a day if this programme starts and ends after midnight.
      #
      if after_midnight
	start_time += ONE_DAY
	stop_time += ONE_DAY
      end

      # If the hour of the stop time is less then the hour of the start time,
      # the programme finishes after midnight and needs a day added to the
      # stop time. The same applies if the programme runs from midnight to
      # midnight, which usually denotes a 24 hour programme, like, for
      # example, the continuous data display of the Weerkanaal.
      #
      if start_hours.to_i > stop_hours.to_i ||
	    ( start_hours.to_i == stop_hours.to_i && start == '00:00' )
	stop_time += ONE_DAY
      end

      # Format start and stop time.
      #
      el_prog.attributes['start'] = start_time.strftime( '%Y%m%d%H%M%S %z' )
      el_prog.attributes['stop'] = stop_time.strftime( '%Y%m%d%H%M%S %z' )

      # Add title.
      #
      el_title = el_prog.add_element( 'title' )
      el_title.attributes['lang'] = 'nl'

      # Fix encoding for Ruby 1.9.
      #
      title.force_encoding( 'UTF-8' ) if String.method_defined? :encode

      # Don't convert apostrophes etc. in the title to entities on output.
      #
      el_title.text = Text.new( title, false, nil, true )

      # Add subtitle, if we've derived one.
      #
      if subtitle
	el_subtitle = el_prog.add_element( 'sub-title' )
	el_subtitle.attributes['lang'] = 'nl'

	# Fix encoding for Ruby 1.9.
	#
	subtitle.force_encoding( 'UTF-8' ) if String.method_defined? :encode

	# Don't convert apostrophes etc. in the subtitle to entities on output.
	#
	el_subtitle.text = Text.new( subtitle, false, nil, true )
      end

      # Add episode number, if we've found one.
      #
      if episode
	el_episode = el_prog.add_element( 'episode-num' )
	el_episode.attributes['system'] = 'xmltv_ns'
	el_episode.text = '.%d.' % [ episode - 1 ]
      end

      # Add description, if there is one.
      #
      unless desc == ''
	el_desc = el_prog.add_element( 'desc' )
	el_desc.attributes['lang'] = 'nl'

	# Fix encoding for Ruby 1.9.
	#
	desc.force_encoding( 'UTF-8' ) if String.method_defined? :encode

	# Don't convert apostrophes etc. in the desc. to entities on output.
	#
	el_desc.text = Text.new( desc, false, nil, true )
      end

      # Can we figure out whether there's a presenter?
      #
      # We isolate from 'Presented by ' to the first full-stop.
      #
      # The 'pres != desc' check is required in order to know whether
      # substitution actually occurred.
      #
      if ( pres = desc.sub( /^.*(?:(?:Presented|Hosted) by|Gepresenteerd door) (.+?)\..*$/i, "\\1" ) ) && pres != desc

	# Grab each string of consecutive words that start with a capital
	# letter. That should give us an array of names, each of which
	# possibly has a trailing space.
	#
	pres =
	  pres.scan( /((?:[[:upper:]](?:'[[:upper:]])?[[:lower:]]+ ?)+)/ ).
	    flatten

	el_credits = el_prog.add_element( 'credits' )

	pres.each do |presenter|
	  el_pres = el_credits.add_element( 'presenter' )

	  # Don't convert apostrophes etc. in the presenter's name to entities
	  # on output.
	  #
	  el_pres.text = Text.new( presenter.rstrip, false, nil, true )
	end
      end

      if options.cattrans

	# Add translated category, if we recognise it.
	#
	if CATEGORIES.key?( category )
	  el_category = el_prog.add_element( 'category' )
	  el_category.attributes['lang'] = 'en'
	  el_category.text = CATEGORIES[category]
	else
	  categories[category] << [ channum, el_prog.attributes['start'],
				    el_prog.attributes['stop'], title ]
	end

      else
	# Add untranslated category.
	#
	el_category = el_prog.add_element( 'category' )
	el_category.attributes['lang'] = 'nl'
	el_category.text = category
      end

      if options.ratings

	# UPC give us almost no way to determine that a programme is a movie.
	# We know that programmes with a genre of 'Speelfilm' are films, but
	# we'll also assume that programmes on channels whose name starts with
	# the word 'Film' are films. This catches, for example, the Film1 set
	# of channels: http://www.film1.nl/
	#
	# We further assume that any programme that lasts between 80 minutes
	# and 4 hours, and is of a credible genre, is also a film. We may not
	# always be right, but even when we're wrong, the negative effect is
	# negligible, as we'll mostly just fail to find a rating for the title.
	#
	duration = ( stop_time - start_time ) / 60

	if category == 'Speelfilm' || channels[channum] =~ /^Film/ ||
	   ( duration >= 80 && duration <= 240 &&
	       category =~ /(?:Actie|Avontuur|Detective|Drama|Komedie|
			     Romantiek|Sci-fi|Tekenfilms|Thriller)$/x )
	  if star_rating = Rating.imdb_rating( title, options )
	    el_star_rating = el_prog.add_element( 'star-rating' )
	    el_star_value = el_star_rating.add_element( 'value' )
	    el_star_value.text = star_rating
	    day_rating_total += 1
	  end
	end
      end

    end

    ch_rating_total += day_rating_total

    if options.verbose
      if options.ratings
	$stderr.puts '    Rated %d film(s).' % [ day_rating_total ]
      end

      $stderr.puts "    Sleeping %d second(s)...\n\n" % [ options.sleep ]
    end

    # Be nice (or not) to the data source.
    #
    sleep options.sleep

  end

  if options.verbose
    $stderr.puts '  Found a total of %d programme(s) for %s (%d).' %
      [ ch_prog_total, channels[channum], channum ]
    if options.ratings
      $stderr.puts '  %d film(s) rated via IMDB.' % [ ch_rating_total ]
    end

    $stderr.puts
  end

  programme_total += ch_prog_total
  rating_total += ch_rating_total
end

threads = []
channels.keys.sort.each do |ch|
  if options.threads
    threads << Thread.new( ch ) { |chan| data_fetcher.call( chan ) }
  else
    data_fetcher.call( ch )
  end
end
threads.each { |thread| thread.join } if options.threads

# Write out UTF-8 XML.
#
doc.write( output, -1 )

if options.ratings && ! options.static_ratings
  Rating.dump_cache( options )
end

# Report on data processed.
#
if options.verbose
  elapsed = Time.now - NOW
  $stderr.puts 'Found a total of %d programme(s) on %d channel(s).' %
    [ programme_total, channels.size ]
  $stderr.puts '%d guide page(s) were fetched in total.' % [ fetches ]

  if options.ratings
    attempted = rating_total + Rating.not_rated + Rating.cache_negatives
    failed = attempted - rating_total
    $stderr.puts 'Attempted to rate %d film(s) via IMDB.' % [ attempted ]

    mode = options.static_ratings ? 'static' : 'dynamic'
    $stderr.puts '%d (%d%%) film(s) rated, of which %d (%d%%) %s and %d (%d%%) cached.' %
      [ rating_total,
	attempted.zero? ?
	  0 : ( ( rating_total.to_f / attempted ) * 100 ).round,
	Rating.rated,
	r = rating_total.zero? ?
	  0 : ( ( Rating.rated.to_f / rating_total ) * 100 ).round,
	mode,
	Rating.cache_positives,
	100 - r ]
    
    $stderr.puts '%d (%d%%) film(s) not rated, of which %d (%d%%) %s and %d (%d%%) cached.' %
      [ failed,
	attempted.zero? ? 0 : ( ( failed.to_f / attempted ) * 100 ).round,
	Rating.not_rated,
	nr = failed.zero? ?
	  0 : ( ( Rating.not_rated.to_f / failed ) * 100 ).round,
	mode,
	Rating.cache_negatives,
	100 - nr ]
  end

  elapsed = elapsed.to_i
  $stderr.printf %Q(The total running time was %02d' %02d" ) %
    [ elapsed / 60, elapsed % 60 ]
  $stderr.puts '(%d pages(s) / %d programme(s) per second).' %
    [ fetches / elapsed, programme_total / elapsed ]
end

# Produce missing programme data report.
#
if options.verbose && ! missing.flatten.empty?
  $stderr.puts 'Missing programme data report:'

  # Report which days had no data for certain channels.
  #
  index = start_day + options.offset - 1
  missing.each do |day|
    day.sort!
    index += 1
    next if day.empty?
    $stderr.puts "\nChannels on day %d:" % [ index ]
    names = channels.values_at( *day )
    day.zip( names ).each { |num, name| $stderr.puts '%5d %s' % [ num, name ] }
  end
  $stderr.puts

  # Report which channels had no data on any day.
  #
  missing.flatten.uniq.each do |channum|
    no_data = true
    ( start_day + options.offset ).
      upto( start_day + options.days - 1 + options.offset ) do |day|
      if ! missing[day - options.offset - 1].include?( channum )
	no_data = false
	break
      end
    end

    if no_data
      $stderr.puts 'Channel %3d (%s) has no data for any day!' %
	[ channum, channels[channum] ]
    end
  end
  $stderr.puts

end

# Produce unknown category report.
#
if options.debug && ! categories.empty?
  $stderr.puts \
    "The following unrecognised programme categories were found:\n\n"
  categories.each do |category, progs|
    $stderr.puts '%s:' % [ category ]
    progs.each do |chan, start, stop, title|
      $stderr.puts '%3d %s - %s : %s' % [ chan, start, stop, title ]
    end
    $stderr.puts
  end
end