#!/usr/bin/perl
#
# Report all importers ever used, a file imported, the number of times used
# and the top client and count.
#
# 1. Grab all unique Service ID version pairs from the client file tables where
#    the file does not have a parent id (is an import not a split)
# 2. Gather the importer information from RPS::Sale::File table;
# 3. Query each client database to find a sample file and the importer counts.
#
# Limitation:
#
#   Because the importer used is not stored in the database this must be pulled
#   from code.  Therefore any changes to service/version pairs in code will
#   alter this report.
#

use strict;

use Getopt::Std;
use File::Basename;

my %opt;
usage() unless getopts( 'c:qhldv', \%opt );

if ( $opt{l} ) {
    list_clients( $ARGV[0] );
}

if ( $opt{h} ) {
    usage();
}

my $controller = new ImporterSample(
    client_id => $opt{c},
    filename  => $ARGV[0],
    quiet     => $opt{q},
    verbose   => $opt{v},
    debug     => $opt{d}
);

$controller->run();

sub usage {
    my $prog = basename $0;

    print <<EofUSAGE;

usage: $prog [-c client_id] [-l client_name/pattern] [-h] [-d]
            -c - Client ID (if not specified then run for all clients)
            -l - List client ids (host pattern is optional)
            -d - display debug information to STDERR
            -v - display verbose debug information to STDERR
            -q - Do not output summary report
            -h - display this screen
EofUSAGE

    exit 1;
}

sub list_clients {
    my $host = shift;
    my $key;
    foreach $key ( sort { $a <=> $b } keys(%Common::RSDB::CLIENT_DB) ) {
        printf( "%-20s %-10s ID: %s\n", $Common::RSDB::CLIENT_DB{$key}->{db_name}, "($Common::RSDB::CLIENT_DB{$key}->{host_id})", $key )
          if ( !defined($host) || $Common::RSDB::CLIENT_DB{$key}->{db_name} =~ /$host/i );
    }
    exit 1;
}

package DB::File;

use lib '/app/tools/raptor/lib';
use base 'Raptor::DB::Item::File';

use constant kTable => 'file';
use constant kDB    => Common::DB::Item::kClientDB();

sub Get {
    my $class = shift;
    my %args  = @_;
    my $dbo   = Common::RSApp::GetClientDB();

    my $sql =
        "SELECT * FROM file "
      . "WHERE service_id = $args{service_id} AND "
      . "version_num = $args{version_num} AND "
      . "parent_file_id IS NULL "
      . "ORDER by date_processed DESC LIMIT 1";

    my $sth = $dbo->DoCmd($sql);
    return $sth->fetchrow_hashref;
}

sub GetServiceCount {
    my $class = shift;

    my $dbo = Common::RSApp::GetClientDB();
    my $sql =
        "SELECT service_id, version_num, count(*) as count "
      . "FROM file "
      . "WHERE service_id IS NOT NULL and version_num IS NOT NULL "
      . "GROUP BY service_id, version_num";

    return $dbo->DoCmd($sql);
}

1;

package ImporterSample;

use Data::Dumper;
use Sys::Hostname;

use lib '/app/tools/common/lib';
use Common::RSApp;
use Common::Util;
use Common::Assert;
use Common::WriteXML;

use lib '/app/tools/common/lib';
use Common::Client;
use base 'Common::Script';

use lib '/app/tools/support/lib';
use Support::Service::ServiceSimple;

use lib '/app/tools/rps/lib';
use RPS::Import::Service;

sub _init {
    my $self = shift;
    my %args = @_;
    $self->SUPER::_init(@_);

    my %clients;

    $self->{_filename} = $args{filename};

    return $self;
}

sub run_process {
    my $self   = shift;
    my $infile = $self->_getFileHandle( $self->{_filename} );
    my $i      = 1;
    my @list;

    my $serviceData = $self->_getServiceData();

    print join( "\t",
        "Service",          "Version",   "Importer", "File",       "Physical Importer",
        "Physical Service", "Last Used", "Count",    "Top Client", "Top Count" )
      . "\n";

    foreach my $serviceID ( keys(%$serviceData) ) {
        foreach my $version ( keys( %{ $serviceData->{$serviceID} } ) ) {
            my $importer = $self->_getImporter( $serviceID, $version );
            my $history = $self->_getHistory( $serviceID, $version );

            print join( "\t",
                $self->_prettyService($serviceID),
                $version,
                $importer,
                $history->{file},
                $self->_isPhysicalImporter($importer),
                $self->_isPhysicalService($serviceID),
                $history->{last},
                $serviceData->{$serviceID}->{$version}->{count},
                $self->_prettyClient( $serviceData->{$serviceID}->{$version}->{topclient} ),
                $serviceData->{$serviceID}->{$version}->{topcount},
            ) . "\n";
        }
    }
}

sub _prettyClient {
    my $self     = shift;
    my $clientID = shift;

    my $singleton = new Common::RSApp( clientID => 0 );
    my $client = new Common::Client( clientID => $clientID );
    $singleton = undef;

    return $client->ClientName . " ($clientID)";
}

sub _prettyService {
    my $self      = shift;
    my $serviceID = shift;

    my $service = new Support::Service::ServiceSimple( serviceID => $serviceID );

    my $name = $service->ServiceName ? $service->ServiceName : "undef";
    return "$name ($serviceID)";
}

sub _getFileHandle {
    my $self = shift;
    my $filename = shift || return *STDIN;

    open( INFILE, $filename ) || die "Can't read input file: $filename ($!)";
    return *INFILE;
}

