#---------------------------------------------------------------
# ____                   _ _         ____  _
#|  _ \ ___  _   _  __ _| | |_ _   _/ ___|| |__   __ _ _ __ ___
#| |_) / _ \| | | |/ _` | | __| | | \___ \| '_ \ / _` | '__/ _ \
#|  _ < (_) | |_| | (_| | | |_| |_| |___) | | | | (_| | | |  __/
#|_| \_\___/ \__, |\__,_|_|\__|\__, |____/|_| |_|\__,_|_|  \___|
#            |___/             |___/
#
# Copyright (C) 2009 RoyaltyShare, Inc.   All Rights Reserved
#---------------------------------------------------------------
package BookPub::Sale::Feed::SaleFeedFileList;
use strict;
use warnings;

use Data::Dumper;

use lib '/app/tools/common/lib';
use Common::Assert;
use lib '/app/tools/bookpub/lib';
use BookPub::DB::Item::SaleFeedFile;
use BookPub::Sale::Feed::SaleFeedFile;
use BookPub::Sale::Feed::SaleFeedService;

use BookPub::RDAS::Request::SaleFeedFileList;

use base 'Common::FormObject::List';

sub _itemName { return 'SaleFeedFile'; }

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

    $self->{_serviceID}         = $args{serviceID};
    $self->{_saleFeedID}        = $args{saleFeedID};
    $self->{_saleFeedServiceID} = $args{saleFeedServiceID};

    assert( $args{serviceID} || $args{saleFeedID} || $args{saleFeedServiceID} );

    return $self->SUPER::_init(@_);
}

sub serviceID         { shift->{_serviceID} }
sub saleFeedID        { shift->{_saleFeedID} }
sub saleFeedServiceID { shift->{_saleFeedServiceID} }

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

    return
        $args{serviceID}  ? BookPub::DB::Item::SaleFeedFile->GetAllByServiceID( $self->serviceID )
      : $args{saleFeedID} ? BookPub::DB::Item::SaleFeedFile->GetAllBySaleFeedID( $self->saleFeedID )
      :                     BookPub::DB::Item::SaleFeedFile->GetAllBySaleFeedServiceID( $self->saleFeedServiceID );
}

sub _getObj {
    my ( $self, $dbItem ) = @_;
    assert($dbItem);

    return BookPub::Sale::Feed::SaleFeedFile->new( dbItem => $dbItem, readOnly => 1 );
}

sub fetch {
    my $self = shift;

    assert( $self->saleFeedID || $self->saleFeedServiceID );

    my $service =
      new BookPub::Sale::Feed::SaleFeedService( saleFeedID => $self->saleFeedID, saleFeedServiceID => $self->saleFeedServiceID );
    my $saleFeedServiceID = $self->saleFeedServiceID;

    Log->info("Fetching all available files");
    if ( $self->saleFeedID ) {
        Log->info( "Fetching file list with sale feed id: " . $self->saleFeedID );
    } else {
        Log->info( "Fetching file list with sale feed service id: " . $self->saleFeedServiceID );
    }

    my $request = BookPub::RDAS::Request::SaleFeedFileList->GetRequestObject(
        $service->ServiceID,
        saleFeedServiceID => $service->SaleFeedServiceID,
        saleFeedID        => $self->saleFeedID
    );

    #die "Failed file list request." unless( $request->run() );
    #
    # Rather than dying here, let's just log the error and keep things moving along.
    # That way we can still process feeds for other clients. FB16922
    {
        no warnings 'uninitialized';
        Log->error("Failed file list request for sale feed service id: $saleFeedServiceID") unless ( $request->run() );
    }

    my $files = $request->Files();

    unless ($files) {
        Log->error("No sales files found");
        return;
    }

    my $itemName = $self->_itemName();
    $self->{$itemName} = [];

    foreach my $f (@$files) {
        my $file = new BookPub::Sale::Feed::SaleFeedFile(
            saleFeedID        => $self->saleFeedID,
            saleFeedServiceID => $service->SaleFeedServiceID,
            startDate         => $f->{start},
            endDate           => $f->{end},
            filename          => $f->{filename},
            accountID         => $f->{accountID},
            url               => $f->{link}
        );
        push( @{ $self->{$itemName} }, $file );
    }
}

1;