#------------------------------------------------------------
# Copyright (C) 2006 RoyaltyShare, Inc.   All Rights Reserved
# $Id$
#------------------------------------------------------------
package RPS::Statement::FastRender;

# This will serve as a generic base class for 'paginated' statements.
# These are statements that have been 'rendered' into a row/cell based 
# representation, and are therefore easy to paginate.
#
# These will NOT provide the same interface as other Statement classes. These
# are indented strictly for quick rendering.  Indeed, we'll use the 'rich' Statement
# classes to generate these.
#
# This base class will provide common mechanisms for pagination, and declare abstract
# methods for fetching and rendering the row data.
#
# !!! So, the XML representation we're looking for is:
# <Statement>
#   <Table>
#     <Class>TableClass</Class>
#     <Row>
#       <Class>RowClass</Class>
#       <Column>
#         <Class>ColumnClass</Class>
#         <DisplayValue>Blah</DisplayValue>
#         <LinkValue>rps/someDisplayArea?c=some_command&id=123</LinkValue>
#       </Column>
#       <Column>...</Column>
#     </Row>
#     <Row>...</Row>
#   </Table>
#   <Table>...</Table>
# <Statement>
#

use Data::Dumper;

use lib '/app/tools/common/lib';
use lib '/app/tools/rps/lib';
use Common::Assert;
use Common::Log;
use Common::Util;
use Common::FormObject::List::NumericPaged;
use Common::WriteXML;


sub _defaultPageSize() { return 50; }

use base 'Common::XMLObject';


sub _init
{
    my ($self, %args) = @_;

    # We handle the pagination in this class.
    #
    $self->{_page} = Common::Util::returnFirstDefined($args{page}, 1);
    $self->{_pageSize} = Common::Util::returnFirstDefined($args{pageSize}, $self->_defaultPageSize());

    # If we are passed a row, then we will determine which page to show based on the row and page size.
    #
    if ($args{row})
    {    
        $self->{_page} = int($args{row} / $self->{_pageSize}) + 1;
    }
    
    # We're going to use a 'lazy' model here.  Rather than build up a data structure
    # in memory, we're going to just sanity check and store our parameters when we
    # construct this object.    The actual data and formatting will happen at the last moment,
    # when we're outputting XML.

    $self->SUPER::_init(%args);

    return $self;
}

 # So, if I did want to create a 'row' iterator here, what would I need to do?
 #
 sub getNextRow
 {
    my ($self) = @_;

    # If we haven't even _started_ yet, get the collection iterator and build the first row.
    # Then, we build the next row.  You see, we don't know whether we're done building the
    # row until we fetch a row with a different row index.
    if (! $self->{_rowIterator})
    {
        # starting
        #
        $self->{_rowIterator} = $self->getRowCollection();
        $self->{_currentRowItem} = $self->{_rowIterator}->next();
    }

    if ($self->{_currentRowItem})
    {
        my $rowIndex = $self->{_currentRowItem}->row_index();

        my %row;
        while ($self->{_currentRowItem} && $self->{_currentRowItem}->row_index == $rowIndex)
        {
            $row{TableClass} = $self->{_currentRowItem}->table_class();
            $row{RowClass} = $self->{_currentRowItem}->row_class();

            push @{$row{Cells}}, {
                CellClass => $self->{_currentRowItem}->cell_class(),
                DisplayValue => $self->{_currentRowItem}->display_value(),
                LinkValue => $self->{_currentRowItem}->link_value(),
                TitleValue => $self->{_currentRowItem}->title_value(),
            };

            $self->{_currentRowItem} = $self->{_rowIterator}->next();
        }

        return \%row;
    }
    else
    {
        # we're done.
        #
        return undef;
    }
 }



