#!/usr/bin/perl

######################################################################
# Script Prerequisites
######################################################################
# Perl modules:
#   LWP::UserAgent;
#   Cwd
#   POSIX
#   Data::ICal::TimeZone (optional)
#
# Command Line:
#   rsync
#   lynx
#   wdiff
######################################################################

$id_mirror = '/Users/adam/Documents/IETF/internet-drafts/';

# See http://search.cpan.org/~rclamp/Data-ICal-TimeZone-1.23/
$timezone = "Europe/Paris";
$tzdef = mkicaltz($timezone);

if (!defined($tzdef))
{
  warn "Could not find timezone $timezone -- do you have Data::ICal::TimeZone installed?\n";
}

#$verbose = 1;

######################################################################
# Working groups of interest, listed in priority order
######################################################################
@groups = (
  'xcon',
  'sip',
  'simple',
  'sipping',
#  'behave',
  'p2psip',
  'speermint',
  'mmusic',
  'ecrit',
  'bliss',
  'geopriv',
  'drinks',
  'sipcore',
  'dispatch',
  'sipclf',
  'e2m',
  'martini',

  'rucus',
  'biff',
  'safe',
  'peppermint',
  'alto',
  'codec',

  'iri',
  'xmpp',
  'grobj',

  'core',
  'ppsp',
);

@areas = ( 'RAI' );

#####
# transform these arrays into hashes
%include_group = map {$_ => 1} @groups;
%include_area = map {$_ => 1} @areas;

######################################################################
# Constants
######################################################################
%month =
(
  'January' => '01',
  'February' => '02',
  'March' => '03',
  'April' => '04',
  'May' => '05',
  'June' => '06',
  'July' => '07',
  'August' => '08',
  'September' => '09',
  'October' => '10',
  'November' => '11',
  'December' => '12'
);


######################################################################
# HTTP User Agent Initialization
######################################################################
use LWP::UserAgent;

$ua = LWP::UserAgent->new;
$ua->agent("AgendaBuilder/0.2");


######################################################################
# ICAL Setup
######################################################################
$myname = (getpwuid($<))[0];
($currsec,$currmin,$currhour,
 $currmday,$currmon,$curryear) = gmtime(time);

$curryear += 1900;
$currmon += 1;
$currDateTime = sprintf("%4.4d%2.2d%2.2dT%2.2d%2.2d%2.2dZ",
                        $curryear,$currmon,$currmday,
                        $currhour,$currmin,$currsec);

$ics = "BEGIN:VCALENDAR\nVERSION\n :2.0\nMETHOD\n :PUBLISH\n";
if (defined($tzdef))
{
  $ics .= $tzdef;
}
######################################################################

######################################################################
# Little bit of sanity checking
######################################################################

if ($id_mirror !~ /\/$/) { $id_mirror .= "/"; }

######################################################################
# Update drafts
######################################################################

if (defined($id_mirror) && -e $id_mirror)
{
  system ("rsync", '-avz', '--exclude', 'tar', 
          'ftp.rfc-editor.org::ids-text-only', $id_mirror);
}

######################################################################

use Cwd;
$number = shift;
if ($number < 1)
{
  $number = getcwd;
  $number =~ /([0-9]{2})$/ || die "Cannot determine IETF number";
  $number = $1;
}

print "Updating local information for IETF $number\n";
######################################################################
# Retrieve, parse, and prune the current agenda
######################################################################
#$lwp_request = HTTP::Request->new(GET => "http://datatracker.ietf.org/meeting/${number}/agenda.txt");
#$lwp_result = $ua->request($lwp_request);
#$txt_agenda = $lwp_result->content;

$lwp_request = HTTP::Request->new(GET => "http://datatracker.ietf.org/meeting/${number}/agenda.csv");
$lwp_result = $ua->request($lwp_request);
$csv_agenda = $lwp_result->content;

if (length ($csv_agenda) < 1000)
{
  die "Could not retrieve agenda.";
}

@agenda = split ("\n",$csv_agenda);
shift @agenda;

