#---------------------------------------------------------------
# ____                   _ _         ____  _
#|  _ \ ___  _   _  __ _| | |_ _   _/ ___|| |__   __ _ _ __ ___
#| |_) / _ \| | | |/ _` | | __| | | \___ \| '_ \ / _` | '__/ _ \
#|  _ < (_) | |_| | (_| | | |_| |_| |___) | | | | (_| | | |  __/
#|_| \_\___/ \__, |\__,_|_|\__|\__, |____/|_| |_|\__,_|_|  \___|
#            |___/             |___/
#
# Copyright (C) 2011 RoyaltyShare, Inc.   All Rights Reserved
#---------------------------------------------------------------

package RPS::Report::Dynamic::LicenseIncome::Base;

use strict;
use warnings;
use Date::Calc;

use lib '/app/tools/common/lib';
use lib '/app/tools/rps/lib';
use lib '/app/tools/report/lib';
use Common::Client;
use RPS::DB::Item::DynamicReport::LicenseIncome::Base;

use base 'Report::Dynamic::SingleQuery';


sub Group { 'License Income' }
sub Type { 'License Income' }
sub FilenameType { 'License Income' }
sub ClientTypeMask { return Common::Client::kArtist; }



sub UserLevelIsValid
{
    my ($class, $userLevel) = @_;
    my %validLevels = (
        AppUser::DB::Item::AccessLevel::kRSAdmin() => 1,
        AppUser::DB::Item::AccessLevel::kRSAccountRep() => 1,
        AppUser::DB::Item::AccessLevel::kRoyalty() => 1,
        AppUser::DB::Item::AccessLevel::kAdminCatalogView() => 1,
        AppUser::DB::Item::AccessLevel::kAdmin() => 1,
    );

    return $validLevels{$userLevel};
}


sub _ParamClass { 'RPS::Report::Dynamic::LicenseIncome::Base::Parameters'; }

sub _getCollection 
{
    my $self = shift;

    my $startDate;
    my $endDate;
    my $dateTypeParam = $self->parameters()->{Criteria}->DateType();
    if ($dateTypeParam)
    {
        if ('By Date' eq $dateTypeParam)
        {
            $startDate = $self->parameters()->{Criteria}->StartDate();
            $endDate = $self->parameters()->{Criteria}->EndDate();
        }
    }

   # Need to determine whether we're sending processed or unprocessed
    my $transTypes = $self->parameters()->{OptionalData}->ReportType();

#    my $processed = 1 if ('All' eq $transTypes || 'Processed' eq $transTypes);
#    my $unprocessed = 1 if ('All' eq $transTypes || 'Pending' eq $transTypes);

   
    return RPS::DB::Item::DynamicReport::LicenseIncome::Base->ReportQuery(
        startDate => $startDate,
        endDate => $endDate,
        transType => $transTypes,
    );
}


# JPK - I am hacking this to take the Processed/Pending status into account.
#
sub _nextReportLineData
{
    my ($self) = @_;

    my $transTypes = $self->parameters()->{OptionalData}->ReportType();
    my $lineData = $self->SUPER::_nextReportLineData();
    return $lineData if ('All' eq $transTypes);

    while ($lineData)
    {
        last if ($transTypes eq $lineData->[11]);
        $lineData = $self->SUPER::_nextReportLineData();
    }

    return $lineData;
}



# All these Transaction reports will use the same columns for the Transaction details.
# But they will have a lot of different stuff as well.
#
sub _columns
{   
    my ($self) = @_;

    my $cols = [];

    push @$cols, 
    {
        header => {
            name => 'file-name',
        },
        column => {
            field => 'file_name',
        }
    },
    {
        header => {
            name => 'date',
        },
        column => {
            field => 'date',
            method => '_formatDate',
            excel => 'date:Y-M-D',
        }
    },
    {
        header => {
            name => 'units',
        },
        column => {
            field => 'units',
            excel => 'number:1',
        }
    },
    {
        header => {
            name => 'amount',
            method => '_appendCurrencyCode',
        },
        column => {
            field => 'amount',
            excel => 'number:0.00',
        }
    },
    {
        header => {
            name => 'album-title',
        },
        column => {
            field => 'album_title',
        }
    },
    {
        header => {
            name => 'catalog-no',
        },
        column => {
            field => 'catalog_number',
        }
    },
    {
        header => {
            name => 'track-title',
        },
        column => {
            field => 'track_title',
        }
    },
    {
        header => {
            name => 'contract-title',
        },
        column => {
            field => 'contract_title',
        }
    },
    {
        header => {
            name => 'contract-id',
        },
        column => {
            field => 'contract_id',
        }
    },
    {
        header => {
            name => 'income-type',
        },
        column => {
            field => 'income_type',
        }
    },
    {
        header => {
            name => 'memo',
        },
        column => {
            field => 'memo',
        }
    },
    {
        header => {
            name => 'status',
        },
        column => {
            field => 'sale_id',
            method => '_determineStatus',
        }
    },
    {
        header => {
            name => 'sales-period-name',
        },
        column => {
            method => '_formatPeriodName',
            field => 'period_name',
        }
    },
    {
        header => {
            name => 'sales-period-id',
        },
        column => {
            field => 'period_id',
        }
    },
    {
        header => {
            name => 'run-name',
        },
        column => {
            field => 'sale_id',
            method => '_determineRunName',
        }
    },
    {
        header => {
            name => 'run-id',
        },
        column => {
            field => 'sale_id',
            method => '_determineRunID',
        }
    };

    return $cols;
}

