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

use strict;
use warnings;

use Data::Dumper;

use lib '/app/tools/rps/lib';
use RPS::ArtistContract::Term;
use RPS::DB::Item::NewArtistContract;
use RPS::DB::Item::NewArtistContractTerm;

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

use Common::FormHash;
use base 'Common::FormHash';


sub _tagName
{
    return 'Term';
}


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

    if (!$args{artistContractID})
    {
        return undef;
    }

    my $collection = RPS::DB::Item::NewArtistContractTerm->GetByArtistContractID($args{artistContractID});
    return $collection;
}


sub _keyMethodName
{
    return 'ArtistContractTermID';
}


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

    if($self->{_artistContractID})
    {
        return RPS::ArtistContract::Term->new(artistContractID => $self->{_artistContractID});
    }
    
    return RPS::ArtistContract::Term->new();
}


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

    return RPS::ArtistContract::Term->new(_dbItem => $dbItem);
}


sub _addObject
{
    my ($self, $object) = @_;

    # The term with priority == 0 is the special default property.  We handle that in a special
    # way, so we don't want it in this list.
    #
    if ($object->Priority() == 0)
    {
        return;
    }

    $self->SUPER::_addObject($object);

    if ($self->{_dependency} && exists $self->{_dependency}{$object->ArtistContractTermID()})
    {
        $object->setDependency();
    }
}


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


    # We want to keep track of the contract ID for later.
    #
	if($args{artistContractID})
	{
        $self->{_dependency} = RPS::DB::Item::NewArtistContractTerm->GetTermDependencyByArtistContractID($args{artistContractID});
		$self->{_artistContractID} = $args{artistContractID};
    }

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


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

	my $valid = 1;
    foreach my $termID (keys %{$self->{Term}})
    {
        my $term = $self->{Term}{$termID};
		next if (!defined $term);

        if (! $term->validate())
        {
            $valid = 0;
        }
	}

	return $valid;
}


# Overriding inherited method to return the keys sorted by Term->Priority.
#
sub getKeys
{
    my ($self) = @_;

    my $keys = $self->getAllKeysSortedByTermPriority();

    return $keys;
}


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

    my @keys = sort {$self->{Term}{$a}->Priority() <=> $self->{Term}{$b}->Priority()} keys %{$self->{Term}};
    return \@keys;
}

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

    
    # !!!
    # I moved the 'smarts' about what happens when deleting a Term into the
    # Term class's Save method.   Basically, checking $term->{_hasData} was a
    # violation of encapsulation.
    #
    # We do still need to determine which Terms are getting deleted, however, since
    # we need to adjust their priority values (priority should be contiguous).
    # Going to do that in a somewhat simpler fashion.
    #
    my $keysSortedByPriority = $self->getAllKeysSortedByTermPriority();

    # Remember, priority '0' term is not in this list.
    #
    my $newPriority = 1;  
    foreach my $termID (@$keysSortedByPriority)
    {
        my $termObj = $self->{Term}{$termID};
        if (! $termObj->Delete())
        {
            $termObj->Priority($newPriority++);
        }
        $termObj->save();
    }
}



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

	return $self->{_artistContractID};
}


###
1;#
###