sub writeXML
{
	my ($self, $xw, $tag, %extraParams) = @_;

    # This outputs the XML reprenting our current pagination state.
    #
    my %paginationHash;
#    $self->_initPagination($self->{Pagination}, \%paginationHash);

    Common::FormObject::List::NumericPaged::CreateNumericPagination(\%paginationHash,
     currentPage => $self->{_page},
     numPages => $self->_numPages(),
    );

#    $outputHash->{Pagination}{PageSize} = $self->{_pageSize};

    $xw->starttag('Statement');

    Common::WriteXML::writeXML($xw, \%paginationHash, 'Pagination');

    # So, what we're going to try to do here is output XML as a 'stream'.
    # Rather than construct a bunch of nested objects, we're going to
    # basically just spew out XML as the data comes out of the DB::ItemCollection.
    #
    # This should keep the memory overhead to a minimum. It also constrains us somewhat, since
    # there won't be a lot of abstraction (everything we need to know about the XML document lives
    # right here in this method).
    # 

    my $collection = $self->getRowCollection();
    my $currentTableClass;
    my $currentRowIndex;
    
    # First, let's check for a repeating row if we're not on the first page.
    #
    if ($self->{_page} != 1)
    {
        my $repeatingRowCollection = $self->getFullRepeatingRow();
        while (my $repeatingRow = $repeatingRowCollection->next)
        {
            ($xw, $currentTableClass, $currentRowIndex) = $self->addItemToXML($xw, $repeatingRow, $currentTableClass, $currentRowIndex);
        }
    }

    while (my $item = $collection->next)
    {
        ($xw, $currentTableClass, $currentRowIndex) = $self->addItemToXML($xw, $item, $currentTableClass, $currentRowIndex);
    }

    # Close off our dangling tags.
    #
    $xw->endtag('Row');
    $xw->endtag('Table');

    $xw->endtag('Statement');

    $self->SUPER::writeXML($xw, $tag, %extraParams);
}


sub addItemToXML
{
    my ($self, $xw, $item, $currentTableClass, $currentRowIndex) = @_;
    #Common::Log::Print("ITEM: " . Dumper($item));
    # Starting a new table?
    #
    if (! defined $currentTableClass || $currentTableClass ne $item->table_class)
    {
        if (defined $currentTableClass)
        {
            $xw->endtag('Row');
            $xw->endtag('Table');
        }

        $xw->starttag('Table');
        $currentTableClass = $item->table_class;
        $xw->element('Class', $currentTableClass);
        $currentRowIndex = undef;
    }

    # Starting a new row?
    #
    if (! defined $currentRowIndex || $currentRowIndex != $item->row_index)
    {
        if (defined $currentRowIndex)
        {
            $xw->endtag('Row');
        }

        $xw->starttag('Row');
        $xw->element('Class', $item->row_class);
        $currentRowIndex = $item->row_index;
    }

    # Output the cell data.
    #
    $xw->starttag('Cell');
        $xw->element('Class', $item->cell_class);
        $xw->element('DisplayValue', $item->display_value);
        $xw->element('LinkValue', $item->link_value);
        $xw->element('TitleValue', $item->title_value);
    $xw->endtag('Cell');
    
    return ($xw, $currentTableClass, $currentRowIndex) ;
}

# NOTE!!!
# The built-in pagination in DB::ItemCollection is not utilized here.
# In otherwords, we don't call 'setPagination' on the collection.
# The accessor method is presumed to do whatever limiting is necessary.
# This is because these are complex joined queries - We return a 'row'
# (in the DBI sense) for each _cell_. 
#

# Subclasses probably won't need to touch this, but you never know...
#
sub _initPagination
{
    my ($self, $collection, $outputHash) = @_;

    return if $self->{_page} eq 'ALL';

    Common::FormObject::List::NumericPaged::CreateNumericPagination($outputHash,
     currentPage => $self->{_page},
     numPages => $self->_numPages(),
    );

    $outputHash->{Pagination}{PageSize} = $self->{_pageSize};
}

sub _numPages
{
    my ($self) = @_;

    assert(0, 'override');
}

sub getRowCollection
{
    my ($self) = @_;

    assert(0, 'override to return DB::ItemCollection');
}

sub getFullRepeatingRow
{
    my ($self) = @_;

    assert(0, 'override');
}



###
1;#
###