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

use strict;

#use warnings;

use Data::Dumper;

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

use lib '/app/tools/rps/lib';
use RPS::DB::Item::Product;
use RPS::DB::Item::Album;
use RPS::DB::Item::Genre;
use RPS::DB::Item::ProductTrack;
use RPS::DB::Item::Track;
use RPS::DB::Item::Artist;
use RPS::DB::Item::Master;
use RPS::DB::Item::Song;
use RPS::DB::Item::Label;
use RPS::DB::Item::ProductDigital;
use RPS::DB::Item::ServicePriceTier;
use RPS::Catalog::TrackAdditionalArtistHash;
use RPS::Catalog::AlbumAdditionalArtistHash;

use lib '/app/tools/distribution/lib';
use Distribution::DB::Item::DistributionJob;
use Distribution::DB::Item::ProductDistribution;
use Distribution::Job::Parameters;
use Distribution::DB::Item::ProductServiceID;
use Distribution::DB::Item::ProductTrackServiceID;

use lib '/app/tools/mediaserve/lib';
use MediaServe::Server;
use MediaServe::DB::Item::ProductTrackFile;
use MediaServe::DB::Item::AlbumFile;

sub CreateDistributionParameters {
    my ($distProcessID) = @_;
    assert($distProcessID);

    # !!! Not sure this is the correct ID...
    # !!! Not even sure if this is really the interface we'll need.
    # !!! We will need a 'job' class, perhaps that can abstract away everything?
    #

    # This is just a quick sanity check.
    #
    my $jobData = Distribution::DB::Item::DistributionProcess->Lookup( distribution_process_id => $distProcessID );
    die "ERROR - distribution job id $distProcessID does not exist" unless $jobData;

    # So, there should just be _1_ service id.  I'm going to keep track of this, and
    # freak out if it changes...
    #
    my $serviceID;

    my @albums;

    # So, we're going to iterate over all the 'product_distribution' records with that dist_job_id.
    #
    my $productDistCollection = Distribution::DB::Item::ProductDistribution->GetAllByDistributionProcessID($distProcessID);
    while ( my $productDist = $productDistCollection->next() ) {
        if ( !defined $serviceID ) {
            $serviceID = $productDist->service_id;
        } elsif ( $productDist->service_id != $serviceID ) {
            die "ERROR - expected service_id $serviceID in this product_distribution record: " . Dumper($productDist);
        }

        my $productID = $productDist->product_id;
        my $product = RPS::DB::Item::Product->Lookup( product_id => $productID );
        assert( $product->product_type_id == RPS::DB::Item::Product::kProductTypeDigital );

        #
        # Quick hack to add apple vendor id.  This should be removed when more services
        # start using custom IDs
        #
        my $appleAlbumID;
        if ( $serviceID == 11 ) {
            my $productServiceID =
              Distribution::DB::Item::ProductServiceID->Lookup( service_id => $serviceID, product_id => $product->product_id );
            $appleAlbumID = $productServiceID->code() if ($productServiceID);
        }

        # Build the territory list
        #
        my $productDigital = RPS::DB::Item::ProductDigital->Lookup( product_id => $productID );
        assert($productDigital);
        my @territoryList;
        my $territories = $productDigital->territories_list;
        if ($territories) {
            @territoryList = split( ' ', $territories );
        }
        my $territoryAllowedFlag = ( RPS::DB::Item::ProductDigital::kTerritoriesFlagAllow eq $productDigital->territories_flag ? 1 : 0 );

        my $albumID = $product->asset_id;
        my $album = RPS::DB::Item::Album->Lookup( album_id => $albumID );

        my $label = RPS::DB::Item::Label->Lookup( label_id => $album->label_id );

        my $albumExplicitFlag = RPS::DB::Item::Album->GetAlbumParentalAdvisory($albumID);
        if ( 'E' eq $albumExplicitFlag ) {
            $albumExplicitFlag = 'explicit';
        } elsif ( 'C' eq $albumExplicitFlag ) {
            $albumExplicitFlag = 'clean';
        } else {
            $albumExplicitFlag = 'none';
        }

        # Let's derive the correct genre - we'll force all the tracks to be this genre too.
        #
        my $isComposerRequired;
        my @genreNames;
        if ( $album->genre_primary_id ) {
            my $genre = RPS::DB::Item::Genre->Lookup( genre_id => $album->genre_primary_id );

            # !!! Not all albums have this yet.
            #
            if ($genre) {
                push @genreNames, $genre->genre_name;

                $isComposerRequired = RPS::DB::Item::Genre::isComposerRequired( genre_id => $album->genre_primary_id );
            }
        }

        my @genreNames_secondary;
        if ( $album->genre_secondary_id ) {
            my $genre = RPS::DB::Item::Genre->Lookup( genre_id => $album->genre_secondary_id );

            # !!! Not all albums have this yet.
            #
            if ($genre) {
                push @genreNames_secondary, $genre->genre_name;

                if ( RPS::DB::Item::Genre::isComposerRequired( genre_id => $album->genre_secondary_id ) ) {
                    $isComposerRequired = 1;
                }
            }
        }

        # Need the 'volume' data, from the product_track table.
        #
        # !!! Going to add a new accessor to include some order_by args
        my $productTracks = RPS::DB::Item::ProductTrack->GetTracksByProductID( $productID, "disc_number, disc_track" );

        my @volumes;

        # So, we'll iterate over the product_tracks, and assemble everything we need to know.
        #
        while ( my $productTrack = $productTracks->next() ) {
            my $trackID = $productTrack->track_id;

            # If this is a bonus track, make sure it belongs at this service.
            #
            if ( $productTrack->is_bonus_track ) {
                my $bonusTrackData =
                  RPS::DB::Item::BonusTrack->Lookup( product_id => $productID, track_id => $trackID, service_id => $serviceID );
                if ( !$bonusTrackData ) {
                    next;
                }
            }
            my $discNum    = $productTrack->disc_number;
            my $volumeData = $volumes[ $discNum - 1 ];
            if ( !defined $volumeData ) {

                # This is a new volume entry.
                # Need id, total length, and the list of tracks.
                #
                $volumeData             = {};
                $volumeData->{id}       = $discNum;
                $volumeData->{sequence} = $discNum;

                # We'll calculate this later.
                #
                $volumeData->{'total-length'} = 0;

                $volumeData->{track} = [];

                push @volumes, $volumeData;
            }

            # Fill in the track info.
            # We'll need track and master data.
            #
            my $tracks    = $volumeData->{track};
            my $trackData = {};

            my $track = RPS::DB::Item::Track->Lookup( track_id => $productTrack->track_id );
            my $master = RPS::DB::Item::Master->Lookup( master_id => $track->master_id );
            my $song = RPS::DB::Item::Song->Lookup( song_id => $master->song_id );
            my $trackArtist = RPS::DB::Item::Artist->Lookup( artist_id => $track->artist_id );

            my $composerName;
            if ( $song->composer_id ) {
                my $composer = RPS::DB::Item::Composer->Lookup( composer_id => $song->composer_id );
                if ($composer) {
                    $composerName = $composer->name;
                }
            }

            my $trackExplicitFlag = $track->parental_advisory;
            if ( 'E' eq $trackExplicitFlag ) {
                $trackExplicitFlag = 'explicit';
            } elsif ( 'C' eq $trackExplicitFlag ) {
                $trackExplicitFlag = 'clean';
            } else {
                $trackExplicitFlag = 'none';
            }

            #
            # Quick hack to add apple vendor id.  This should be removed when more services
            # start using custom IDs
            #
            my $appleTrackID;
            if ( $serviceID == 11 ) {
                my $productTrackServiceID = Distribution::DB::Item::ProductTrackServiceID->Lookup(
                    service_id       => $serviceID,
                    product_track_id => $productTrack->product_track_id
                );
                $appleTrackID = $productTrackServiceID->code() if ($productTrackServiceID);
            }

            $trackData->{'is-explicit'}    = $trackExplicitFlag;
            $trackData->{'sell-unbundled'} = 'yes';
            $trackData->{'title'}          = $track->title;
            $trackData->{'isrc'}           = $master->isrc;
            $trackData->{'sequence'}       = $productTrack->disc_track;
            $trackData->{'length'}         = $master->duration;           # We'll translate this into stupid mode later.

            $trackData->{'genre'} = \@genreNames;

            $trackData->{'label'}          = $label->label_name;
            $trackData->{'cline'}          = $album->c_line;
            $trackData->{'pline'}          = $album->p_line;
            $trackData->{'display-artist'} = $trackArtist->name;
            $trackData->{'composer'}       = $composerName;
            $trackData->{'apple-track-id'} = $appleTrackID;
            $trackData->{'album-only'}     = $productTrack->album_only;

            $trackData->{'additional-artists'} = getAdditionalArtists( track_id => $trackID, service_id => $serviceID );

            # Need to fetch the media_file_id that corresponds to this track's audio.
            #
            my $productTrackFile = MediaServe::DB::Item::ProductTrackFile->Lookup(
                product_track_id => $productTrack->product_track_id,
                file_type        => MediaServe::DB::Item::ProductTrackFile::kFileTypeOriginal,
            );

            my $mediaFileID = $productTrackFile->media_file_id;
            my $audioPath =
              MediaServe::Server::GetAudioPath( mediaFileID => $mediaFileID, clientID => Common::RSApp::GetClientID(), type => 'linux' );
            my $audioWinPath =
              MediaServe::Server::GetAudioPath( mediaFileID => $mediaFileID, clientID => Common::RSApp::GetClientID(), type => 'windows' );
            $trackData->{'audio-path-linux'}   = $audioPath;
            $trackData->{'audio-path-windows'} = $audioWinPath;

            push @{$tracks}, $trackData;
        }

        my $price_tier = RPS::DB::Item::ServicePriceTier->LookupByProduct( service_id => $serviceID, product_id => $product->product_id );
        my $default_price_tier = RPS::DB::Item::ServicePriceTier->Lookup( service_id => $serviceID, default_tier => 1 );

        my $albumData = {};
        $albumData->{volume}           = \@volumes;
        $albumData->{'sell-bundled'}   = 'yes';
        $albumData->{'is-explicit'}    = $albumExplicitFlag;
        $albumData->{upc}              = $product->upc_ean;
        $albumData->{title}            = $album->title;
        $albumData->{'catalog-number'} = $album->catalog_number;
        $albumData->{'label'}          = $label->label_name;
        $albumData->{'release-date'}   = $product->release_date;
        $albumData->{'wholesale-price-tier'} = $price_tier->tier_code         if ($price_tier);
        $albumData->{'default-price-tier'}   = $default_price_tier->tier_code if ($default_price_tier);
        $albumData->{'cline'}                = $album->c_line;
        $albumData->{'pline'}                = $album->p_line;
        $albumData->{'genre'}                = \@genreNames;
        $albumData->{'genre-id'}             = $album->genre_primary_id;
        $albumData->{'genre-secondary'}      = \@genreNames_secondary;
        $albumData->{'genre-secondary-id'}   = $album->genre_secondary_id;
        $albumData->{'apple-album-id'}       = $appleAlbumID;

        $albumData->{'is-classical'}            = $isComposerRequired;
        $albumData->{'product-distribution-id'} = $productDist->product_distribution_id;

        my $albumArtist = RPS::DB::Item::Artist->Lookup( artist_id => $album->artist_id );
        $albumData->{'display-artist'} = $albumArtist->name;

        $albumData->{'additional-artists'} = getAdditionalArtists( album_id => $albumID, service_id => $serviceID );

        # Get the image path
        #
        my $imageFile = MediaServe::DB::Item::AlbumFile->Lookup(
            album_id  => $album->album_id,
            file_type => MediaServe::DB::Item::AlbumFile::kFileTypeDistribution
        );
        assert( $imageFile, "Failed to find album image. Album ID: " . $album->album_id );

        my $mediaFile = MediaServe::DB::Item::MediaFile->Lookup( media_file_id => $imageFile->media_file_id );
        my $imagePath = MediaServe::Server::GetImagePath(
            mediaFileID => $imageFile->media_file_id,
            clientID    => Common::RSApp::GetClientID(),
            type        => 'linux'
        );
        my $imageWinPath = MediaServe::Server::GetImagePath(
            mediaFileID => $imageFile->media_file_id,
            clientID    => Common::RSApp::GetClientID(),
            type        => 'windows'
        );
        $albumData->{'image-file'}         = $mediaFile->filename;
        $albumData->{'image-path-linux'}   = $imagePath;
        $albumData->{'image-path-windows'} = $imageWinPath;

        # Build the territories XML
        #
        if ( scalar @territoryList ) {
            if ($territoryAllowedFlag) {
                $albumData->{'territories'}{'allowed'} = \@territoryList;
            } else {
                $albumData->{'territories'}{'denied'} = \@territoryList;
            }
        } else {
            $albumData->{'territories'} = undef;
        }

        push @albums, $albumData;
    }

    my %paramHash;
    $paramHash{album} = \@albums;

    # Now, we instantiate the XML object.
    #
    my $paramObj = Distribution::Job::Parameters->new( hash => \%paramHash );
    return $paramObj;
}

