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

use strict;
use warnings;
use Carp;
use Data::Dumper;

use lib '/app/tools/rps/lib';
use RPS::LabelContract::GroupTermHash;
use RPS::LabelPayee::LabelPayee;

use RPS::DB::Item::LabelContract;

use Common::FormObject;

use base 'Common::FormObject';


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

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

    my %properties;
    if ($args{_dbItem})
    {
        $self->_propertiesFromDBItem(\%properties, $args{_dbItem});
    }
    elsif ($args{labelContractID})
    {
        $self->_propertiesFromDB(\%properties, $args{labelContractID});
    }
    else
    {
        $self->_propertiesFromDefaults(\%properties);
    }

    $self->_initProperties(\%properties);
    $self->_initSubs(\%properties);

    return $self;
}


sub _propertiesFromDB
{
    my ($self, $hrProperties, $id) = @_;

    my $dbItem = RPS::DB::Item::LabelContract->Lookup(label_contract_id => $id);
    $self->_propertiesFromDBItem($hrProperties, $dbItem);
}


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

    $hrProperties->{label_contract_id} = $dbItem->label_contract_id;
    $hrProperties->{title} = $dbItem->title;
    $hrProperties->{label_payee_id} = $dbItem->label_payee_id;
    $hrProperties->{payor_id} = $dbItem->payor_id;
    $hrProperties->{client_contract_id} = $dbItem->client_contract_id;
    $hrProperties->{issue_date} = $dbItem->issue_date;

    $hrProperties->{date_created} = $dbItem->date_created;
    $hrProperties->{date_modified} = $dbItem->date_modified;
    $hrProperties->{created_by} = $dbItem->created_by;
    $hrProperties->{modified_by} = $dbItem->modified_by;

}


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

    $self->{LabelContractID}	= Common::FormObject::Scalar->new(value => $props->{label_contract_id}, readOnly => 1);
    $self->{Title}				= Common::FormObject::Scalar::String->new(value => $props->{title}, required => 1);
    $self->{LabelPayeeID}		= Common::FormObject::Scalar->new(value => $props->{label_payee_id}, required => 1);
    $self->{PayorID}		    = Common::FormObject::Scalar->new(value => $props->{payor_id}, required => 1);
    $self->{ClientContractID}	= Common::FormObject::Scalar::String->new(value => $props->{client_contract_id});
    $self->{IssueDate}			= Common::FormObject::Scalar::Date->new(value => $props->{issue_date});

    $self->{CreatedDate}		= Common::FormObject::Scalar::DateTime->new(value => $props->{date_created}, readOnly => 1);
    $self->{ModifiedDate}		= Common::FormObject::Scalar::DateTime->new(value => $props->{date_modified}, readOnly => 1);
    $self->{CreatedBy}			= Common::FormObject::Scalar::UserName->new(value => $props->{created_by}, readOnly => 1);
    $self->{ModifiedBy}			= Common::FormObject::Scalar::UserName->new(value => $props->{modified_by}, readOnly => 1);

    my $labelPayee = RPS::LabelPayee::LabelPayee->new(labelPayeeID => $props->{label_payee_id}, loadSubs => 0, readOnly => 1);
	$self->{LabelPayeeName}     = Common::FormObject::Scalar::String->new(value => $labelPayee->Name(), readOnly => 1);

}


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

	if($self->loadSubs())
	{
        my $labelContractID = $props->{label_contract_id};

        $self->{GroupTermList} = RPS::LabelContract::GroupTermHash->new(labelContractID => $labelContractID);

	}
}


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

    my $defaultPayor = RPS::DB::Item::Payor->GetDefault();
    if ($defaultPayor)
    {
        $hrProperties->{payor_id} = $defaultPayor->payor_id;
    }
    # JPK - Don't have any canned defaults (yet)
    #
}



