#------------------------------------------------------------
# Copyright (C) 2006 RoyaltyShare, Inc.   All Rights Reserved
#------------------------------------------------------------
package RPS::Report;
use strict;
use warnings;

use lib '/app/tools/common/lib';
use Common::FormObject;
use Common::Assert;
use Common::Client;
use Common::Locale;

use lib '/app/tools/rps/lib';
use RPS::DB::Item::Product;
use RPS::DB::Item::ReportQueries;
use RPS::DB::Item::ReportQueries::TrackWithoutLicenses;

use base 'Common::XMLObject';

use constant kDefaultPageSize => 30;

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

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

    my $page = $args{page};
    $page = 1 unless $page;

    if ( $page eq 'iterator' ) {
        return $self->_initIterator(%args);
    } else {
        return $self->_initReport(%args);
    }
}

sub _initIterator {
    my $self = shift;

    $self->{_iterator} = $self->_getDBItem(@_);

    return $self;
}

sub _initReport {
    my $self = shift;
    my %args = @_;

    my $page = $args{page};
    $page = 1 unless $page;

    my $pageSize = $args{pageSize};
    $pageSize = kDefaultPageSize unless $pageSize;

    my $rows = $self->_getDBItem(@_);

    if ( 'all' ne $page ) {
        $rows->setPagination( pageIndex => ($page), pageSize => $pageSize );

        $self->{Page}     = $page;
        $self->{NumPages} = $rows->numPages();
    }

    $self->{ $self->_baseXMLName() } = [];
    while ( my $item = $rows->next() ) {
        my $trackHash = $self->_fillInHash($item);

        push @{ $self->{ $self->_baseXMLName() } }, $trackHash;
    }

    return $self;
}

sub _baseXMLName {
    assert( 0, "Must be overloaded" );
}

sub _fillInHash {
    assert( 0, "Must be overloaded" );
}

sub _getDBItem {
    assert( 0, "Must be overloaded" );
}

sub _reportColumns {
    assert( 0, "Must be overloaded" );
}

sub _next {
    my $self = shift;
    return unless ( $self->{_iterator} );
    return $self->{_iterator}->next();
}

sub getNextRow {
    my $self = shift;
    my $i;
    my $row  = $self->_next();
    my @list = $self->_reportColumns();
    my $result;

    if ($row) {
        my $data = $self->_fillInHash($row);

        unless ( $data->{ProductType} ) {
            $data->{ProductType} = $self->_getProductType( $data->{ProductTypeID} );
        }

        for ( $i = 0 ; $i < @list ; $i += 2 ) {
            $result .= "\t" if ( defined $result );
            $result .= ref( $data->{ $list[$i] } ) ? $data->{ $list[$i] }->access() : $data->{ $list[$i] };
        }
    }

    return $result;
}

sub getHeader {
    my $self = shift;
    my @order;
    my $i;
    my @list = $self->_reportColumns();

    for ( $i = 0 ; $i < @list ; $i += 2 ) {
        push( @order, $list[ $i + 1 ] );
    }

    return join( "\t", @order );
}

sub _getProductTypeHash {
    my $self = shift;
    my %result;

    return $self->{xml}{_productTypeHash} if ( $self->{xml}{_productTypeHash} );

    my $productTypes = RPS::Product::TypeList->new( includeTrackProducts => 1 );

    foreach my $type ( @{ $productTypes->{Type} } ) {
        $result{ $type->ProductTypeID } = $type->Description;
    }

    # Add in the special product types
    $result{ RPS::DB::Item::Product::kAllDigitalProducts } = "All Digital";
    $result{ RPS::DB::Item::Product::kAllPhysicalProducts } = "All Physical";

    $self->{xml}{_productTypeHash} = \%result;
    return \%result;
}

sub _getProductType {
    my $self = shift;
    my $productTypeID = shift || return "All";

    my $pt = $self->_getProductTypeHash();

    return $pt->{$productTypeID};
}

###
1;    #
###