use POSIX;
foreach $line (@agenda)
{
  $line =~ s/^"//;
  $line =~ s/"$//;
  ($date, $start, $end, $session, $room, $area, $wg, $type, $desc, $tid, $agenda, $slides) = split ('","',$line);
  ($year,$month,$day) = split ('-',$date);
  $time = POSIX::mktime(0,0,0,$day,$month-1,$year-1900);
  $datestring = POSIX::strftime("%A, %B %e, %Y", gmtime($time));

  if ($date ne $prev_date)
  {
    $prev_date = $date;
    $text_agenda .= "\n$datestring\n==============================================================================\n";
    $html_agenda .= "</table>\n<hr><h1>$datestring</h1>\n<table width=\"100%\">\n";
  }
  $slides{$wg} = $slides;
  $agenda{$wg} = $agenda;
  if ($type =~ /bof/i){
    push (@bofs, "$area - $wg - $desc");
  }
  if ($wg =~ /plenary/i)
  {
    &addEvent($month, $day, $year, $start, $end, $desc, $room); # Plenaries
  }
  elsif ($desc =~ /break/i)
  {
    &addEvent($month, $day, $year, $start, $end, $desc); # Breaks
  }
  elsif ($include_group{$wg} || $include_area{$area})
  {
    $meeting{$wg}++;
    &addEvent($month, $day, $year, $start, $end, $wg, $room, $desc); # wg meetings
    if ($agenda{$wg})
    {
      $html_agenda .= "<tr><td colspan=\"3\"></td>".
                      "<td colspan=\"2\">".
                      "<iframe width=\"100%\" height=\"8\" src=\"groups/$wg.html\" ".
                      "onload=\"r(this)\">".
                      "</iframe></td></tr>\n";
    }
    else
    {
      $html_agenda .= "<tr><td colspan=\"3\"></td>".
                      "<td colspan=\"2\">".
                      "<font color='red'><b>$wg has not yet uploaded an agenda</b></font></td></tr>\n";
    }
  }
}

######################################################################
# Write out the agenda file
######################################################################
open (AGENDA, ">agenda_${number}.txt");
print AGENDA $text_agenda;
close (AGENDA);

######################################################################
# Write out the HTML agenda file
######################################################################
open (AGENDA, ">agenda_${number}.html");
print AGENDA "<html><head><title>IETF $number Agenda</title>".
             "<script type=\"text/javascript\"> /* Resizes an IFRAME".
             "to fit its contents */ function r(obj) { try { docHeig".
             "ht = obj.contentWindow.document.body.scrollHeight; obj".
             ".height = docHeight; } catch (e) {} }</script>".
             "</head><body><table>\n".$html_agenda.
             "</table></body></html>\n";
close (AGENDA);


######################################################################
# Retrieve the sub-agendas
######################################################################
mkdir ("groups");
chdir("groups") || die $!;

foreach $wg (sort keys %meeting)
{
  if (!$agenda{$wg})
  {
    print "\x1B[31;3mWarning: $wg has no agenda uploaded\x1B[0m\n";
    next;
  }
  print "Getting agenda for $wg ($agenda{$wg})...\n";
  unlink ("${wg}.htm");
  unlink ("${wg}.html");
  unlink ("${wg}.txt");

  # $subdir = $number;
  # $subdir = $meetingCode;
  #foreach $subdir ($number, $meetingCode)
  #{
  #  &wget("http://www.ietf.org/proceedings/${subdir}/agenda/${wg}.txt", "${wg}.txt");
  #  &wget("http://www.ietf.org/proceedings/${subdir}/agenda/${wg}.htm", "${wg}.htm");
  #  &wget("http://www.ietf.org/proceedings/${subdir}/agenda/${wg}.html", "${wg}.html");
  #}

  $agenda{$wg} =~ /([^\/]*)$/;
  #$output = $1;
  $output = "$wg";
  &wget($agenda{$wg},$output);

  if (-z "${wg}.htm") { unlink ("${wg}.htm"); }
  if (-z "${wg}.html") { unlink ("${wg}.html"); }
  if (-e "${wg}.htm") { rename ("${wg}.htm", "${wg}.html"); }
  
  if (-e "${wg}.html" && !-e"${wg}.txt")
  {
    system ("lynx --nolist --dump '${wg}.html' > '${wg}.txt'");
  }

  if (!-e "${wg}.html" && !-e"${wg}.txt")
  {
    &cp ("../provisional/$wg.txt", ".");
    &cp ("../provisional/$wg.html", ".");
  }
}
chdir("..") || die $!;


