Apache::iNcom::CartManager - Object responsible for managing the user

    $Cart->order( \%item );
    my $items = $Cart->items;
    $Cart->empty;

#
#    CartManager.pm - Object that manages user shopping cart
#
#    This file is part of Apache::iNcom.
#
#    Author: Francis J. Lacoste <francis.lacoste@iNsu.COM>
#
#    Copyright (C) 1999 Francis J. Lacoste, iNsu Innovations
#
#    This program is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 2 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program; if not, write to the Free Software
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
package Apache::iNcom::CartManager;

use strict;


use vars qw( $VERSION );

BEGIN {
    ($VERSION) = '$Revision: 1.7 $' =~ /Revision: ([\d.]+)/;
}

sub new {
    my $proto = shift;
    my $class = ref $proto || $proto;

    my ( $cart, $package, $profile_file ) = @_;

    $cart ||= {};

    bless { profile_file => $profile_file,
	    cart	 => $cart,
	    package	 => $package,
	  }, $class;
}

sub cart {
    my $self = shift;

    # Return the cart data structure.
    $self->{cart};
}

my %DEFAULT_DELEGATES = (
			 item_price	=> sub { 0 },
			 item_discount	=> sub { 0 },
			 discount	=> sub { 0 },
			 shipping	=> sub { 0 },
			 taxes		=> sub { 0 },
			);

sub load_delegates {
    my $self = shift;

    # Define delegates in the namespace of the page
    my $delegates_code = "package " . $self->{package} . ";\n";

    # Read in the delegates code
    open ( DELEGATES, $self->{profile_file} )
      or die "Error loading pricing delegates: $!\n";
    my $line;
    while ( defined ( $line = <DELEGATES> ) ) {
	$delegates_code .= $line;
    }
    close DELEGATES;

    my $delegates = eval $delegates_code;
    die "Error evaluating delegates: $@" if $@;
    die "Delegates didn't evaluate to an hash ref\n"
      unless ref $delegates eq "HASH";

    # Make sure that defaults functions are defined for
    # all of them
    for my $name (keys %DEFAULT_DELEGATES ) {
	my $f = $delegates->{$name} ||= $DEFAULT_DELEGATES{$name};
	die "Delegate $name is not a function ref\n" 
	  unless ref $f eq "CODE";
    }

    $delegates;
}

my %RESERVED_ITEM_NAMES = map { $_ => 1 }
  qw( quantity price discount subtotal );

sub order {
    my $self = shift;

    # Add items to shopping cart
    for my $item (@_) {
	my @attr = sort grep { not $RESERVED_ITEM_NAMES{$_} } keys %$item;

	my $key = join "\0", map { $item->{$_} } @attr;

	if ( defined $item->{quantity} && $item->{quantity} == 0 ) {
	    delete $self->{cart}{items}{$key}
	} else {
	    my $q = $item->{quantity} || 1;
	    my $cart_item = $self->{cart}{items}{$key};
	    unless ( $cart_item ) {
		# Item is not already in cart
		$self->{cart}{items}{$key} = $cart_item = {};
		# Copy key attributes
		for my $attr ( @attr ) {
		    $cart_item->{$attr} =  $item->{$attr};
		}
		$cart_item->{quantity} = 0;
	    }
	    $cart_item->{quantity} += $q;

	    # Toss item if deleted
	    delete $self->{cart}{items}{$key}
	      if ($cart_item->{quantity} <= 0);
	}

	# Mark cart as needing recomputation
	$self->{cart}{dirty} = 1;
    }
}

sub empty {
    my $self = shift;

    delete $self->{cart}{items};
    $self->{cart}{items}    = {};

    # Reset cart status
    $self->{cart}{subtotal} = 0;
    $self->{cart}{discount} = 0;
    $self->{cart}{dirty}    = 0;
    $self->{cart}{total}    = 0;
    $self->{cart}{taxes}    = 0;
    $self->{cart}{shipping} = 0;
}

sub is_empty {
    my $self = shift;

    return keys %{$self->{cart}{items}} == 0;
}

