package Website;
use strict;

sub new {
  my $proto = shift;
  my $class = ref($proto) || $proto;
  my $self  = {};
  my $line = undef;
  my $attr = undef;
  my $val = undef;
  my $nothing = undef;
  $self->{NAME}   = undef;
  $self->{MAINTAINER}    = undef;
  $self->{URL}    = undef;
  $self->{OUTPUT_DIR}    = undef;
  $self->{DATABASE_FILENAME}    = undef;
  $self->{COMMON_SUBTAGGROUP}    = undef;
  $self->{COMMON_PAGEORDER}    = undef;
  $self->{LASTMOD_TAGNAME}    = undef;
  $self->{INCLUDE_TAGNAME}    = undef;
  $self->{WSMAKE_VERSION_TAGNAME}    = undef;
  $self->{PATH_TAGNAME}    = undef;
  $self->{SOURCE_TAGNAME}    = undef;
  $self->{OUTPUT_TAGNAME}    = undef;
  $self->{HEADER_TAGNAME}    = undef;
  $self->{FOOTER_TAGNAME}    = undef;

    # Load page from stdin
  while(! ( ($line = <STDIN>) =~ /}/)) {
    next if $line =~ /^\#/;               # Skip comments
    next if $line eq "\n";        # Skip emptylines

    for ($line) {
      s/^\s+//;
      s/\s+$//;
    }

    ($attr,$val) = split /\s+/, $line, 2;

    for ($attr) {
      SWITCH: {
        /^name$/i && do { $self->{NAME} = $val; last SWITCH; };
        /^maintainer$/i && do { $self->{MAINTAINER} = $val; last SWITCH; };
        /^url$/i && do { $self->{URL} = $val; last SWITCH; };
        /^output_dir$/i && do { $self->{OUTPUT_DIR} = $val; last SWITCH; };
        /^database_filename$/i && do { $self->{DATABASE_FILENAME} = $val; last SWITCH; };
        /^common_subtaggroup$/i && do { $self->{COMMON_SUBTAGGROUP} = $val; last SWITCH; };
        /^common_pageorder$/i && do { $self->{COMMON_PAGEORDER} = $val; last SWITCH; };
        /^lastmod_tagname$/i && do { $self->{LASTMOD_TAGNAME} = $val; last SWITCH; };
        /^include_tagname$/i && do { $self->{INCLUDE_TAGNAME} = $val; last SWITCH; };
        /^wsmake_version_tagname$/i && do { $self->{WSMAKE_VERSION_TAGNAME} = $val; last SWITCH; };
        /^path_tagname$/i && do { $self->{PATH_TAGNAME} = $val; last SWITCH; };
        /^source_tagname$/i && do { $self->{SOURCE_TAGNAME} = $val; last SWITCH; };
        /^output_tagname$/i && do { $self->{OUTPUT_TAGNAME} = $val; last SWITCH; };
        /^header_tagname$/i && do { $self->{HEADER_TAGNAME} = $val; last SWITCH; };
        /^footer_tagname$/i && do { $self->{FOOTER_TAGNAME} = $val; last SWITCH; };
        $nothing = 1;
      }
    }
  }

  bless ($self, $class);
  return $self;
}

sub print {
  my $self = shift;
  my $page = undef;
  my $subtaggroup = undef;
  my $pageorder = undef;

  print "Website {\n";
  if(defined($self->{NAME})) {
    print "  name $self->{NAME}\n";
    print "  maintainer $self->{MAINTAINER}\n";
    print "  url $self->{URL}\n";
  }

  print "\n  DefaultSetup {\n";
  print "    lastmod_tagname $self->{LASTMOD_TAGNAME}\n";
  print "    wsmake_version_tagname $self->{WSMAKE_VERSION_TAGNAME}\n";
  print "    web_path_tagname $self->{PATH_TAGNAME}\n";
  print "    source_tagname $self->{SOURCE_TAGNAME}\n";
  print "    output_tagname $self->{OUTPUT_TAGNAME}\n";
  if(defined($self->{HEADER_TAGNAME})) {
    print "    header_tagname $self->{HEADER_TAGNAME}\n";
  }
  if(defined($self->{FOOTER_TAGNAME})) {
    print "    footer_tagname $self->{FOOTER_TAGNAME}\n";
  }
  print "    include_tagname $self->{INCLUDE_TAGNAME}\n";
  print "    database_filename $self->{DATABASE_FILENAME}\n";

  print "\n";
  foreach $subtaggroup (@::subtaggroups) {
    $subtaggroup->print();
  }

  # Pageorders will handle printing of pageorderpages
  foreach $pageorder (@::pageorders) {
    $pageorder->print();
    print "\n";
  }

  print "  }\n\n";

  foreach $page (@::pages) {
    if($page->page_type ne "PAGEORDER") {
      $page->print();
      print "\n";
    }
  }

  print "}\n\n";

  return;
}

sub name {
          my $self = shift;
          if (@_) { $self->{NAME} = shift }
          return $self->{NAME};
}

sub maintainer {
          my $self = shift;
          if (@_) { $self->{MAINTAINER} = shift }
          return $self->{MAINTAINER};
}

sub url {
          my $self = shift;
          if (@_) { $self->{URL} = shift }
          return $self->{URL};
}

sub output_dir {
          my $self = shift;
          if (@_) { $self->{OUTPUT_DIR} = shift }
          return $self->{OUTPUT_DIR};
}

sub database_filename {
          my $self = shift;
          if (@_) { $self->{DATABASE_FILENAME} = shift }
          return $self->{DATABASE_FILENAME};
}

sub common_subtaggroup {
          my $self = shift;
          if (@_) { $self->{COMMON_SUBTAGGROUP} = shift }
          return $self->{COMMON_SUBTAGGROUP};
}

sub common_pageorder {
          my $self = shift;
          if (@_) { $self->{COMMON_PAGEORDER} = shift }
          return $self->{COMMON_PAGEORDER};
}

sub lastmod_tagname {
          my $self = shift;
          if (@_) { $self->{LASTMOD_TAGNAME} = shift }
          return $self->{LASTMOD_TAGNAME};
}

sub include_tagname {
          my $self = shift;
          if (@_) { $self->{INCLUDE_TAGNAME} = shift }
          return $self->{INCLUDE_TAGNAME};
}

sub wsmake_version_tagname {
          my $self = shift;
          if (@_) { $self->{WSMAKE_VERSION_TAGNAME} = shift }
          return $self->{WSMAKE_VERSION_TAGNAME};
}

sub path_tagname {
          my $self = shift;
          if (@_) { $self->{PATH_TAGNAME} = shift }
          return $self->{PATH_TAGNAME};
}

sub source_tagname {
          my $self = shift;
          if (@_) { $self->{SOURCE_TAGNAME} = shift }
          return $self->{SOURCE_TAGNAME};
}

sub output_tagname {
          my $self = shift;
          if (@_) { $self->{OUTPUT_TAGNAME} = shift }
          return $self->{OUTPUT_TAGNAME};
}

sub header_tagname {
          my $self = shift;
          if (@_) { $self->{HEADER_TAGNAME} = shift }
          return $self->{HEADER_TAGNAME};
}

sub footer_tagname {
          my $self = shift;
          if (@_) { $self->{FOOTER_TAGNAME} = shift }
          return $self->{FOOTER_TAGNAME};
}

1;  # so the require or use succeeds