#------------------------------------------------------------
# Copyright (C) 2006 RoyaltyShare, Inc.   All Rights Reserved
#------------------------------------------------------------
package RPS::Catalog::ErrorReport;
use strict;
use warnings;

use Data::Dumper;

use lib '/app/tools/rps/lib';
use RPS::Catalog::AlbumError;
use RPS::Track::TrackList;
use RPS::Product::Product;
use RPS::DB::Item::Product;

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

use base 'Common::FormObject';

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

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

    $self->_propertiesFromValidation(%args);

    return $self;
}

sub _propertiesFromValidation
{
    my $self = shift;
    my %args = @_;
    assert($self);

    $self->{Album}             = new RPS::Catalog::AlbumError( albumID => $args{albumID} );
    $self->{AlbumErrors}       = $self->_validateAlbumData( %args );
    $self->{ProductErrors}     = $self->_validateProduct( %args );
    $self->{Assets}            = $self->_validateAssets( %args );

    ( $self->{SingleTrackErrors}, $self->{MultiTrackErrors} ) = $self->_validateTrack( %args );
}

sub _validateAlbumData
{
    my $self = shift;
    my %args = @_;
	my $errors = {};

    my $harness = new Metadata::Validate::Harness( failState => Validate::kStatusOK, ignoreCurrentData => 1 );
    my $album   = new RPS::Catalog::AlbumError( albumID => $args{albumID} );
    $album->_validateMetadata( metadataValidator => $harness );

	foreach ( keys %$album ) {
		next unless( /^[A-Z]/ && ref($album->{$_}) );

        my $albumErrors = $album->{$_};
		$errors->{$_} = $album->{$_}->{_xmlParams}->{emsg} if( $album->{$_}->{_xmlParams}->{emsg} );
	}

    return $errors;
}

sub _validateTrack
{
    my $self = shift;
    my %args = @_;

    my $multiErrors = {};
    my $singleErrors = {};
	my $trackErrors = {};
	my $err;
	my $s_err;

    my $harness = new Metadata::Validate::Harness( failState => Validate::kStatusOK, ignoreCurrentData => 1 );
    my $oTracks = new RPS::Track::TrackList( %args );
	my $tracks = $oTracks->getTracks();
    my $track;

    my @singleTracksWithErrors;

    foreach $track ( @$tracks ) {
		$track->_validateMetadata( metadataValidator => $harness );

	    ###
        #   Multi-track edit errors
        ###
        if( $track->{Master} && $track->{Master}->{ISRC} ) {
            $err = $track->{Master}->{ISRC}->{_xmlParams}->{emsg};

            unless( $err ) {
                $err = "Duplicate detected" if( $track->{Master}->{ISRC}->{_xmlParams}->{e} );
            }

			$multiErrors->{ISRC}->{$err} = 1 if( $err );
		}

		if( $track->{Title} ) {
            $err = $track->{Title}->{_xmlParams}->{emsg};
			$multiErrors->{Title}->{$err} = 1 if( $err );
		}

		if( $track->{ParentalAdvisory} ) {
            $err = $track->{ParentalAdvisory}->{_xmlParams}->{emsg};
			$multiErrors->{ParentalAdvisory}->{$err} = 1 if( $err );
		}

		if( $track->{MediaType} ) {
            $err = $track->{MediaType}->{_xmlParams}->{emsg};
			$multiErrors->{MediaType}->{$err} = 1 if( $err );
		}

		if( $track->{Length} ) {
            $err = $track->{Length}->{_xmlParams}->{emsg};
			$multiErrors->{Length}->{$err} = 1 if( $err );
		}

		if( $track->{ArtistName} ) {
            $err = $track->{ArtistName}->{_xmlParams}->{emsg};
			$multiErrors->{ArtistName}->{$err} = 1 if( $err );
		}

		if( $track->{TrackOrder} ) {
            $err = $track->{TrackOrder}->{_xmlParams}->{emsg};
			$multiErrors->{TrackOrder}->{$err} = 1 if( $err );
		}


        ###
        #   Single-track edit errors
        ###
        $s_err = undef;
        my $s_err_found = undef;


        if( $track->{Master} && $track->{Master}->{Title} ) {
            $s_err = $track->{Master}->{Title}->{_xmlParams}->{emsg};
            $s_err_found = 1 if( $s_err );
			$singleErrors->{Title}->{$s_err} = 1 if( $s_err );
		}

        if( $track->{Master} && $track->{Master}->{ArtistName} ) {
            $s_err = $track->{Master}->{ArtistName}->{_xmlParams}->{emsg};
            $s_err_found = 1 if( $s_err );
			$singleErrors->{ArtistName}->{$s_err} = 1 if( $s_err );
		}

        if( $track->{Master} && $track->{Master}->{DateRecorded} ) {
            $s_err = $track->{Master}->{DateRecorded}->{_xmlParams}->{emsg};
            $s_err_found = 1 if( $s_err );
			$singleErrors->{DateRecorded}->{$s_err} = 1 if( $s_err );
		}

        my $song = $track->{Master}->{Song} if( $track->{Master} );

        if( $song ) {

            if( $song->{Title} ) {
                $s_err = $song->{Title}->{_xmlParams}->{emsg};
                $s_err_found = 1 if( $s_err );
			    $singleErrors->{SongTitle}->{$s_err} = 1 if( $s_err );
		    }

            if( $song->{ComposerName} ) {
                $s_err = $song->{ComposerName}->{_xmlParams}->{emsg};
                $s_err_found = 1 if( $s_err );
			    $singleErrors->{Composer}->{$s_err} = 1 if( $s_err );
		    }

        }


        $trackErrors->{$track->TrackOrder} = 1 if( $s_err_found );
        push( @singleTracksWithErrors, $track) if( $s_err_found );
	}

	my $multiResult;
	my $singleResult;

	foreach ( keys( %$multiErrors ) ) {
        my $msgs = join( ",", keys( %{$multiErrors->{$_}} ) );
		$multiResult->{$_} = $msgs;
	}

    foreach ( keys( %$singleErrors ) ) {
        my $msgs = join( ",", keys( %{$singleErrors->{$_}} ) );
		$singleResult->{$_} = $msgs;
    }

    if( $singleResult ) {
        my @tracks = sort { $a <=> $b } keys(%$trackErrors);
        #$singleResult->{Tracks}->{TrackOrder} = \@tracks;
        $singleResult->{Tracks}->{Track} = \@singleTracksWithErrors;
    }

	return ($singleResult, $multiResult);
}

