#---------------------------------------------------------------
# ____                   _ _         ____  _
#|  _ \ ___  _   _  __ _| | |_ _   _/ ___|| |__   __ _ _ __ ___
#| |_) / _ \| | | |/ _` | | __| | | \___ \| '_ \ / _` | '__/ _ \
#|  _ < (_) | |_| | (_| | | |_| |_| |___) | | | | (_| | | |  __/
#|_| \_\___/ \__, |\__,_|_|\__|\__, |____/|_| |_|\__,_|_|  \___|
#            |___/             |___/
#
# Copyright (C) 2011 RoyaltyShare, Inc.   All Rights Reserved
#---------------------------------------------------------------

package RPS::Report::Dynamic::Catalog::Albums;

use strict;
use warnings;

use lib '/app/tools/common/lib';
use lib '/app/tools/report/lib';
use lib '/app/tools/rps/lib';
use lib '/app/tools/appuser/lib';

use Common::Log;
use Common::Assert;
use File::Path;
use AppUser::DB::Item::AccessLevel;
use Text::CSV::Encoded;
use Report::Dynamic::Parameters;
use RPS::DB::Item::Genre;
use RPS::DB::Item::DynamicReport::Catalog::Albums;
use RPS::DB::Item::ArtistRole;
use RPS::DB::Item::Artist;
use RPS::DB::Item::AlbumAdditionalArtist;

use base 'RPS::Report::Dynamic::Catalog::Base';


sub Type    { 'Albums Only'; }
sub FilenameType { 'Albums' }

# defined at the end of this file
#
sub _ParamClass { 'RPS::Report::Dynamic::Catalog::Albums::Parameters'; }


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

    return
    [
        { 
            header => { 
                name => 'album-title' 
            },             
            column => { 
                field => 'title' 
            } 
        },
        { 
            header => { 
                name => 'primary-album-artist', 
            },   
            column => { 
                field => 'primary_artist', 
            } 
        },
        { 
            header => { 
                name => 'secondary-album-artists', 
            }, 
            column => { 
#                field => 'secondary_artist', 
                field => 'album_id', 
                method => '_fetchAlbumSecondaryArtists',
            } 
        },
        { 
            header => { 
                name => 'label-name', 
            },       
            column => { 
                field => 'label_name', 
            } 
        },
        { 
            header => { 
                name => 'catalog-no', 
            },   
            column => { 
                field => 'catalog_number', 
            } 
        },
        { 
            header => { 
                name => 'client-album-id', 
            },  
            column => { 
                field => 'client_album_id', 
            } 
        },
        { 
            header => { 
                name => 'primary-genre', 
            },    
            column => { 
                field => 'genre_primary_id', 
                method => '_idToGenre',
            } 
        },
        { 
            header => { 
                name => 'secondary-genre', 
            },  
            column => { 
                field => 'genre_secondary_id', 
                method => '_idToGenre',
            } 
        },
        { 
            header => { 
                name => 'c-line', 
            },           
            column => { 
                field => 'c_line', 
            } 
        },
        { 
            header => { 
                name => 'p-line', 
            },           
            column => { 
                field => 'p_line', 
            } 
        },
        { 
            header => { 
                name => 'album-status', 
            },           
            column => { 
                field => 'status', 
            } 
        },
        { 
            header => { 
                name => 'album-custom-1', 
            },         
            column => { 
                field => 'custom_1', 
            } 
        },
        { 
            header => { 
                name => 'album-custom-2', 
            },         
            column => { 
                field => 'custom_2', 
            } 
        },
        { 
            header => { 
                name => 'album-custom-3', 
            },         
            column => { 
                field => 'custom_3', 
            } 
        },
        { 
            header => { 
                name => 'album-date-created', 
            },     
            column => { 
                field => 'date_created', 
                excel => 'date:Y-M-D',
                method => '_formatDate',
            } 
        },
        { 
            header => { 
                name => 'album-created-by', 
            },       
            column => { 
                field => 'created_by', 
                method => '_userIDToUserName',
            } 
        },
        { 
            header => { 
                name => 'album-date-modified', 
            },    
            column => { 
                field => 'date_modified', 
                excel => 'date:Y-M-D',
                method => '_formatDate',
            } 
        },
        { 
            header => { 
                name => 'album-modified-by', 
            },      
            column => { 
                field => 'modified_by', 
                method => '_userIDToUserName',
            } 
        },
        { 
            header => { 
                name => 'rs-album-id', 
            },         
            column => { 
                field => 'album_id', 
            } 
        },
    ];
}


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

    # Dereference the parameters, see if we're constraining
    # the query by date somehow.
    #
    # !!! Don't want to just pass the CGI parameter straight through - That could
    # !!! cause problems...
    #
    my $dateType;
    my $dateTypeParam = $self->parameters()->{Criteria}->DateType();
    if ($dateTypeParam)
    {
        if ('Date Created' eq $dateTypeParam)
        {
            $dateType = 'date_created';
        }
        elsif ('Date Modified' eq $dateTypeParam)
        {
            $dateType = 'date_modified';
        }
    }

    return RPS::DB::Item::DynamicReport::Catalog::Albums->ReportQuery
    (
        dateType => $dateType,
        startDate => $self->parameters()->{Criteria}->StartDate(),
        endDate => $self->parameters()->{Criteria}->EndDate(),
    );
}