sub _getSaleRunStatus
{
    my ($self, $runID) = @_;

    if (! defined $self->{_saleRunStatus})
    {
        # JPK - This is really an ugly hack, but I don't really want to stuff this code into the DB::Item::LicenseIncome class.
        #
        my $sql = 'SELECT license_income.sale_id, artist_royalty_run.label, artist_royalty_run.artist_royalty_run_id FROM license_income'
         . " JOIN sale_run_map ON (license_income.sale_id = sale_run_map.sale_id AND sale_run_map.run_type='ARTR' AND sale_run_map.status='paid')"
         . ' JOIN artist_royalty_run ON (sale_run_map.run_id = artist_royalty_run.artist_royalty_run_id)'
         . ' WHERE artist_royalty_run.status in (2,5)';

        my $dbo = Common::RSApp::GetClientDB();
        my $sth = $dbo->DoCmd($sql);
        while (my $ar = $sth->fetchrow_arrayref())
        {
            $self->{_saleRunStatus}{$ar->[0]} = 
            {
                status => 'Processed',
                run_name => $ar->[1],
                run_id => $ar->[2],
            };
        }
    }

    return { status=>'Pending', run_name=>'', run_status=>'' } unless defined $self->{_saleRunStatus}{$runID};
    return $self->{_saleRunStatus}{$runID};
}

sub _determineStatus
{
    my ($self, %args) = @_;
    my $rowItem = $args{row};
    my $fieldName = $args{field};
    my $saleID = $rowItem->$fieldName();

    my $saleRunStatus = $self->_getSaleRunStatus($saleID);
    return $saleRunStatus->{status};
}

sub _determineRunName
{
    my ($self, %args) = @_;
    my $rowItem = $args{row};
    my $fieldName = $args{field};
    my $saleID = $rowItem->$fieldName();

    my $saleRunStatus = $self->_getSaleRunStatus($saleID);
    return $saleRunStatus->{run_name};
}

sub _determineRunID
{
    my ($self, %args) = @_;
    my $rowItem = $args{row};
    my $fieldName = $args{field};
    my $saleID = $rowItem->$fieldName();

    my $saleRunStatus = $self->_getSaleRunStatus($saleID);
    return $saleRunStatus->{run_id};
}

sub _prettyDate
{
    my ($date) = @_;
    my ($year, $month, $day) = split('-', $date);

    $month = substr(Date::Calc::Month_to_Text($month), 0, 3);

    return "$month $day, $year";
}

sub _formatPeriodName
{
    my ($self, %args) = @_;
    my $rowItem = $args{row};
    my $fieldName = $args{field};

    my $periodName = $rowItem->$fieldName();
    if (! $periodName)
    {
        my $startDate = $rowItem->period_start_date();
        my $endDate = $rowItem->period_end_date();
        if ($startDate)
        {
            $periodName = _prettyDate($startDate);
        }
        if ($endDate)
        {
            $periodName .= ' - ' if $periodName;
            $periodName .= _prettyDate($endDate);
        }
    }



    return $periodName;
}



1;


package RPS::Report::Dynamic::LicenseIncome::Base::Parameters;

use strict;
use warnings;

use lib '/app/tools/common/lib';
use lib '/app/tools/report/lib';
use lib '/app/tools/rps/lib';

use base 'RPS::Report::Dynamic::Parameters';


sub _Criteria
{
    return {
        'StartDate' =>
        {
            order => 1,
            type => Report::Dynamic::Parameters::kTypeDate,
            display => 'Start',
        },
        'EndDate' =>
        {
            order => 2,
            type => Report::Dynamic::Parameters::kTypeDate,
            display => 'End',
        },
        'DateType' => 
        {
            type => Report::Dynamic::Parameters::kTypeMenu,
            display => 'Only show data based on date parameters',
            validValues => ['None', 'By Date'],
            value => 'None',
        },
    };
}
sub __Criteria
{
    return {
        'DateType' => 
        {
            type => Report::Dynamic::Parameters::kTypeMenu,
            display => 'Show sales',
            order => 1,
            validValues => ['None', 'By Date'],
            value => 'None',
        },
        'StartDate' =>
        {
            order => 2,
            type => Report::Dynamic::Parameters::kTypeDate,
            display => 'Start',
        },
        'EndDate' =>
        {
            order => 3,
            type => Report::Dynamic::Parameters::kTypeDate,
            display => 'End',
        },
    };
}


sub _OptionalData
{
    {
        'ReportType' => {
            type => Report::Dynamic::Parameters::kTypeRadioGroup,
            order => 1,
            validValues => ['Pending', 'Processed', 'All'],
            displayValues => ['Show Pending', 'Show Processed', 'Show All'],
            value => 'Pending',  # This sets the _default_ value.
            filename => ['wPending', 'wProcessed', 'wAll'],
        },
    }
}



1;