######################################################################
# Substitue agendas for description fields, where possible
######################################################################
foreach $wg_agenda (<groups/*.txt>)
{
  $wg = $wg_agenda;
  $wg =~ s/.*\///;
  $wg =~ s/\.txt//;
  $description = $desc{$wg};

  open (AGENDA, $wg_agenda);
  $agenda = join('',<AGENDA>);
  close (AGENDA);

  $agenda =~ s/\\/\\\\/g;
  $agenda =~ s/;/\\;/g;
  $agenda =~ s/,/\\,/g;
  $agenda =~ s/\n/\\n/g;
  $agenda =~ s/\r//g;

  $ics =~ s/ :$description *[\r\n]/ :$agenda\n/g;
}

######################################################################
# Wrap up and write out the ical file
######################################################################
$ics .= "END:VCALENDAR\n";

while ($ics =~ s/([\r\n])([^\r\n]{74})([^\r\n])/$1$2\n $3/gs){;}

$icalfile = "ietf_${number}.ics";
open (ICS, ">", $icalfile);
print ICS $ics;
close (ICS);

######################################################################
# Copy the drafts
######################################################################
foreach $wg_agenda (<groups/*.txt>,<groups/*.html>)
{
  open (AGENDA, $wg_agenda);
  $wg = $wg_agenda;
  $wg =~ s/\.txt//g;
  $wg =~ s/\.html//g;
  print "\n$wg\n".('-' x length($wg))."\n";
  @drafts = (join('',<AGENDA>) =~ /(draft-[-a-z0-9]*)/g);
  close (AGENDA);

  # Make the list of drafts unique
  undef %tmp;
  foreach $draft (@drafts)
  {
    $draft =~ s/-*$//;
    $tmp{$draft}++;
  }
  @drafts = sort keys %tmp;

  mkdir($wg);

  foreach $draft (@drafts)
  {
    # If there's not a number, count down from 99 until we find the right one
    if (defined($id_mirror) && (-e $id_mirror) && ($draft !~ /-[0-9]$/))
    {
      for ($i = 99; $i >= 0; $i--)
      {
        $fname = sprintf("${id_mirror}${draft}-%2.2d.txt", $i) ;
        if (-e $fname) 
        {
          $fixedname{$draft} = sprintf("${draft}-%2.2d", $i) ;
          $draft = $fixedname{$draft};
          last;
        }
      }
    }

    $d = $draft;

    if ($fixedname{$draft})
    {
      $d = $fixedname{$draft};
    }

    print "  ${d}.txt\n";

    if (-e $id_mirror.$d.".txt")
    {
      &cp ($id_mirror.$d.".txt", $wg);
      $source{"$wg/${d}.txt"} = $id_mirror.$d.".txt";
    }
    else
    {
      if ($verbose) { print "Getting ${d}.txt into $wg\n"; }
      &wget("http://tools.ietf.org/id/${d}.txt","$wg/${d}.txt");
      $source{"$wg/${d}.txt"} = "$wg/${d}.txt";
    }

  }
}
print "\n";

######################################################################
# Find and create diffs (from previous meeting, if available; from
# previous version if not discussed at previous meeting)
######################################################################
foreach $draft (sort keys %source)
{
  $source{$draft} =~ /([0-9]{2})\.txt$/;
  $num = $1;

  undef($old);

  $lastMeeting = getcwd;
  $lastNumber = $number-1;
  $lastMeeting =~ s/$number/$lastNumber/;
  $lastMeeting .= "/$draft";
  $lastMeeting =~ s/[0-9]{2}\.txt/??.txt/;
  $lastMeeting =~ s/draft-ietf-/draft-*-/;
  ($oldDraft) = glob($lastMeeting);

  if (-e $oldDraft)
  {
    $old = $oldDraft;
  }
  elsif ($num ne '00')
  {
    $prev = $num - 1;
    $prev = sprintf("%2.2d",$prev);
    $old = $source{$draft};
    $old =~ s/$num\.txt$/$prev\.txt/;

    if (! -e $old)
    {
      $old_draft_name = $draft;
      $old_draft_name =~ s/.*\/([^\/]*)$/$1/g;
      $old_draft_name =~ s/$num\.txt$/$prev\.txt/;
      if ($verbose) { print "Getting old draft $old_draft_name\n"; }
      &wget("http://tools.ietf.org/id/${old_draft_name}",$old);
    }
  }

  if (defined($old) && -e $old)
  {
    $diff = &htmlwdiff($old, $source{$draft});
    $output = "${draft}-diff.html";
    print "Writing $output...\n";
    open (DIFF, ">$output");
    print DIFF $diff;
    close DIFF;
  }
  else
  {
    if ($verbose)
    {
      print "Can't diff $draft...\n";
    }
  }

}

######################################################################
# Relink any pre-existing HTML agendas
######################################################################
foreach $agenda (<groups/*.html>)
{
  ($group) = ($agenda =~ /([^\/]*)\.html$/);
  
  open (IN, $agenda);
  $body = join('',<IN>);
  close IN;

  $out = $agenda;

  $body =~ s/<a[^>]*href *= *['"]http[^'"]*['"][^>]*>(.*?)<\/a>/$1/gis;
  $body =~ s/(draft-[-a-z0-9]*[a-z0-9])/&linkdraft($group,$1)/ge;

  open (OUT, ">$out");
  print OUT $body;
  close (OUT);
}

######################################################################
# HTML-ize any text sub-agendas
######################################################################
foreach $agenda (<groups/*.txt>)
{
  $out = $agenda;
  $out =~ s/(.*)\/([^\/]*)\.txt/$1\/$2.html/g;
  $group = $2;

  if (-e $out) { next; }

  open (IN, $agenda);
#  open (IN, "fmt $agenda|");
  $body = join('',<IN>);
  close IN;

  $body =~ s/\&/&amp;/g; 
  $body =~ s/</&lt;/g;
  $body =~ s/>/&gt;/g;

  $body =~ s/\r?\n\r?( *)/'<BR>'.&nbsp($1)/eg;
  # This is in case the ECRIT chairs' text editor goes bonkers.
  $body =~ s/\r( *)/'<BR>'.&nbsp($1)/eg;
  $body =~ s/\t/&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;/g;

  $body =~ s/(draft-[-a-z0-9]*[a-z0-9])/&linkdraft($group,$1)/ge;

  open (OUT, ">$out");
  print OUT "<HTML><HEAD><TITLE>$group agenda</TITLE></HEAD><BODY><TT>\n".
             $body.
             "\n</TT></BODY></HTML>\n";
  close (OUT);
}


######################################################################
# Merge all agenda files into one file for printing
######################################################################
open (IN, "agenda_${number}.html");
$agenda = join '', <IN>;
close (IN);
$agenda =~ s/<iframe[^>]*src="([^"]*)"[^>]*><\/iframe>/&import($1)/goem;
open (OUT, ">agenda_${number}_printable.html");
print OUT $agenda;
close (OUT);

sub import
{
  open (IFRAME, shift);
  my ($body) = join '', <IFRAME>;
  close (IFRAME);
  $body =~ s/<\/?(html|body)>//goim;
  $body =~ s/<head>.*<\/head>//gois;
  return "<table border='1' style='border-color:black;border-width:3px;border-style:solid'><tr><td style='border-style:none'>".$body."</td></tr></table>\n";
}


######################################################################
sub nbsp { my($x) = shift; $x =~ s/./&nbsp;/g; $x}

######################################################################
# Update web page
######################################################################
#system("scp $icalfile www.nostrum.com:.public_html");

######################################################################
# List the BOFs
######################################################################
if (@bofs)
{
  print "\nBOF sessions for IETF ${number}:\n";
  foreach $bof (sort @bofs)
  {
    print "  * $bof\n";
  }
}

######################################################################
# Subroutine to turn draft names into HTML links
######################################################################

sub linkdraft
{
  my ($group, $draft) = @_;
  my ($link) = $draft;
  my ($pages);

  $display_name = $draft;
  if ($fixedname{$draft}) { $draft = $fixedname{$draft}; }

  if (-e "groups/$group/$draft.txt")
  {
    $link = "<a target=\"$draft\" href=\"$group\/$draft.txt\">$display_name<\/a>";
    $link .= " [".int(((stat("groups/$group/$draft.txt"))[7]) / 1024)."k";
    $pages = &count_pages("groups/$group/$draft.txt");
    if ($pages) { $link .= ", ${pages}p"; }
    $link .= "]";
    if (-e "groups/$group/$draft.txt-diff.html") 
    {
      $link .=" (<a target=\"$draft\" href=\"$group\/$draft.txt-diff.html\">diff<\/a>)";
    }
  }
  else
  {
    $link = "<font color=\"#ff0000\">$draft<\/font>";
  }
  $link;
}


######################################################################
# Subroutine to get number of pages in an i-d or RFC
######################################################################
sub count_pages
{
  my ($file) = shift;
  my ($tail);
  my ($page);
  open (FILE, $file) || return 0;
  seek (FILE, -100, 2);
  read (FILE, $tail, 100);
  close FILE;
  ($page) = ($tail =~ /page ([0-9]+)/i);
  return $page;
}

######################################################################
# Subroutine to get the contents of a URL into a file
######################################################################
sub wget
{
  my (%mime) =
  (
    "text/plain" => "txt",
    "text/html" => "html",
  );
  my ($url, $output) = @_;

  my ($lwp_request) = HTTP::Request->new(GET => $url);
  my ($lwp_result) = $ua->request($lwp_request);
  my ($agenda) = $lwp_result->content;
  my ($type) = $lwp_result->header("Content-Type");
  $type =~ s/[ ;,].*//g;

  if ($output !~ /\./ && $mime{$type})
  {
    $output .= ".".$mime{$type};
  }

  #print "Saving $url ($type) in $output\n";

  if($lwp_result->is_success)
  {
    open (WGET_OUT, ">$output");
    print WGET_OUT $agenda;
    close (WGET_OUT);
  }
  else
  {
    print "\x1B[31;3mWarning: Could not retreive $url\x1B[0m\n";
  }
  return ($lwp_result->is_success);
}