# Cache the genres
#
my $gGenreCache;

sub _idToGenre
{
    my ($self, %args) = @_;
    my $rowItem = $args{row};
    my $fieldName = $args{field};

    my $id = $rowItem->$fieldName();

    my $genreName;
    if ($id)
    {
        if (! $gGenreCache)
        {
            $gGenreCache = {};
            my $allGenres = RPS::DB::Item::Genre->GetAll();
            while (my $genre = $allGenres->next())
            {
                $gGenreCache->{ $genre->genre_id() } = $genre->genre_name();
            }
        }

        $genreName = $gGenreCache->{$id};
    }

    return $genreName;
}


# Need to cache the artist roles.
# Not a big table, but it lives in RSCOMMON, and it's going to be expensive
# to keep going back there all the time.
# NOTE that this is not a 'regular' column filter method that takes a row item and stuff.
# 
#
sub _artistRoleFromID
{
    my ($self, $id) = @_;

    my $role;

    if ($id)
    {
        if (! $self->{_ArtistRoleCache})
        {
            $self->{_ArtistRoleCache} = {};

            my $allRoles = RPS::DB::Item::ArtistRole->GetAll();
            while (my $data = $allRoles->next())
            {
                $self->{_ArtistRoleCache}->{ $data->artist_role_id() } = $data->role();
            }
        }

        $role = $self->{_ArtistRoleCache}->{$id};
    }

    return $role;
}


# Another internal cache.
# 
sub _artistFromID
{
    my ($self, $id) = @_;

    my $name;

    if ($id)
    {
        if (! $self->{_ArtistCache})
        {
            $self->{_ArtistCache} = {};

            my $all = RPS::DB::Item::Artist->GetAll();
            while (my $data = $all->next())
            {
                $self->{_ArtistCache}->{ $data->artist_id() } = $data->name();
            }
        }

        $name = $self->{_ArtistCache}->{$id};
    }

    return $name;
}


my $gLastAlbumSecondaryArtists;
my $gLastAlbumSecondaryArtistsID;
sub _fetchAlbumSecondaryArtists
{
    my ($self, %args) = @_;
    my $rowItem = $args{row};
    my $fieldName = $args{field};

    my $id = $rowItem->$fieldName();

    my $outString;
    if ($id)
    {
        # Fetch all the secondary album artists (if there are any).
        #
        # Note that I am not going to cache all of these.
        # We're already caching all the artists and all the roles.
        # However, when outputting the track report, we will need to
        # get the same data more than once.  So we'll just cache the _last_
        # line to make that more efficient.
        #
        if ($id == $gLastAlbumSecondaryArtistsID)
        {
            $outString = $gLastAlbumSecondaryArtists;
        }
        else
        {
            my $all = RPS::DB::Item::AlbumAdditionalArtist->GetAllForAlbumID($id);
            if ($all && $all->size() > 0)
            {
                my @list;
                while (my $data = $all->next())
                {
                    my $name = $self->_artistFromID($data->artist_id());
                    my $role = $self->_artistRoleFromID($data->artist_role_id());
                    push @list, "$name ($role)";
                }
                $outString = join(', ', @list);
            }

            $gLastAlbumSecondaryArtists = $outString;
            $gLastAlbumSecondaryArtistsID = $id;
        }
    }

    return $outString;
}


1;

package RPS::Report::Dynamic::Catalog::Albums::Parameters;
use strict;
use warnings;

use lib '/app/tools/common/lib';
use lib '/app/tools/report/lib';
use lib '/app/tools/rps/lib';
use base 'RPS::Report::Dynamic::Catalog::Parameters';


sub _OptionalData
{
    # !!! Don't have any optional data for the basic catalog report.
    #
    return undef;
}


1;