#------------------------------------------------------------
# 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->{_hasData} ) {
            $termObj->Priority( $newPriority++ );
        }
        $termObj->save();
    }
}

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

    return $self->{_artistContractID};
}

###
1;    #
###