######################################################################
# Subroutine to copy a file
######################################################################
sub cp
{
  my ($source, $dest) = @_;
  my ($basename);
  my ($bytes_read);

  if (-d $dest)
  {
    $source =~ /([^\/]*)$/;
    $basename = $1;
    $dest .= "/".$basename;
  }

  if ($verbose)
  {
    $| = 1;
    print "  - Copying $source to $dest";
  }

  open (CP_IN, $source) || (warn "Cannot copy from $source", return 1);
  open (CP_OUT, ">$dest") || (warn "Cannot copy to $dest", return 1);

  while (sysread(CP_IN, $buffer, 8192))
  {
    syswrite(CP_OUT, $buffer);
    if ($verbose) {print ".";}
  }

  if ($verbose) {print "\n";}

  close (CP_OUT);
  close (CP_IN);
  0;
}


######################################################################
sub addEvent
{
  my ($month, $day, $year, $start, $end, $event, $location, $description) = @_;

   my ($htmlevent) = $event;
   
   $htmlevent =~ y/A-Z/a-z/;
   if ($meeting{$htmlevent})
   {
     my ($link) = 'http://www.ietf.org/html.charters/'.$htmlevent.'-charter.html';
     $htmlevent = "<a href=\"$link\">$event</a>";
   }
   else
   {
     $htmlevent = $event;
   }

   if ($description)
   {
     $htmlevent .= " &#8212; <i>$description</i>";
  }

  $serialNumber++;
  my ($textid) = "$month$day$year$start$end";
  if ($added{$textid})
  {
     $text_agenda .= sprintf ("          %s",$event);
     $html_agenda .= "<tr><td colspan=\"3\"></td><td>$htmlevent";
  }
  else
  {
     $text_agenda .= sprintf ("%-4.4s-%-4.4s %s",$start,$end,$event);
     $html_agenda .= "<tr><td>$start</td><td>-</td><td>$end</td><td width=\"100%\">$htmlevent";
     $added{$textid}++;
  }

  if ($location)
  {
    $text_agenda .= " ($location)";
    my ($tmp) = $location;
    $tmp =~ s/ /&nbsp;/g;
    $html_agenda .= "</td><td>$tmp";
  }
  else
  {
    $html_agenda .= "</td><td>";
  }

  if ($description)
  {
    $text_agenda .= " - $description";
  }

  $text_agenda .= "\n";
  $html_agenda .= "</td></tr>\n";

  $ics .= "BEGIN:VEVENT\n";
  $ics .= "UID\n :ietf-${myname}-${month}-${year}-${serialNumber}\n";
  $ics .= "SUMMARY\n :$event\n";
  if (length($location))
  {
    $ics .= "LOCATION\n :$location\n";
  }
  if (length($description))
  {
    $ics .= "DESCRIPTION\n :$description\n";
  }
  $ics .= "STATUS\n :TENTATIVE\n";
  $ics .= "CLASS\n :PUBLIC\n";

  $ics .= "DTSTART\n ";
  if (defined($timezone) && defined($tzdef))
  {
    $ics .= ";TZID=${timezone}";
  }
  $ics .= ":${year}${month}${day}T${start}00\n";

  $ics .= "DTEND\n ";
  if (defined($timezone) && defined($tzdef))
  {
    $ics .= ";TZID=${timezone}";
  }
  $ics .= ":${year}${month}${day}T${end}00\n";

  $ics .= "DTSTAMP\n :$currDateTime\n";
  $ics .= "END:VEVENT\n";
}


