#------------------------------------------------------------
# Copyright (C) 2009 RoyaltyShare, Inc.   All Rights Reserved
# $Id$
#------------------------------------------------------------

package RPS::RoyaltyRun::Process;
use strict;

use Data::Dumper;

use lib '/app/tools/rps/lib';
use lib '/app/tools/common/lib';
use Common::Process;
use Common::Assert;
use Common::Log;

use RPS::DB::Item::Album;
use RPS::DB::Item::Artist;
use RPS::DB::Item::Label;
use RPS::DB::Item::Master;
use RPS::DB::Item::Product;
use RPS::DB::Item::ProductType;
use RPS::DB::Item::Song;
use RPS::DB::Item::Track;

use base 'Common::Process';

sub canExecute { 1 }

sub execute {
    my $self = shift;

    if ( $self->canExecute() ) {
        eval { $self->run(@_); };

        if ($@) {
            print STDERR "$0 died\n";
            print STDERR "$@\n";
            $self->_onFailure( exception => $@ );
            exit 1;
        }
    }
}

sub run {
    my $self = shift;

    unless ( $self->_prevalidateRun() ) {
        $self->_setStateToError();
        return;
    }

    return 1;
}

sub _prevalidateRun {
    my $self = shift;

    $self->_report("Begin Pre Run Validation.");

    return $self->_prevalidateReserveLiquidationSchedule()
      && $self->_prevalidatePennyRate();
}

sub _prevalidatePennyRate {
    my $self = shift;

    my $collection = $self->_getPennyRateErrors();

    if ( defined($collection) ) {
        if ( $collection->hasNext() ) {
            while ( my $row = $collection->next() ) {
                $self->_report( "Track rate type is penny rate, but penny rate is 0: " . Dumper $row );
            }

            return;
        } else {
            $self->_report("Penny Rate test: Passed");
        }
    } else {
        $self->_report("*****  _getPennyRateErrors not overloaded. Not validating penny rate! *****");
    }

    return 1;
}

sub _prevalidateReserveLiquidationSchedule {
    my $self = shift;

    my $collection = $self->_getReserveErrors();

    if ( defined($collection) ) {
        if ( $collection->hasNext() ) {
            while ( my $row = $collection->next() ) {
                $self->_report( "Missing reserve liquidations: " . Dumper $row );
            }

            return;
        } else {
            $self->_report("Reserve Liquidation test: Passed");
        }
    } else {
        $self->_report("*****  _getReserveErrors not overloaded. Not validating liquidation schedule! *****");
    }

    return 1;
}

sub _getReserveErrors   { }
sub _getPennyRateErrors { }

# Going to add the cached metadata accessors here.
# I am going to want these in both the RunController and CreateStatement classes.

sub _getSong {
    my ( $self, $songID ) = @_;

    if ( !$self->{_song}{$songID} ) {
        $self->{_song}{$songID} = RPS::DB::Item::Song->Lookup( song_id => $songID );
    }

    return $self->{_song}{$songID};
}

sub _getTrack {
    my ( $self, $trackID ) = @_;

    if ( !$self->{_track}{$trackID} ) {
        $self->{_track}{$trackID} = RPS::DB::Item::Track->Lookup( track_id => $trackID );
    }

    return $self->{_track}{$trackID};
}

sub _getMaster {
    my ( $self, $masterID ) = @_;

    if ( !$self->{_master}{$masterID} ) {
        $self->{_master}{$masterID} = RPS::DB::Item::Master->Lookup( master_id => $masterID );
    }
    return $self->{_master}{$masterID};
}

sub _getAlbum {
    my ( $self, $albumID ) = @_;

    if ( !$self->{_album}{$albumID} ) {
        $self->{_album}{$albumID} = RPS::DB::Item::Album->Lookup( album_id => $albumID );
    }
    return $self->{_album}{$albumID};
}

sub _getTrackDuration {
    my ( $self, $trackID ) = @_;

    if ( !defined $self->{_trackDuration}{$trackID} ) {
        my $track = $self->_getTrack($trackID);
        assert($track);
        my $master = $self->_getMaster( $track->master_id );
        assert($master);
        my $duration = $master->duration;

        $self->{_trackDuration}{$trackID} = $duration;
    }

    return $self->{_trackDuration}{$trackID};
}

sub _getProduct {
    my ( $self, $productID ) = @_;
    assert($productID);

    if ( !$self->{_product}{$productID} ) {
        $self->{_product}{$productID} = RPS::DB::Item::Product->Lookup( product_id => $productID );
        assert( $self->{_product}{$productID}, "Unable to fetch a product using id $productID" );
    }

    return $self->{_product}{$productID};
}

sub _getLabel {
    my ( $self, $labelID ) = @_;
    assert($labelID);

    if ( !$self->{_label}{$labelID} ) {
        $self->{_label}{$labelID} = RPS::DB::Item::Label->Lookup( label_id => $labelID );
        assert( $self->{_label}{$labelID}, "Unable to fetch a label using id $labelID" );
    }

    return $self->{_label}{$labelID};
}

sub _getArtist {
    my ( $self, $artistID ) = @_;
    assert($artistID);

    if ( !$self->{_artist}{$artistID} ) {
        $self->{_artist}{$artistID} = RPS::DB::Item::Artist->Lookup( artist_id => $artistID );
        assert( $self->{_artist}{$artistID}, "Unable to fetch an artist using id $artistID" );
    }

    return $self->{_artist}{$artistID};
}

sub _getProductType {
    my ( $self, $productTypeID ) = @_;
    assert($productTypeID);

    if ( !$self->{_productType} ) {
        my $productTypeList = RPS::DB::Item::ProductType->GetAll();
        while ( my $productType = $productTypeList->next() ) {
            $self->{_productType}{ $productType->product_type_id } = $productType;
        }
    }

    return $self->{_productType}{$productTypeID};
}

sub _onFailure {
    my $self = shift;

}

sub interupt {
    shift->_onFailure( interupt => 1 );
}

1;