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

use strict;
use warnings;

use Data::Dumper;

use lib '/app/tools/rps/lib';
use RPS::DistributorContract::Term;
use RPS::DB::Item::DistributorContract;
use RPS::DB::Item::DistributorContractTerm;

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

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

sub _tagName {
    return 'Term';
}

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

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

    my $collection = RPS::DB::Item::DistributorContractTerm->GetByDistributorContractID( $args{distributorContractID} );
    return $collection;
}

sub _keyMethodName {
    return 'DistributorContractTermID';
}

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

    if ( $self->{_distributorContractID} ) {
        return RPS::DistributorContract::Term->new( distributorContractID => $self->{_distributorContractID} );
    }

    return RPS::DistributorContract::Term->new();
}

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

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

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

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

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

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

    # We want to keep track of the contract ID for later.
    #
    if ( $args{distributorContractID} ) {

     #$self->{_dependency} = RPS::DB::Item::DistributorContractTerm->GetTermDependencyByDistributorContractID($args{distributorContractID});
        $self->{_distributorContractID} = $args{distributorContractID};
    }

    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->LabelName.
#

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

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

    return $keys;
}

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

    my @keys = sort { uc( $self->{Term}{$a}->LabelName() ) cmp uc( $self->{Term}{$b}->LabelName() ) } 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.
    #

    #
    my $keysSorted = $self->getAllKeysSortedByTermLabelName();

    foreach my $termID (@$keysSorted) {
        my $termObj = $self->{Term}{$termID};
        $termObj->save();
    }
}

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

    return $self->{_distributorContractID};
}

###
1;    #
###