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

use Carp;
use Data::Dumper;

use lib '/app/tools/rps/lib';
use RPS::ControlledComposition::ControlledComposition;
use RPS::Payee::ArtistPayee;
use RPS::DB::Item::ArtistContract;
use RPS::DB::Item::Artist;

use RPS::XMLObject;
use base 'RPS::XMLObject';

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

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

    if ( $args{_dbItem} ) {
        return $self->_initFromDBItem( $args{_dbItem} );
    } elsif ( $args{artistContractID} ) {
        return $self->_initFromDB( $args{artistContractID} );
    } else {
        return $self->_initWithDefaults();
    }
}

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

    my $dbItem = RPS::DB::Item::ArtistContract->Lookup( artist_contract_id => $id );
    return $self->_initFromDBItem($dbItem);
}

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

    return $self if ( !$dbItem );

    $self->_initProperties($dbItem);

    if ( $self->loadSubs() ) {
        $self->_initSubs($dbItem);
    }

    return $self;
}

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

    $self->{ArtistContractID} = RPS::XMLObject::Scalar::Integer->new( value => $dbItem->artist_contract_id, readOnly => 1 );
    $self->{ArtistPayeeID} = RPS::XMLObject::Scalar::Integer->new( value => $dbItem->artist_payee_id );
    $self->{ClientContractID} = RPS::XMLObject::Scalar::String->new( value => $dbItem->client_contract_id );
    $self->{Title}            = RPS::XMLObject::Scalar::String->new( value => $dbItem->title );
    $self->{Notes}            = RPS::XMLObject::Scalar::String->new( value => $dbItem->notes );
    $self->{IssueDate} = RPS::XMLObject::Scalar::Date->new( value => $dbItem->issue_date );
    $self->{TermStart} = RPS::XMLObject::Scalar::Date->new( value => $dbItem->term_start );
    $self->{TermEnd}   = RPS::XMLObject::Scalar::Date->new( value => $dbItem->term_end );
    $self->{Status} = RPS::XMLObject::Scalar::Integer->new( value => $dbItem->status );

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

    # -jff- the artist contract by itself is fairly useless,
    # so I feel like ArtistPayee is a pretty integral part of this object.
    # It was in the _initSubs, but I moved it here.
    #
    $self->{ArtistPayee} = RPS::Payee::ArtistPayee->new( artistPayeeID => $dbItem->artist_payee_id, loadSubs => 0 );

    # We need to fetch the artist name, given the artist id.
    #
    my $artistName;
    if ( $dbItem->artist_id ) {
        my $artistDBItem = RPS::DB::Item::Artist->Lookup( artist_id => $dbItem->artist_id );
        $artistName = $artistDBItem->name;
    }
    $self->{ArtistName} = RPS::XMLObject::Scalar::String->new( value => $artistName );
    $self->{ArtistID} = RPS::XMLObject::Scalar::Integer->new( value => $dbItem->artist_id );

    return $self;
}

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

    if ( $self->loadSubs() ) {

        # Load all the contract clauses.
        #
        $self->{ControlledComposition} =
          RPS::ControlledComposition::ControlledComposition->new( contractID => $dbItem->artist_contract_id );
    }

    return $self;
}

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

    $self->{ArtistContractID} = RPS::XMLObject::Scalar::Integer->new( readOnly => 1 );
    $self->{ArtistID}         = RPS::XMLObject::Scalar::Integer->new();
    $self->{ArtistPayeeID}    = RPS::XMLObject::Scalar::Integer->new();
    $self->{ClientContractID} = RPS::XMLObject::Scalar::String->new();
    $self->{Title}            = RPS::XMLObject::Scalar::String->new();
    $self->{Notes}            = RPS::XMLObject::Scalar::String->new();
    $self->{IssueDate}        = RPS::XMLObject::Scalar::Date->new();
    $self->{TermStart}        = RPS::XMLObject::Scalar::Date->new();
    $self->{TermEnd}          = RPS::XMLObject::Scalar::Date->new();
    $self->{Status}           = RPS::XMLObject::Scalar::Integer->new();

    $self->{CreatedDate}  = RPS::XMLObject::Scalar::DateTime->new( readOnly => 1 );
    $self->{ModifiedDate} = RPS::XMLObject::Scalar::DateTime->new( readOnly => 1 );
    $self->{CreatedBy}    = RPS::XMLObject::Scalar::UserName->new( readOnly => 1 );
    $self->{ModifiedBy}   = RPS::XMLObject::Scalar::UserName->new( readOnly => 1 );

    $self->{ArtistPayee} = RPS::Payee::ArtistPayee->new();
    $self->{ArtistName}  = RPS::XMLObject::Scalar::String->new();

    if ( $self->loadSubs() ) {
        $self->{ControlledComposition} = RPS::ControlledComposition::ControlledComposition->new();
    }

    return $self;
}

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

    # my $valid = $self->SUPER::validate();
    my $valid = 1;

    if ( !$self->ArtistPayeeID() ) {
        $self->{ArtistPayeeID}->setError(RPS::XMLObject::kErrFieldBlank);
        $valid = 0;
    }

    if ( $self->ArtistName() ) {

        # check for duplicate artist name:
        #   we're not actually going to flag an error here,
        #   just use the existing artist_id if it exists.
        #
        if ( !$self->ArtistID ) {
            my $tmpArtist = RPS::DB::Item::Artist->Lookup( name => $self->ArtistName() );
            if ( defined $tmpArtist && lc( $tmpArtist->name ) eq lc( $self->ArtistName() ) ) {
                $self->ArtistID( $tmpArtist->artist_id );
            }
        }
    }

    return $valid;
}

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

    # -------------------------------
    # Save or create the artist
    # -------------------------------
    #
    my $artistObj;
    if ( $self->ArtistID() ) {
        $artistObj = RPS::DB::Item::Artist->Lookup( artist_id => $self->ArtistID() );

        # changing the artist? see if it's a different artist
        if ( $self->ArtistName() ) {
            if ( lc( $artistObj->name ) ne lc( $self->ArtistName() ) ) {
                $artistObj = RPS::DB::Item::Artist->Create( name => $self->ArtistName() );
                $artistObj->save();
            }
        }
    } elsif ( $self->ArtistName() ) {

        # Create a new artist.
        $artistObj = RPS::DB::Item::Artist->Create( name => $self->ArtistName() );
        $artistObj->save();
    }

    my $dbObj;
    if ( $self->ArtistContractID() ) {
        $dbObj = RPS::DB::Item::ArtistContract->Lookup( artist_contract_id => $self->ArtistContractID() );
    } else {
        $dbObj = RPS::DB::Item::ArtistContract->Create();
    }

    # set fields here
    #
    $dbObj->artist_id( $artistObj->artist_id );
    $dbObj->artist_payee_id( $self->ArtistPayeeID() );
    $dbObj->client_contract_id( $self->ClientContractID() );
    $dbObj->title( $self->Title() );
    $dbObj->notes( $self->Notes() );
    $dbObj->issue_date( $self->IssueDate() );
    $dbObj->term_start( $self->TermStart() );
    $dbObj->term_end( $self->TermEnd() );
    $dbObj->status( $self->Status() );

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

    # reload object
    #
    $self->_initProperties($dbObj);
}

sub delete {
    my $self = shift;

    my $myDBObj = RPS::DB::Item::ArtistContract->Lookup( artist_contract_id => $self->ArtistContractID() );
    $myDBObj->delete();

    return 1;
}

###
1;    #
###