sub _getServiceData {
    my $self = shift;
    my @list = $self->_get_client_list();

    foreach my $client (@list) {
        my $singleton = new Common::RSApp( clientID => $client );
        my $data = $self->_getClientServiceData($client);
    }

    return $self->{_serviceData};
}

sub _getClientServiceData {
    my $self     = shift;
    my $client   = shift;
    my $clientID = Common::RSApp::GetClientID();

    my $data = $self->{_serviceData};

    my $sth = DB::File->GetServiceCount();

    while ( my $row = $sth->fetchrow_hashref() ) {
        my $service = $row->{service_id};
        my $version = $row->{version_num};

        if ( defined($service) && defined($version) ) {
            $data->{$service}->{$version}->{count} += $row->{count};

            if ( $data->{$service}->{$version}->{topclient} ) {
                if ( $data->{$service}->{$version}->{topcount} < $row->{count} ) {
                    $data->{$service}->{$version}->{topclient} = $clientID;
                    $data->{$service}->{$version}->{topcount}  = $row->{count};
                }
            } else {
                $data->{$service}->{$version}->{topclient} = $clientID;
                $data->{$service}->{$version}->{topcount}  = $row->{count};
            }
        }
    }

    $self->{_serviceData} = $data;

}

sub _getImporter {
    my $self      = shift;
    my $serviceID = shift;
    my $version   = shift;

    return unless ( $serviceID && $version );

    my $importers = RPS::Import::Service::GetImporters($serviceID);
    return $importers->{$version};
}

sub _getHistory {
    my $self      = shift;
    my $serviceID = shift;
    my $version   = shift;
    my @list      = $self->_get_client_list();

    my $history;

    return unless ( $serviceID && $version );

    foreach my $client (@list) {
        my $singleton = new Common::RSApp( clientID => $client );

        my $tmp = $self->_getClientHistory( $serviceID, $version );
        next unless ($tmp);

        if ($history) {
            if ( $history->{last} gt $tmp->{last} ) {
                $history = $tmp;
            }
        } else {
            $history = $tmp;
        }

        $singleton = undef;
    }

    return $history;
}

sub _getClientHistory {
    my $self      = shift;
    my $serviceID = shift;
    my $version   = shift;
    my $clientID  = Common::RSApp::GetClientID();
    my $history;

    my $file = DB::File->Get( service_id => $serviceID, version_num => $version );

    if ($file) {
        if ($file) {
            $history->{client_id} = $clientID;
            $history->{file}      = $file->{file_dir} . "/" . $file->{file_name};
            $history->{last}      = $file->{date_processed};
        }
    }

    return $history;
}

sub _get_client_list {
    my $self = shift;
    my @list;

    my $host = hostname;
    $host =~ s/\..*//g;
    $self->debug("Running on $host");

    assert($self);
    assert($host);
    my $singleton = new Common::RSApp( clientID => 0 );

    return ( $self->{_client_id} ) if ( defined( $self->{_client_id} ) );

    # If this is being run on a production box
    if (Common::RSApp::IsProductionServer) {
        return sort { $a <=> $b } Common::RSDB::GetAllRPSClientIDs();
    }

    # Running on some other host, run of all install DBs on localhost
    else {
        return sort { $a <=> $b } Common::RSDB::GetLocalClientIDs($host);
    }
}

sub _isPhysicalImporter {
    my $self     = shift;
    my $importer = shift;

    my @physicalImporters = qw( RPS::Import::ADAPhys
      RPS::Import::AmazonCreateSpace
      RPS::Import::AmazonPhys
      RPS::Import::BMG
      RPS::Import::BMGCHouse
      RPS::Import::BMGSony2
      RPS::Import::BMGSonyPhys
      RPS::Import::BMGSonyPhys2
      RPS::Import::Caroline
      RPS::Import::CreateSpace
      RPS::Import::Dock
      RPS::Import::DownloadCentric
      RPS::Import::DTArtistDirect
      RPS::Import::DTInternational
      RPS::Import::DTThirdParty
      RPS::Import::Echo
      RPS::Import::Echospin
      RPS::Import::Faithworks
      RPS::Import::Fontana
      RPS::Import::Fusion
      RPS::Import::HarmoniaMundi
      RPS::Import::KochEntCanada
      RPS::Import::KochPhysArc
      RPS::Import::LMMGSales
      RPS::Import::LookoutDirect
      RPS::Import::Navarre
      RPS::Import::NugsRevised
      RPS::Import::OutSideMusic
      RPS::Import::ProperUK
      RPS::Import::Red
      RPS::Import::RevolverPhysical
      RPS::Import::Rootsy
      RPS::Import::RoughTradeDist
      RPS::Import::RoughTradeDist2
      RPS::Import::RSFormat
      RPS::Import::RSFormatFull
      RPS::Import::RSPhysicalFormat
      RPS::Import::Rykodisc
      RPS::Import::Rykodisc2
      RPS::Import::SanctHistorical
      RPS::Import::SDROutsideSales
      RPS::Import::Shellshock
      RPS::Import::TouchNGoPhys
      RPS::Import::UniversalCAPhysical
      RPS::Import::Welk );

    return grep( /^$importer$/, @physicalImporters ) ? "P" : "";
}

sub _isPhysicalService {
    my $self = shift;
    my $serviceID = shift || return;

    my @services = qw( 46 47 48 49 50 51 54 55 56 57 58 59 61 63 64 66 78 139
      140 155 156 160 170 172 174 256 275 277 282 350 );

    return grep( /^$serviceID$/, @services ) ? "X" : "";
}

1;