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

use strict;
use warnings;

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

use lib '/app/tools/rps/lib';
use RPS::DB::Item::Expense;
use RPS::Expense::ExpenseType;

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

use constant kParentTypeAlbumContract => 1;
use constant kParentTypeTrackContract => 2;

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

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

    my %properties;
    if ($args{_dbItem})
    {
        $self->_propertiesFromDBItem(\%properties, $args{_dbItem});
    }
    elsif ($args{expenseID})
    {
        $self->_propertiesFromDB(\%properties, $args{expenseID});
    }
    else
    {
        $self->_propertiesFromDefaults(\%properties, $args{parentID}, $args{parentType});
    }

    $self->_initProperties(\%properties);
    $self->_initSubs(\%properties);

    return $self;
}


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

    my $dbItem = RPS::DB::Item::Expense->Lookup(expense_id => $id);
    $self->_propertiesFromDBItem($hrProperties, $dbItem);
}


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

	$self->{_inDB} = 1;

    $hrProperties->{expense_id}			= $dbItem->expense_id;
    $hrProperties->{expense_type_id}	= $dbItem->expense_type_id;
    $hrProperties->{parent_type}		= $dbItem->parent_type;
    $hrProperties->{parent_id}			= $dbItem->parent_id;
    $hrProperties->{amount}				= $dbItem->amount;
    $hrProperties->{percent}			= $dbItem->percent;
    $hrProperties->{memo}				= $dbItem->memo;
    $hrProperties->{pre_process}		= $dbItem->pre_process;
    $hrProperties->{processed}			= $dbItem->processed;
}


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

    $self->{ExpenseID}		= Common::FormObject::Scalar->new(value => $props->{expense_id});
    $self->{ExpenseTypeID}	= Common::FormObject::Scalar->new(value => $props->{expense_type_id}, required => 1);
    $self->{ParentType}		= Common::FormObject::Scalar->new(value => $props->{parent_type}, required => 1);
    $self->{ParentID}		= Common::FormObject::Scalar->new(value => $props->{parent_id}, required => 1);
    $self->{Percent}		= Common::FormObject::Scalar::Decimal->new(value => $props->{percent}, precision => '0.2');
    $self->{Amount}			= Common::FormObject::Scalar::Decimal->new(value => $props->{amount}, required => 1, precision => '0.2');
    $self->{Memo}			= Common::FormObject::Scalar::String->new(value => $props->{memo});
    $self->{PreProcess}		= Common::FormObject::Scalar->new(value => $props->{pre_process});
    $self->{Processed}		= Common::FormObject::Scalar->new(value => $props->{processed}, readOnly => 1);
    # just for display purposes
    my $effectiveAmount 	= Common::RSMath::round($props->{amount} * ($props->{percent} / 100), 2);
    $self->{EffectiveAmount}	= Common::FormObject::Scalar::Decimal->new(value => $effectiveAmount, precision => '0.2');
}


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

	if($self->loadSubs())
    {
		if($props->{expense_type_id})
		{
	    	$self->{ExpenseType} = RPS::Expense::ExpenseType->new(expenseTypeID => $props->{expense_type_id}, readOnly => 1);
		}
    }
}


sub _propertiesFromDefaults
{
    my ($self, $hrProperties, $parentID, $parentType) = @_;

    assert($parentID);
    assert($parentType);

    $hrProperties->{parent_id} = $parentID;
    $hrProperties->{parent_type} = $parentType;
}



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

	my $valid = 1;

	# only validate if something was entered
	#
	if(defined $self->Amount() || defined $self->ExpenseTypeID())
	{
		$valid =  $self->SUPER::validate();

		if(!$self->Amount() > 0)
		{
			$self->{Amount}->setError(Common::FormObject::kErrFieldInvalid);
			$valid = 0;
		}
	}

	return $valid;
}

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

	my $dbObj;
	if($self->ExpenseID())
	{
		$dbObj = RPS::DB::Item::Expense->Lookup(expense_id => $self->ExpenseID());
	}
	else
	{
		$dbObj = RPS::DB::Item::Expense->Create();
	}

	# set fields here
	#
	$dbObj->expense_type_id($self->ExpenseTypeID());
	$dbObj->parent_type($self->ParentType());
	$dbObj->parent_id($self->ParentID());
	$dbObj->amount($self->Amount());
	$dbObj->percent($self->Percent());
	$dbObj->memo($self->Memo());
	$dbObj->pre_process($self->PreProcess());
	$dbObj->processed($self->Processed());

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

	# reload object
	#
	$self->_init(_dbItem => $dbObj);
}

sub delete
{
	my $self = shift;

	if($self->{_inDB} && !$self->Processed())
	{
		my $dbItem = RPS::DB::Item::Expense->Lookup(expense_id => $self->ExpenseID());
		$dbItem->delete();
		$self->{_inDB} = 0;
	}
	return 1;
}


###
1;#
###