sub validate
{
    my ($self) = @_;

    my $valid = $self->SUPER::validate();
    
    
	if($self->loadSubs())
	{
        my $termList = $self->GroupTermList();
    
        my %labelsSeen;
    
        foreach my $termID (keys %{$termList->{GroupTerm}})
        {
            my $term = $termList->{GroupTerm}{$termID};
    		next if (!defined $term);
    		
    		my $termLabelList = $term->GroupTermLabelList();
            foreach my $termLabelID (keys %{$termLabelList->{GroupTermLabel}})
            {
                my $termLabel = $termLabelList->{GroupTermLabel}{$termLabelID};
        		next if (!defined $termLabel);		
    
                # We need to make sure that this label is not already associated
                # with the same payee through a different contract.
                if ($termLabel->LabelID() && ! $termLabel->Delete())
                {            
                    # We also want to check for dupes on the same contract.
                    #
                    if ($labelsSeen{$termLabel->LabelID()})
                    {
                        $termLabel->{LabelID}->setError(Common::FormObject::kErrFieldDuplicate);
                        $valid = 0;
                    } 
                    else
                    {
                        $labelsSeen{$termLabel->LabelID()} = 1;
                    }        
                    
                    my $contractTerms = RPS::DB::Item::LabelContractGroupTermLabel->GetByLabelID($termLabel->LabelID());
                    while (my $contractTerm = $contractTerms->next())
                    {   
                        my $otherGroupTerm = RPS::DB::Item::LabelContractGroupTerm->Lookup(label_contract_group_term_id => $contractTerm->label_contract_group_term_id);
                        if ($otherGroupTerm->label_contract_id != $self->LabelContractID())
                        {    
                            my $otherContract = RPS::DB::Item::LabelContract->Lookup(label_contract_id => $otherGroupTerm->label_contract_id);
                            if ($otherContract->label_payee_id == $self->LabelPayeeID)
                            {
                                $termLabel->{LabelID}->setError(Common::FormObject::kErrFieldInvalid);
                                $valid = 0;
                            }
                        }
                    }                                                 
                }		
            }   		
        }
    }

    return $valid;
}

sub save
{
    my ($self) = @_;

	my $dbObj;
	if($self->LabelContractID())
	{
		$dbObj = RPS::DB::Item::LabelContract->Lookup(label_contract_id => $self->LabelContractID());
	}
	else
	{
		$dbObj = RPS::DB::Item::LabelContract->Create();
	}

	# set fields here
	#
	$dbObj->label_payee_id($self->LabelPayeeID());
	$dbObj->client_contract_id($self->ClientContractID());
	$dbObj->title($self->Title());
	$dbObj->issue_date($self->IssueDate());
	$dbObj->payor_id($self->PayorID());

	# save db item
	#
	$dbObj->save();

	if($self->loadSubs())
	{
    	# save the term list
    	#	
    	foreach my $termKey (keys %{$self->{GroupTermList}->getHash()})
    	{	
            my $term = $self->{GroupTermList}->getHash()->{$termKey};
    		if(defined $term && defined $term->DistributionFee())
    		{
    			$term->LabelContractID($dbObj->label_contract_id);
    		}
    	}
    
        $self->{GroupTermList}->save();
    }
	$dbObj->touch();
	$dbObj->save();
	$self->_init(_dbItem => $dbObj);
}

sub delete
{
	my $self = shift;

	# TODO: we'll have to delete all the terms, reserve, escalation, attached albums, tracks, etc...
	#
	# my $myDBObj = RPS::DB::Item::NewArtistContract->Lookup(artist_contract_id => $self->ArtistContractID());
	# $myDBObj->delete();

	return 1;
}


# Need to handle LabelPayeeID a little differently.
# I want to be automatically update the LabelPayeeName field when this is changed.
#
sub LabelPayeeID
{
    my ($self, @args) = @_;

    if ($self->{LabelPayeeID})
    {
        my $rval = $self->{LabelPayeeID}->access(@args);
        if (scalar @args && $rval)
        {
            my $payeeID = $self->{LabelPayeeID}->access();
            my $payeeName = '- Unknown -';
            if ($payeeID)
            {
                my $payeeObj = RPS::LabelPayee::LabelPayee->new(labelPayeeID => $payeeID, readOnly => 1);
                $payeeName = $payeeObj->Name();
            }
    
            # This field is read-only...  The 'best' way to deal with it is to
            # simply _replace_ the object.
            #
    	    $self->{LabelPayeeName} = Common::FormObject::Scalar->new(value => $payeeName, readOnly => 1);
        }
        return $rval;
    }
    
}


###
1;#
###