sub getAdditionalArtists {
    my %args = @_;
    my $hash;
    my $artistHash;
    my @result;

    my $serviceID = $args{service_id};

    assert($serviceID);

    if ( $args{album_id} ) {
        $artistHash = new RPS::Catalog::AlbumAdditionalArtistHash( albumID => $args{album_id}, serviceID => $serviceID );
    } elsif ( $args{track_id} ) {
        $artistHash = new RPS::Catalog::TrackAdditionalArtistHash( trackID => $args{track_id}, serviceID => $serviceID );
    }

    return unless ($artistHash);

    foreach my $key ( @{ $artistHash->getKeys() } ) {
        my $artist = $artistHash->getHash()->{$key};
        my $dbItem = RPS::DB::Item::ArtistRole->LookupWithMap( service_role => $artist->{Role}->Role(), service_id => $serviceID );

        $hash                               = {};
        $hash->{'artist-id'}                = $artist->ArtistID;
        $hash->{'display-artist'}           = $artist->Name;
        $hash->{'role'}->{'artist-role-id'} = $artist->{Role}->ArtistRoleID();
        $hash->{'role'}->{'name'}           = $artist->{Role}->Role();
        $hash->{'role'}->{'map'} = $dbItem->{service_role} if ($dbItem);

        push( @result, $hash );
    }

    return @result ? \@result : undef;
}

1;