#------------------------------------------------------------
# Copyright (C) 2006 RoyaltyShare, Inc.   All Rights Reserved
#------------------------------------------------------------
package RPS::Product::ProductDistribution;

use strict;
use warnings;
use Carp;

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

use lib '/app/tools/distribution/lib';
use Distribution::DB::Item::ProductDistribution;

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

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

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

    $self->{_service_id} = $args{service_id};
    $self->{_product_id} = $args{product_id};

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

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

    if ( $args{product_distribution_id} ) {
        $dbItem = Distribution::DB::Item::ProductDistribution->Lookup(%args);
    } elsif ( $args{service_id} && $args{product_id} ) {
        $dbItem = Distribution::DB::Item::ProductDistribution->Search(%args);
        return $self->_initProperties( {} ) unless ($dbItem);
    } else {
        return undef;
    }

    return $self->_initFromDBItem($dbItem);
}

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

    my %properties = (
        product_distribution_id => $dbItem->product_distribution_id,
        product_id              => $dbItem->product_id,
        service_id              => $dbItem->service_id,
        distribution_process_id => $dbItem->distribution_process_id,
        third_party             => $dbItem->third_party,
        denied                  => $dbItem->denied,
        invalid                 => $dbItem->invalid,
        delivery_date           => $dbItem->delivery_date,
        created_by              => $dbItem->created_by,
        created_date            => $dbItem->date_created,
        modified_date           => $dbItem->date_modified,

        album_id => $dbItem->{asset_id},
    );

    return $self->_initProperties( \%properties );
}

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

    $self->{ProductDistribtionID} = Common::FormObject::Scalar->new( value => $prop->{product_distribution_id}, readOnly => 1 );
    $self->{ProductID}            = Common::FormObject::Scalar->new( value => $prop->{product_id},              readOnly => 1 );
    $self->{ServiceID}            = Common::FormObject::Scalar->new( value => $prop->{service_id},              readOnly => 1 );
    $self->{DistribtionProcessID} = Common::FormObject::Scalar->new( value => $prop->{distribution_process_id} );
    $self->{ThirdParty}           = Common::FormObject::Scalar->new( value => $prop->{ThirdParty} );
    $self->{Invalid}              = Common::FormObject::Scalar->new( value => $prop->{invalid} );
    $self->{Denied} = Common::FormObject::Scalar::String->new( value => $prop->{denied} );

    $self->{CreatedBy} = Common::FormObject::Scalar::String->new( value => $prop->{create_by} );

    $self->{DeliveryDate} = Common::FormObject::Scalar::DateTime->new( value => $prop->{delivery_date}, readOnly => 1 );
    $self->{CreatedDate}  = Common::FormObject::Scalar::DateTime->new( value => $prop->{date_created},  readOnly => 1 );
    $self->{ModifiedDate} = Common::FormObject::Scalar::DateTime->new( value => $prop->{date_modified}, readOnly => 1 );

    $self->{AlbumID} = Common::FormObject::Scalar->new( value => $prop->{album_id}, readOnly => 1 );

    return $self;
}

sub toggleStagedDistribution {
    my $self   = shift;
    my $toggle = shift;

    assert($self);
    assert( defined($toggle) );

    if ( !$toggle ) {
        $self->stageDistribution();
    } else {
        $self->clearDistribution();
    }
}

sub stageDistribution {
    my $self = shift;

    assert($self);
    assert( $self->{_product_id} );
    assert( $self->{_service_id} );

    # If we can't clear out the old record then we should be able to add a new
    # one.
    return undef unless ( $self->clearDistribution() );

    $self->forceStageDistribution();

    return 1;
}

sub forceStageDistribution {
    my $self = shift;

    assert($self);
    assert( $self->{_product_id} );
    assert( $self->{_service_id} );

    my $pd_record = Distribution::DB::Item::ProductDistribution->Create(
        product_id => $self->{_product_id},
        service_id => $self->{_service_id}
    );
    $pd_record->save();

    return 1;
}

sub clearDistribution {
    my $self = shift;
    assert($self);

    #  service_id and product_id are required
    return 1 unless ( $self->ProductID && $self->ServiceID );

    #  If we have already distributed then we can't delete
    return undef if ( $self->DeliveryDate || $self->DistribtionProcessID );

    Distribution::DB::Item::ProductDistribution->ClearStagedDistribution(
        product_id => $self->ProductID,
        service_id => $self->ServiceID
    );

    return 1;
}

sub invalidateDistribution {
    my $self = shift;

    assert($self);
    assert( $self->{_product_id} );
    assert( $self->{_service_id} );

    my $pd_record = Distribution::DB::Item::ProductDistribution->Lookup(
        product_id => $self->{_product_id},
        service_id => $self->{_service_id},
        invalid    => 0
    );

    if ($pd_record) {
        $pd_record->invalid(1);
        $pd_record->save();
    }

    return 1;
}

1;