######################################################################
# Adaptation of Henrik's gawk script to strip internet-draft cruft
######################################################################
sub strip
{
  my ($input, $output) = @_;

  my ($newpage, $sentence, $haveblank, $outline);

  open (STRIP_INPUT, $input);
  open (STRIP_OUTPUT, '>'.$output);

  while (<STRIP_INPUT>)
  {
    s/[\r\n]//g;
    s/[ \t]+$//g;

    if (/\[?[Pp]age [0-9ivx]+\]?[ \t]*$/) { next; }

    if (/^[ \t]*\f/)                    { $newpage=1; next; }
    if (/^ *Internet.Draft.+[0-9]+ *$/) { $newpage=1; next; }
    if (/^ *INTERNET.DRAFT.+[0-9]+ *$/) { $newpage=1; next; }
    if (/^RFC.+[0-9]+$/)                { $newpage=1; next; }
    if (/^draft-[-a-z0-9_.]+.*[0-9][0-9][0-9][0-9]$/) { $newpage=1; next; }

    if (/^[^ \t]/) { $sentence=1; }

    if (/[^ \t]/) {
      if ($newpage) {
        if ($sentence) {
          $outline++;
          print STRIP_OUTPUT "\n"; 
        }
      } else {
        if ($haveblank) {
          $outline++;
          print STRIP_OUTPUT "\n"; 
        }
      }
      $haveblank=0;
      $sentence=0;
      $newpage=0;
    }

    if (/[.:][ \t]*$/) { $sentence=1; }
    if (/^[ \t]*$/) { $haveblank=1; next; }

    $outline++; 
    s/\&/&amp;/g;
    s/\</&lt;/g;
    s/\>/&gt;/g;
    print STRIP_OUTPUT "$_\n"; 

  }

  close (STRIP_OUTPUT);
  close (STRIP_INPUT);
}

