package Page;
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->{PATH}   = undef;
  $self->{BASE_DIR}    = undef;
  $self->{PAGE_TYPE}    = undef;
  $self->{PARSE}    = undef;
  $self->{CGI_HEADER}    = undef;
  $self->{CGI_FOOTER}    = undef;
  $self->{SUBTAGS}  = [];
  $self->{SUBTAGGROUPS}  = [];
  $self->{PAGEORDERS}  = [];
  $self->{PRINTED} = 0;

  # 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; };
        /^path$/i && do { $self->{PATH} = $val; last SWITCH; };
        /^base_dir$/i && do { $self->{BASE_DIR} = $val; last SWITCH; };
        /^page_type$/i && do { $self->{PAGE_TYPE} = $val; last SWITCH; };
        /^parse$/i && do { $self->{PARSE} = $val; last SWITCH; };
        /^cgi_header$/i && do { $self->{CGI_HEADER} = $val; last SWITCH; };
        /^cgi_footer$/i && do { $self->{CGI_FOOTER} = $val; last SWITCH; };
        /^SubTag$/i && do { push @{$self->{SUBTAGS}}, $val; last SWITCH; };
        /^subtaggroup$/i && do { push @{$self->{SUBTAGGROUPS}}, $val; last SWITCH; };
        /^pageorder$/i && do { push @{$self->{PAGEORDERS}}, $val; last SWITCH; };
        $nothing = 1;
      }
    }
  }

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

sub print {
  my $self = shift;
  my $subtag;
  my $subtaggroup;
  my $pageorder;

  if($self->{PRINTED} == 0) {
    if($self->{PAGE_TYPE} ne "PAGEORDER") {
      print "  DefaultPage {\n";
      if(defined($self->{NAME})) {
        print "    name $self->{NAME}\n";
      }
      print "    web_path $self->{PATH}\n";
      print "    source_dir $self->{BASE_DIR}\n";
      print "    output_dir ".($::website->output_dir)."\n";
      if(defined($self->{PARSE})) {
        print "    parse $self->{PARSE}\n";
      }
      if(defined($self->{PAGE_TYPE})) {
        print "    page_type $self->{PAGE_TYPE}\n";
      }
      foreach $subtag (@{$self->{SUBTAGS}}) {
        print "    SubTag $subtag\n";
      }
      foreach $subtaggroup (@{$self->{SUBTAGGROUPS}}) {
        print "    subtaggroup $subtaggroup\n";
      }
      if(defined($::website->common_subtaggroup)) {
        print "    subtaggroup ".($::website->common_subtaggroup)."\n";
      }
      foreach $pageorder (@{$self->{PAGEORDERS}}) {
        print "    pageorder $pageorder\n";
      }
      if(defined($::website->common_pageorder)) {
        print "    pageorder ".($::website->common_pageorder)."\n";
      }
      if(defined($self->{CGI_HEADER})) {
        print "    cgi_header $self->{CGI_HEADER}\n";
      }
      if(defined($self->{CGI_FOOTER})) {
        print "    cgi_footer $self->{CGI_FOOTER}\n";
      }
      print "  }\n";
    } else {
      # First lets print out the pageorderpage's pageorders!
      foreach $pageorder (@{$self->{PAGEORDERS}}) {
        &findAndPrint($self,$pageorder);
      }
      
      print "    PagePart {\n";
      print "      name $self->{NAME}\n";
      print "      filename $self->{PATH}\n";
      print "      directory $self->{BASE_DIR}\n";
      if(defined($self->{PARSE})) {
        print "      parse $self->{PARSE}\n";
      }
      if(defined($self->{CGI_HEADER})) {
        print "    # PageOrderPage's can't be CGI types....
        print "    # cgi_header $self->{CGI_HEADER}\n";
      }
      if(defined($self->{CGI_FOOTER})) {
        print "    # PageOrderPage's can't be CGI types....
        print "    # cgi_header $self->{CGI_FOOTER}\n";
      }
      foreach $subtag (@{$self->{SUBTAGS}}) {
        print "      SubTag $subtag\n";
      }
      foreach $subtaggroup (@{$self->{SUBTAGGROUPS}}) {
        print "      subtaggroup $subtaggroup\n";
      }
      foreach $pageorder (@{$self->{PAGEORDERS}}) {
        print "      pageorder $pageorder\n";
      }
      print "    }\n";
    }
    $self->{PRINTED} = 1;
  }
  return;
}

sub findAndPrint {
  my $self = shift;
  my ($name) = @_;
  my $pageorder = undef;
  my $found = 0;

  $name =~ s/(=?\\)\"//g;

  foreach $pageorder (@::pageorders) {
    if($pageorder->name eq $name) {
      $found = 1;
      if($pageorder->printed == 0) {
        $pageorder->print();
      }
    }
  }

  print "Could not find reference to `$name'...\n" if !$found;

  return;
}

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

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

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

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

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

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

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

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

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

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

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

1;  # so the require or use succeeds