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

use strict;
use warnings;

use lib '/app/tools/rps/lib';
use RPS::DB::Item::ExpenseType;
use RPS::DB::Item::Expense;
use RPS::DB::Item::ExpenseName;
use Common::FormObject;
use base 'Common::FormObject';


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

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

    my %properties;
    if ($args{_dbItem})
    {
        $self->_propertiesFromDBItem(\%properties, $args{_dbItem});
    }
    elsif ($args{expenseTypeID})
    {
        $self->_propertiesFromDB(\%properties, $args{expenseTypeID});
    }
    elsif($args{artistContractID})
    {
        $self->_propertiesFromDefaults(\%properties, $args{artistContractID});
    }
	else
	{
		# we need something!
		confess("we need some init parameter for ExpenseType.");
	}

    $self->_initProperties(\%properties);

    return $self;
}


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

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


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

	$self->{_inDB} = 1;

    $hrProperties->{expense_type_id}	= $dbItem->expense_type_id;
    $hrProperties->{artist_contract_id} = $dbItem->artist_contract_id;
    $hrProperties->{expense_name_id}	= $dbItem->expense_name_id;
    $hrProperties->{percent}			= $dbItem->percent;
    $hrProperties->{inactive}			= $dbItem->inactive;
}


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

    $self->{ExpenseTypeID}		= Common::FormObject::Scalar->new(value => $props->{expense_type_id}, readOnly => 1);
    $self->{ArtistContractID}	= Common::FormObject::Scalar->new(value => $props->{artist_contract_id}, required => 1);
    $self->{ExpenseNameID}		= Common::FormObject::Scalar->new(value => $props->{expense_name_id});
    $self->{Percent}			= Common::FormObject::Scalar::Percent->new(value => $props->{percent}, required => 1);
    $self->{Inactive}			= Common::FormObject::Scalar::Boolean->new(value => $props->{inactive}, readOnly => 1);

	# We need to fetch the expense name, given the id
	#
	my $expenseName;
	if ($props->{expense_name_id})
	{
		my $dbItem = RPS::DB::Item::ExpenseName->Lookup(expense_name_id => $props->{expense_name_id});
		if($dbItem)
		{
			$expenseName = $dbItem->name;
		}
	}
	$self->{ExpenseName} = Common::FormObject::Scalar::String->new(value => $expenseName, readOnly => 1);
	$self->{NewExpenseName} = Common::FormObject::Scalar::String->new(skipXML => 1);

	# we need to know if there are expenses using this type
	#
	my $linkedProcesssedExpenses = 0;
	my $linkedUnProcessedExpenses = 0;
	if($props->{expense_type_id})
	{
		my $expenseColl = RPS::DB::Item::Expense->GetByType($props->{expense_type_id});
		while($expenseColl->hasNext())
		{
			my $dbItem = $expenseColl->next();
			($dbItem->processed) ? $linkedProcesssedExpenses++ : $linkedUnProcessedExpenses++;
		}
	}
	$self->{LinkedProcessed} = Common::FormObject::Scalar->new(value => $linkedProcesssedExpenses, readOnly => 1);
	$self->{LinkedUnProcessed} = Common::FormObject::Scalar->new(value => $linkedUnProcessedExpenses, readOnly => 1);

	# for deleting
	$self->{Delete} = Common::FormObject::Scalar->new();
}


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


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

    $hrProperties->{artist_contract_id} = $contractID;
}


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

	if($self->Delete() || $self->Inactive())
	{
		return 1;
	}

    my $valid = 1;

	if($self->NewExpenseName() && $self->ExpenseNameID())
	{
		$valid = 0;
		$self->{ExpenseNameID}->setError(Common::FormObject::kErrFieldInvalid);
		$self->{NewExpenseName}->skipXML(0);
	}

	# was something entered?
	#
	if($self->Percent() || $self->ExpenseNameID() || $self->NewExpenseName())
	{
		$valid = $self->SUPER::validate();

		if(!$self->ExpenseNameID() && !$self->NewExpenseName())
		{
			$self->{ExpenseNameID}->setError(Common::FormObject::kErrFieldBlank);
			$valid = 0;
		}
		if($self->Percent() <= 0)
		{
			$self->{Percent}->setError(Common::FormObject::kErrFieldInvalid);
			$valid = 0;
		}
	}
	return $valid;
}

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

	if($self->Delete())
	{
		$self->delete();
		return;
	}

	# -------------------------------
	# Save or create the expense name
	# -------------------------------
	#
	my $expenseNameObj;
	if($self->ExpenseNameID())
	{
		$expenseNameObj = RPS::DB::Item::ExpenseName->Lookup(expense_name_id => $self->ExpenseNameID());
	}
	elsif($self->NewExpenseName())
	{
		# Create a new expense name.
		$expenseNameObj = RPS::DB::Item::ExpenseName->Create(name => $self->NewExpenseName());
		$expenseNameObj->save();
	}

	my $dbObj;
	my $oldPercent;
	if($self->ExpenseTypeID())
	{
		$dbObj = RPS::DB::Item::ExpenseType->Lookup(expense_type_id => $self->ExpenseTypeID());
		$oldPercent = $dbObj->percent();
	}
	else
	{
		$dbObj = RPS::DB::Item::ExpenseType->Create();
	}

	# set fields here
	#
	$dbObj->artist_contract_id($self->ArtistContractID());
	$dbObj->expense_name_id($expenseNameObj->expense_name_id());
	$dbObj->percent($self->Percent());

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

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

	# update attached expenses with new percent
	#
	if(defined $oldPercent && $oldPercent != $self->Percent())
	{
		my $expenseColl = RPS::DB::Item::Expense->GetByType($self->ExpenseTypeID());
		while($expenseColl->hasNext())
		{
			my $dbItem = $expenseColl->next();
			if(!$dbItem->processed)
			{
				$dbItem->percent($self->Percent());
				$dbItem->save();
			}
		}
	}
}

sub delete
{
	my $self = shift;

	my $dbItem = RPS::DB::Item::ExpenseType->Lookup(expense_type_id => $self->ExpenseTypeID());
	$dbItem->inactive(1);
	$dbItem->save();
}


###
1;#
###