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

use strict;
use warnings;
use Data::Dumper;
use Carp;
use Date::Calc qw( Date_to_Days Decode_Date_US );

use lib '/app/tools/common/lib';
use Common::Assert;
use Common::Util qw(decodeDateMysql);
use Common::Log;

use lib '/app/tools/rps/lib';
use RPS::License::BaseTrackLicense;
use RPS::License::LicenseType;
use RPS::Publisher::CA::Publisher;
use RPS::DB::Item::CATrackLicense;
use RPS::DB::Item::CALicenseReserve;
use RPS::DB::Item::FinanceTransaction;
use RPS::DB::Item::ReserveLiquidation;
use RPS::DB::Item::CAMechanicalStatementItem;
use RPS::DB::Item::CAMechanicalStatementLicense;
use RPS::DB::Item::CAPublisherTrackCrossedLicenseAccount;
use RPS::License::ReserveLiquidationList;


use RPS::License::CA;
use base 'RPS::License::BaseTrackLicense';

sub _getDBItem
{
    my ($self, $id) = @_;
    return RPS::License::CA::GetDBItem($id);
}

sub _type { return RPS::License::LicenseType::kPublishingLicense; }


sub _propertiesFromDBItem
{
	my ($self, $hrProperties, $dbItem) = @_;

    $self->SUPER::_propertiesFromDBItem($hrProperties, $dbItem);
	$hrProperties->{ca_track_license_id} = $dbItem->ca_track_license_id,
	$hrProperties->{ca_publisher_id}	 = $dbItem->ca_publisher_id,
	$hrProperties->{issuer_song_id}	 = $dbItem->issuer_song_id,
}



sub _initProperties
{
    my ($self, $props) = @_;

	$self->SUPER::_initProperties($props);

    $self->{TrackLicenseID}     = Common::FormObject::Scalar->new(value => $props->{ca_track_license_id}, readOnly => 1);
    $self->{PublisherID}	    = Common::FormObject::Scalar->new(value => $props->{ca_publisher_id});
    $self->{IssuerSongID}	    = Common::FormObject::Scalar->new(value => $props->{issuer_song_id}, maxlength => 40);

    $self->createPublisher();

	if ($props->{ca_track_license_id})
    {

        # We need to mark the license so that we can tell if it's ever been used in a run (that wasn't deleted).
        #
        my $inUse = 0;

        my $licenseCount = RPS::DB::Item::CAMechanicalStatementLicense->LicenseCount($props->{ca_track_license_id});
        if ($licenseCount > 0)
        {
            $inUse = 1;
        }

        # Let's also check for (historical) reserves, just to be safe

        if ($inUse == 0)
        {
            my $reserveCount = RPS::DB::Item::CALicenseReserve->CountByTrackLicenseID($props->{ca_track_license_id});
            if ($reserveCount > 0)
            {
                $inUse = 1;
            }
        }

        # And lastly let's check for committed (that is, non-pending) transactions.

        if ($inUse == 0)
        {
            my $trackLicense = RPS::DB::Item::CATrackLicense->Lookup(ca_track_license_id => $props->{ca_track_license_id});
            if ($trackLicense->finance_account_id)
            {
                my $transactions = RPS::DB::Item::FinanceTransaction->GetAccountTransactions(finance_account_id => $trackLicense->finance_account_id);
            	while ($transactions->hasNext())
            	{
                    $inUse = 1;
                    last;
                }
            }
        }

        $self->{InUse} = $inUse;

    }

}


sub _setDBValues
{
    my ($self, $dbItem) = @_;
    assert($dbItem);
    $self->SUPER::_setDBValues($dbItem);

    $dbItem->ca_publisher_id($self->PublisherID());
    $dbItem->issuer_song_id($self->IssuerSongID());
}


sub _getCountryCodeMapForValidation
{
    my ($self) = @_;
    my $matchingProductTypes = $self->_getMatchingProductTypes( $self->ProductTypeID );

    my %countryCodeMap;
    my $similarLicenses = RPS::DB::Item::CATrackLicense->GetByTrackPublisherProductTypeAndDate($self->TrackID(),$self->PublisherID, $matchingProductTypes,
																							   $self->TermStart, $self->TermEnd);
    while (my $similarLicense = $similarLicenses->next())
    {
        # Skip over _this_ track license...
        #
        next if ($self->TrackLicenseID() && $similarLicense->ca_track_license_id == $self->TrackLicenseID());
		# Skip all inactive licenses
		#
		next if( $similarLicense->inactive );
        # Skip unless there is an overlap of start and end terms
		#
		next unless( $similarLicense->{start_term_overlap} || $similarLicense->{end_term_overlap} );
		my $ccMapItems = RPS::DB::Item::RegionCountryMap->GetByRegionID($similarLicense->region_id());
        while (my $mapItem = $ccMapItems->next())
        {
            $countryCodeMap{$mapItem->country_code} = 1;
        }
    }


    return \%countryCodeMap;
}


sub _getPublisherObject
{
    my ($self, $publisherID) = @_;
    assert($publisherID);

    my $pubObj = RPS::Publisher::CA::Publisher->new(publisherID => $publisherID, readOnly => 1);
    return $pubObj;
}

sub createPublisher {
	my $self = shift;

	$self->{Publisher} = $self->_getPublisherObject($self->PublisherID)
	    if( $self->PublisherID );
}


###
1;#
###