sub items {
    my $self = shift;

    $self->compute;

    return values %{$self->{cart}{items}};
}

sub subtotal {
    my $self = shift;

    $self->compute;
    return $self->{cart}{subtotal};
}

sub taxes  {
    my $self = shift;

    $self->compute;
    my $taxes = $self->{cart}{taxes};

    return wantarray ? @$taxes : $taxes if ref $taxes;
    return $taxes;
}

sub total {
    my $self = shift;

    $self->compute;
    return $self->{cart}{total};
}

sub discount {
    my $self = shift;

    $self->compute;
    my $discount = $self->{cart}{discount};

    return wantarray ? @$discount : $discount if ref $discount;
    return $discount;
}

sub shipping {
    my $self = shift;

    $self->compute;
    my $shipping = $self->{cart}{shipping};

    return wantarray ? @$shipping : $shipping if ref $shipping;
    return $shipping;
}

sub item_price {
    my ($self, $item) = @_;

    # Load the customized function to calculate price
    my $delegates = $self->load_delegates;

    my $item_copy = { %$item };
    $item_copy->{quantity} ||= 1;

    return $delegates->{item_price}->( $item_copy );
}

sub item_discount {
    my ($self, $item) = @_;

    # Load the customized function to calculate price
    my $delegates = $self->load_delegates;

    my $item_copy = { %$item };
    $item_copy->{quantity} ||= 1;
    $item_copy->{price} = $delegates->{item_price}->( $item_copy );

    return $delegates->{item_discount}->( $item_copy );
}

sub item_pricing {
    my ($self, $item) = @_;

    # Load the customized function to calculate price
    my $delegates = $self->load_delegates;

    # Copy the item infos
    my $item_pricing = { %$item };

    $item_pricing->{quantity} ||= 1;

    my $item_price	= $delegates->{item_price}->( $item_pricing );
    my $item_discount   = $delegates->{item_discount}->( $item_pricing );

    $item_pricing->{price}	= $item_price;
    $item_pricing->{discount}	= $item_discount;
    $item_price			= apply_discount( $item_price, $item_discount);
    $item_pricing->{subtotal}	= $item_price * $item->{quantity};

    return $item_pricing;
}

sub compute {
    my $self = shift;

    return unless $self->{cart}{dirty};

    # Load the customized function to calculate price
    my $delegates = $self->load_delegates;

    my $subtotal = 0;
    my $items = [values %{$self->{cart}{items} }];
    for my $item ( @$items ) {
	my $item_price	    = $delegates->{item_price}->( $item );
	my $item_discount   = $delegates->{item_discount}->( $item );

	$item->{price}	    = $item_price;
	$item->{discount}   = $item_discount;
	$item_price	    = apply_discount( $item_price, $item_discount);
	$item->{subtotal}   = $item_price * $item->{quantity};
	$subtotal += $item->{subtotal};
    }

    $self->{cart}{subtotal} = $subtotal;
    my $shipping    = $self->{cart}{shipping} =
      $delegates->{shipping}->( $subtotal, $items );
    my $discount    = $self->{cart}{discount} =
      $delegates->{discount}->( $subtotal, $shipping, $items );
    my $taxes	    = $self->{cart}{taxes}    =
      $delegates->{taxes}->( $subtotal, $shipping, $discount, $items);

    my $total = $subtotal;

    # Add order discounts
    $total = apply_discount( $total, $discount );

    # Add shippings
    $total = apply_charges( $total, $shipping );

    # Add taxes
    $total = apply_charges( $total, $taxes );

    $self->{cart}{total}    = $total;

    $self->{cart}{dirty}    = 0;
}

sub apply_charges {
    my ( $amount, $charges ) = @_;

    if ( ref $charges ) {
	foreach my $c ( @$charges ) {
	    $amount += $c;
	}
    } else {
	$amount += $charges;
    }

    $amount;
}

sub apply_discount {
    my ($amount, $discount) = @_;

    if ( ref $discount ) {
	foreach my $d ( @$discount ) {
	    $amount -= $discount;
	}
    } else {
	$amount -= $discount;
    }

    $amount;
}

1;

__END__