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

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

use lib '/app/tools/common/lib';
use Common::Assert;

use lib '/app/tools/rps/lib';
use RPS::LabelContract::LabelContract;
use RPS::LabelList;
use RPS::Payor::PayorList;
use RPS::RoyaltyRun::RoyaltyRunStatusList;
use RPS::CountryList;
use RPS::ServiceList;
use RPS::DB::Item::LabelContract;
use RPS::DB::Item::LabelContractGroupTerm;
use RPS::DB::Item::LabelContractGroupTermLabel;

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

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

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

	if($args{labelContractGroupTermID})
	{
		$self->{GroupTerm}
			= RPS::LabelContract::GroupTerm->new(
				labelContractGroupTermID => $args{labelContractGroupTermID}
			);

	}
	elsif($args{labelContractID})
	{
		$self->{GroupTerm}
			= RPS::LabelContract::GroupTerm->new(
				labelContractID => $args{labelContractID}
			);

	}	
	else
	{
		die "Unable to create group term";
	}

	$self->{LabelList} = RPS::LabelList->new();
	$self->{CountryList} = RPS::CountryList->new();
	$self->{ServiceList} = RPS::ServiceList->new(fileOnly => 1);
	

	$self->{RoyaltyRunStatus} = new RPS::RoyaltyRun::RoyaltyRunStatusList( label => 1 );

	return $self;
}

sub _propertyIsEditable
{
	my ($self, $propertyName) = @_;

	# The Product (and contained objects) can be edited.
	#
	# if ($propertyName eq 'Album')
	# {
		# return 1;
	# }
	if ($propertyName eq 'GroupTerm')
	{
		return 1;
	}
	return 0;
}

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

    my $valid = $self->{GroupTerm}->validate();

    # We need to make sure that the labels for this term aren't already associated with the payee
    # on this contract or another contract.	  
    my $term = $self->{GroupTerm};
       
    my $labelContract = RPS::DB::Item::LabelContract->Lookup(label_contract_id => $term->LabelContractID);
    my $labelPayeeID = $labelContract->label_payee_id;  
    my %labelsSeen;        
    
    # Let's prefill this with the labels from the _other_ terms on this contract.
    my $groupTerms = RPS::DB::Item::LabelContractGroupTerm->GetByLabelContractID($term->LabelContractID);
    while (my $groupTerm = $groupTerms->next()) {
        if ($groupTerm->label_contract_group_term_id != $term->LabelContractGroupTermID) {
            my $groupTermLabels = RPS::DB::Item::LabelContractGroupTermLabel->GetByLabelContractGroupTermID($groupTerm->label_contract_group_term_id);   
            while (my $groupTermLabel = $groupTermLabels->next()) {    
                $labelsSeen{$groupTermLabel->label_id} = 1;
            }
        }
    }    
    
	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 != $term->LabelContractID())
                {    
                    my $otherContract = RPS::DB::Item::LabelContract->Lookup(label_contract_id => $otherGroupTerm->label_contract_id);
                    if ($otherContract->label_payee_id == $labelPayeeID)
                    {
                        $termLabel->{LabelID}->setError(Common::FormObject::kErrFieldInvalid);
                        $valid = 0;
                    }
                }
            }                                                 
        }		
    }
    
    if (!$term->DistributionFee)
    {
        $term->{DistributionFee}->setError(Common::FormObject::kErrFieldBlank);
        $valid = 0;
    }
    		
	return $valid;
}

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

	$self->{GroupTerm}->save();
}

sub delete
{
	my ($self) = @_;
	my $term = $self->{GroupTerm};
	
    # Let's make sure this isn't the only term attached to the contract.
    my $groupTermCount = 0;
    my $groupTerms = RPS::DB::Item::LabelContractGroupTerm->GetByLabelContractID($term->LabelContractID);
    while (my $groupTerm = $groupTerms->next()) {	
        $groupTermCount++;
    }
    
    if ($groupTermCount > 1) {
	    $self->{GroupTerm}->delete();
    } else {
        return undef;   
    }
}

sub labelContractGroupTermID
{
	my ($self) = @_;
	return $self->{GroupTerm}->LabelContractGroupTermID();
}


###
1;#
###