######################################################################
# Adaptation of Bill Fenner's htmlwdiff script
# Requires: wdiff from ftp://ftp.gnu.org/gnu/wdiff/
######################################################################
sub htmlwdiff
{
  my ($diff);
  my ($first, $second) = @_;
  my ($first_name, $second_name) = @_;
  my ($temp1) = "/tmp/iddiff1.$$";
  my ($temp2) = "/tmp/iddiff2.$$";

  &strip($first, $temp1);
  &strip($second, $temp2);

  $first_name =~ s/.*\///g;
  $second_name =~ s/.*\///g;

  $diff = "<html><head><title>wdiff $first_name $second_name</title></head><body>\n<pre>\n";
  $diff .= `wdiff -w "<strike><font color='red'>" -x "</font></strike>" -y "<strong><font color='green'>" -z "</font></strong>" $temp1 $temp2`;
  $diff .= "</pre>\n</body></html>\n";

  unlink ($temp1);
  unlink ($temp2);

  return $diff;
}

######################################################################
# Generate a timezone description for a specified city.
#
# Right now, we just use the Data::ICal::TimeZone interface
# for its back-end database.  Long term, it would be ideal to
# go ahead and use the whole Data::ICal infrastructure (although
# that would create a hard dependency on Data::ICal, which we
# don't currently have).
######################################################################

sub mkicaltz
{
  my $retval = undef;
  eval( <<'EOT'
  use Data::ICal::TimeZone;

  my $zone = Data::ICal::TimeZone->new(timezone => $timezone);
  if (!$zone) { return undef; }

  my $calendar = Data::ICal->new;
  $calendar->add_entry($zone->definition);
  $calendar->as_string =~ /(BEGIN:VTIMEZONE.*END:VTIMEZONE.)/gos;
  $retval = $1;
EOT
  );
  $retval =~ s/\r//gos;
  return $retval."\n";
}