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


# !!! This class exists because of structural problem we have in our current catalog/track/product XML objects.
# !!! So, basically, this is a 'chimera' class that includes stuff that would normally be in Album/TrackList/Track and
# !!! stuff that would appear in Product/TrackList/Track.
#
# !!! In other words, this is sort of a hack.
#
use strict;
use warnings;

use Data::Dumper;

use lib '/app/tools/rps/lib';
#use RPS::DB::Item::ProductTrack;
use RPS::DB::Item::Track;
use RPS::DB::Item::User;
use RPS::Track::Track;

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


sub _tagName
{
    return 'Track';
}


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

    return undef unless defined $args{albumID};

    $self->{_origAlbumID} = $args{albumID};
    my $collection = RPS::DB::Item::Track->GetTracksByAlbumID($args{albumID});
    return $collection;
}


sub _keyMethodName
{
    return 'TrackID';
}


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

    return RPS::Track::Track->new(albumID => $self->{_origAlbumID});
}


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

    return RPS::Track::Track->new(_dbItem => $dbItem);
}



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


    # Stash the albumID away for later
    #
    $self->{_albumID} = $args{albumID};

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

    return $self;
}


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

    # Present the tracks sorted by track_order
    # !!! Might want to have sorting by disc_num, disc_track, track_order
    #
    my @keys = sort { $self->{Track}{$a}->TrackOrder() <=> $self->{Track}{$b}->TrackOrder() } keys %{$self->{Track}};
    return \@keys;

}


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

    my @keys = sort
    {
        my $r = $self->{Track}{$a}->DiscNumber() <=> $self->{Track}{$b}->DiscNumber();
        if (0 == $r)
        {
            $r = $self->{Track}{$a}->DiscTrack() <=> $self->{Track}{$b}->DiscTrack();
        }
        return $r;
    } keys %{$self->{Track}};

    return \@keys;
}

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

	return $self->{Track};
}

sub validate
{
    my $self = shift;
    my %isrc;

    my $valid = $self->SUPER::validate(@_);

    foreach my $trackID ( keys(%{$self->{Track}}) ) {
        my $track  = $self->{Track}->{$trackID};
        my $master = $track->{Master};

        next unless( $master );

        Common::Log::Debug( "MASTER: " . $master->ISRC );
        if( $master->ISRC() && $isrc{$master->ISRC()} ) {
            $master->{ISRC}->setError(Common::FormObject::kErrDuplicateISRC);
            return 0;
        } else {
            $isrc{$master->ISRC} = 1;
        }
    }

    return $valid;
}


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

    # Create the album tracks first, then create the track products
    #
    my $keys = $self->getKeys();
    my $trackOrder = 1;
    foreach my $trackID (@$keys)
    {
        my $trackObj = $self->{Track}{$trackID};
        $trackObj->save($albumID, \$trackOrder);
    }
}


1;