sub _validateProduct
{
    my $self = shift;
    my %args = @_;
	my $errors = {};

    my $dbProduct = RPS::DB::Item::Product->GetDigitalAlbumProduct( $args{albumID} );
    my $harness   = new Metadata::Validate::Harness( failState => Validate::kStatusOK, ignoreCurrentData => 1 );

    my $product   = new RPS::Product::Product( _dbItem => $dbProduct );
    $product->validate( metadataValidator => $harness );

    $errors = { Product => "no digital product" } unless( $dbProduct );

	foreach ( keys %$product ) {
		next unless( /^[A-Z]/ && ref($product->{$_}) );

		$errors->{$_} = $product->{$_}->{_xmlParams}->{emsg} if( $product->{$_}->{_xmlParams}->{emsg} );

        if( $_ eq 'UPC' ) {
            $errors->{$_} = "UPC Required"
                unless( $product->UPC );

            $errors->{$_} = "Invalid UPC"
                unless( Validate::Util::is_valid_upc_or_ean( $product->UPC ) );
        }

	}

    if( $product->TrackList ) {
        foreach my $track ( @{$product->TrackList->getTracks} ) {
            foreach my $field ( qw( DiscNumber DiscTrack ) ) {
                $errors->{$field}  = $track->{$field}->{_xmlParams}->{emsg}
                    if( $track->{$field}->{_xmlParams}->{emsg} );
            }
        }
    }

    $errors->{Product} = $product if( keys(%$errors) );

    return $errors;
}

sub _validateAssets
{
    my $self = shift;
    my %args = @_;

    my $result = {};

    $result->{Image} = $self->_validateImageAssets( $args{albumID} );
    $result->{Audio} = $self->_validateAudioAssets( $args{albumID} );

    return $result;
}


sub _validateImageAssets {
    my $self = shift;
    my $album_id = shift;
    my $client_id = Common::RSApp::GetClientID();
    my $path;

    assert( $album_id, "Album ID Required" );

    my $image_assets = MediaServe::DB::Item::AlbumFile->Search( album_id => $album_id );

    return ( "missing" ) unless( $image_assets->hasNext() );

    while( $image_assets->hasNext ) {
        my $asset = $image_assets->next();
        (undef, $path) = MediaServe::Server::GetImagePath( clientID => $client_id,
                                                           mediaFileID => $asset->media_file_id );

        if( ! -f $path ) {
            Common::Log::Print( "Does not exist: $path" );
            return "processing";
        }
    }

    return undef;
}

sub _validateAudioAssets {
    my $self = shift;
    my $album_id = shift;
    my $client_id = Common::RSApp::GetClientID();
    my $path;

    assert( $album_id, "Album ID Required" );

    my $audio_assets = MediaServe::DB::Item::ProductTrackFile->Search( album_id => $album_id );
    return ( "missing" ) unless( $audio_assets->hasNext() );

    while( $audio_assets->hasNext ) {
        my $asset = $audio_assets->next();
        (undef, $path) = MediaServe::Server::GetAudioPath( clientID    => $client_id,
                                                           mediaFileID => $asset->media_file_id );
        if( ! -f $path ) {
            Common::Log::Print( "Does not exist: $path" );
            return ( "processing" );
            return undef;
        }
    }

	my $collection = RPS::DB::Item::Album->SearchNoAudio( album_id => $album_id );

    if( $collection->hasNext() ) {
        return "missing";
    }

    return MediaServe::DB::Item::ProductTrackFile::hasUnmatchedAudio( album_id => $album_id ) ? "unmatched" : undef;
}

1;