#------------------------------------------------------------
# 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;