#!/usr/bin/perl
use strict;

use Proc::Pidfile;
use Text::ParseWords;
use Data::Dumper;

use lib '/app/tools/common/lib';
use Common::RSApp;
use Common::Log;
use Common::DB::Item::TableChangeLog;
use Common::DB::Item::Client;
use Common::DB::Item::ClientType;
use Common::DB::Item::ClientCMIDMap;

use lib '/app/tools/rps/lib';
use RPS::DB::Item::Track;
use RPS::DB::Item::Album;
use RPS::DB::Item::Product;
use RPS::DB::Item::Master;
use RPS::DB::Item::Song;
use RPS::DB::Item::Artist;
use RPS::DB::Item::Composer;
use RPS::DB::Item::Label;
use RPS::DB::Item::ProductTrack;

use constant kCMClientID => 112;

# Create a pidfile.  This is just a file that will contain this script's
# process id.  We'll use the Proc::Pidfile module - This will allow
# us to silently exit if the file already exists (so we don't run two instances
# of this script at once), and will automatically clean up the pid file.
#
use constant kPIDFile => '/tmp/consumeMetadataChangeLog.pid';
my $pidfile = Proc::Pidfile->new( pidfile => kPIDFile, silent => 1 );

# Redirect stderr to a log file.
#
use constant kLogFilePath => '/app/data/logs/consumeMetadataChangeLog.log';
open( STDERR, ">> " . kLogFilePath ) or die "cannot redirect STDERR: $!\n";
select STDERR;
$| = 1;
select STDOUT;
$| = 1;

my $gErrors;

# This will map table name to constructor, and any additional state we
# might need to keep track of.
#
my %gTableMap = (
    'track' => {
        class     => 'RPS::DB::Item::Track',
        autoField => 'track_id',
    },
    'album' => {
        class     => 'RPS::DB::Item::Album',
        autoField => 'album_id',
    },
    'product' => {
        class     => 'RPS::DB::Item::Product',
        autoField => 'product_id',
    },
    'master' => {
        class     => 'RPS::DB::Item::Master',
        autoField => 'master_id',
    },
    'song' => {
        class     => 'RPS::DB::Item::Song',
        autoField => 'song_id',
    },
    'artist' => {
        class     => 'RPS::DB::Item::Artist',
        autoField => 'artist_id',
        noDelete  => 1,
        uniqueKey => 'name',
    },
    'composer' => {
        class     => 'RPS::DB::Item::Composer',
        autoField => 'composer_id',
        noDelete  => 1,
        uniqueKey => 'name',
    },
    'label' => {
        class     => 'RPS::DB::Item::Label',
        autoField => 'label_id',
    },
    'product_track' => {
        class     => 'RPS::DB::Item::ProductTrack',
        autoField => 'product_track_id',

        # No autoincrement key for this table
    },
);

my $singleton = Common::RSApp->new( clientID => kCMClientID );

# Make a map of valid client ids.
#
my %gDistClientIDs;
my $distClients = Common::DB::Item::Client->GetAllOfType(Common::DB::Item::ClientType::kClientTypeBitMaskDistribution);
while ( my $client = $distClients->next() ) {

    # !!! Just in case...
    #
    next if $client->client_id == kCMClientID;
    next if $client->client_id == 4;             # BIG_FISH
    next if $client->client_id == 42;            # IDEA
    next if $client->client_id == 23;            # COMPASS
    next if $client->client_id == 38;            # BLIND_PIG
    next if $client->client_id == 9;             # LAUGH
    next if $client->client_id == 60;            # RSDEMO

    #	next if $client->client_id == 122; # CENTAUR
    next if $client->client_id == 123;           # WELK
    next if $client->client_id == 202;           # rstest
    next if $client->client_id == 288;           # rstest

    $gDistClientIDs{ $client->client_id } = 1;
}

# We're also going to need to know which ids get mapped.
# !!! We might want to put these into a table someplace?
# !!! But for now I'll just hard-code it.
#
my %gIDsToRemap = (
    track_id         => 1,
    album_id         => 1,
    product_id       => 1,
    master_id        => 1,
    song_id          => 1,
    artist_id        => 1,
    composer_id      => 1,
    label_id         => 1,
    asset_id         => 1,
    product_track_id => 1,
);

my $changes = Common::DB::Item::TableChangeLog->GetAllNew();
while ( my $change = $changes->next() ) {

    # Delete entries for non-distribution clients
    # !!! Not going to delete - going to mark these as 'skipped'.
    # !!! Seems safer until we get all the kinks worked out.
    #
    if ( !$gDistClientIDs{ $change->client_id } ) {
        $change->status(Common::DB::Item::TableChangeLog::kStatusSkipped);
        $change->save();
        next;
    }

    # !!! Wrap this whole damn thing in an eval block.
    # If something throwns an exeception, we'll mark the record and move on.
    #

    eval {
        my $tableDef = $gTableMap{ $change->table_name };
        if ( !$tableDef ) {

            # The log table is now catching changes for tables that this script may not care about.
            # That's not really an error.
            #
            $change->status(Common::DB::Item::TableChangeLog::kStatusSkipped);
            $change->save();
            next;
        }

        if ( Common::DB::Item::TableChangeLog::kActionDelete eq $change->action ) {
            handleDelete( $change, $tableDef );
        } elsif ( Common::DB::Item::TableChangeLog::kActionInsert eq $change->action ) {

            # !!! If we already _have_ this record in the CM data, then we want to treat
            # !!! this like an update...
            #
            handleInsert( $change, $tableDef );
        } elsif ( Common::DB::Item::TableChangeLog::kActionUpdate eq $change->action ) {
            handleUpdate( $change, $tableDef );
        } else {

            # We don't recognize this action for some reason.  It is probably a malformed
            # log entry.  So we'll mark it as bad rather than deleting it, so we have some
            # hope of later fixing the problem.
            #
            logError(
                "ERROR - Unknown action '" . $change->action . "' for log entry " . $change->table_change_log_id . " - marking as bad" );
            $change->status(Common::DB::Item::TableChangeLog::kStatusBad);
            $change->save();
        }
    };
    if ($@) {
        logError( "ERROR - Caught exception: $@ : for log entry " . $change->table_change_log_id . " - marking as bad" );
        $change->status(Common::DB::Item::TableChangeLog::kStatusBad);
        $change->save();
    }
}

if ( defined $gErrors ) {
    open( MAIL, "|/usr/lib/sendmail -oi -t" );
    print MAIL "From: consumeMetaDataChangeLog\n";
    print MAIL 'To: knott@royaltyshare.com' . "\n";
    print MAIL 'Subject: ERROR REPORT' . "\n\n";
    print MAIL "$gErrors\n";
    close(MAIL);
}

sub handleDelete {
    my ( $change, $tableDef ) = @_;

    my $whereHash = parsePairString( $change->where_pairs );
    remapClientIDs( $whereHash, $change->client_id );

    # Fetch the current metadata record.
    #
    my $class = $tableDef->{class};
    my $data  = $class->Lookup(%$whereHash);
    if ( !$data ) {
        logError( "ERROR ON DELETE - could not find matching record for log entry " . $change->table_change_log_id . " - marking as bad" );
        $change->status(Common::DB::Item::TableChangeLog::kStatusBad);
        $change->save();
        return;
    }

    # !!! We need some special handling for the artist and composer tables.
    # !!! Basically, we _never_ delete artist or composers.
    #
    if ( $tableDef->{noDelete} ) {
        $change->status(Common::DB::Item::TableChangeLog::kStatusNoDelete);
        $change->save();
        return;
    }

    # Delete it!
    #
    $data->delete();

    # Done with the change log item
    #
    $change->status(Common::DB::Item::TableChangeLog::kStatusProcessed);
    $change->save();

    #    $change->delete();
}

sub handleInsert {
    my ( $change, $tableDef ) = @_;

    my $setHash = parsePairString( $change->set_pairs );

    # Pull the auto-increment value out of the hash, if there is one.
    # !!! Well, currently every table we map has an auto-increment column...
    #
    # !!! If we already _have_ a record with this id, we want to treat this like an update.
    #
    my $autoFieldName = $tableDef->{autoField};
    my $autoFieldValue;
    if ( defined $autoFieldName ) {
        $autoFieldValue = $setHash->{$autoFieldName};
        if ( !defined $autoFieldValue ) {
            logError( "ERROR ON INSERT- missing primary key for log entry " . $change->table_change_log_id . " - marking as bad" );
            $change->status(Common::DB::Item::TableChangeLog::kStatusBad);
            $change->save();
            return;
        }

        # ... actually, if the record is already there, I think we want to _punt_.
        #
        my $mapping = Common::DB::Item::ClientCMIDMap->Lookup(
            client_id      => $change->client_id,
            id_type        => $autoFieldName,
            client_site_id => $autoFieldValue,
        );

        if ($mapping) {
            logError( "WARNING - Skipping INSERT for change " . $change->table_change_log_id . " - record with that key already exists" );
            $change->status(Common::DB::Item::TableChangeLog::kStatusSkipped);
            $change->save();
            return;
        }

        delete $setHash->{$autoFieldName};
    }

    # Now we re-map the ids.
    #
    remapClientIDs( $setHash, $change->client_id );

    my $class = $tableDef->{class};

    # If we're going to insert a record with a unique key, we need to see if a record
    # with that key already exists!
    # If it does, then we just want to re-use that id, and not try to create a new record.
    #
    if ( $tableDef->{uniqueKey} && defined $setHash->{ $tableDef->{uniqueKey} } ) {
        my $previousRecord = $class->Lookup( $tableDef->{uniqueKey} => $setHash->{ $tableDef->{uniqueKey} } );
        if ($previousRecord) {
            my $cmIDValue = $previousRecord->$autoFieldName;

            my $newIDMapping = Common::DB::Item::ClientCMIDMap->Create(
                client_id      => $change->client_id,
                client_site_id => $autoFieldValue,
                cm_site_id     => $cmIDValue,
                id_type        => $autoFieldName,
            );
            $newIDMapping->save();

            $change->status(Common::DB::Item::TableChangeLog::kStatusDuplicate);
            $change->save();
            return;
        }
    }

    # Create the new metadata record.
    #
    my $newItem = $class->Create(%$setHash);
    $newItem->save();

    # If there is an autoincrement primary key on this table, get the new id
    # and add that to the mapping table.
    #
    if ( defined $autoFieldName ) {
        my $cmIDValue = $newItem->$autoFieldName;

        my $newIDMapping = Common::DB::Item::ClientCMIDMap->Create(
            client_id      => $change->client_id,
            client_site_id => $autoFieldValue,
            cm_site_id     => $cmIDValue,
            id_type        => $autoFieldName,
        );
        $newIDMapping->save();
    }

    # All done, we can get rid of the change entry
    #
    #    $change->delete();
    $change->status(Common::DB::Item::TableChangeLog::kStatusProcessed);
    $change->save();
}

sub handleUpdate {
    my ( $change, $tableDef ) = @_;

    # Parse both pair strings into hashes.
    #
    my $setHash   = parsePairString( $change->set_pairs );
    my $whereHash = parsePairString( $change->where_pairs );

    # remap the ids.
    # Note!  All these ids should already exist in the table!
    #
    eval {
        remapClientIDs( $whereHash, $change->client_id );
        remapClientIDs( $setHash,   $change->client_id );
    };
    if ($@) {
        logError( "ERROR ON UPDATE - problem finding id map for log entry " . $change->table_change_log_id . " - $@ - marking as bad" );
        $change->status(Common::DB::Item::TableChangeLog::kStatusBad);
        $change->save();
        return;
    }

    # Fetch the current metadata record.
    #
    my $class = $tableDef->{class};
    my $data  = $class->Lookup(%$whereHash);
    if ( !$data ) {
        logError( "ERROR ON UPDATE - could not find matching record for log entry " . $change->table_change_log_id . " - marking as bad" );
        $change->status(Common::DB::Item::TableChangeLog::kStatusBad);
        $change->save();
        return;
    }

    # Now update the record, and save the changes.
    #
    # !!! Going to be paranoid, and do this in an eval, just in case we somehow
    # get a bogus field name and the DB::Item throws an exception.
    #
    eval {
        foreach my $key ( keys %$setHash ) {
            $data->$key( $setHash->{$key} );
        }

        $data->save();
    };
    if ($@) {
        logError( "ERROR ON UPDATE - id:" . $change->table_change_log_id . " threw this exception: $@ - marking as bad" );
        $change->status(Common::DB::Item::TableChangeLog::kStatusBad);
        $change->save();
        return;
    }

    # Done with the change log item.
    #
    #    $change->delete();
    $change->status(Common::DB::Item::TableChangeLog::kStatusProcessed);
    $change->save();
}

sub remapClientIDs {
    my ( $hash, $clientID ) = @_;

    my $assetID;

    foreach my $keyName ( keys %$hash ) {

        # Want to limit hitting the database to recognized id types
        #
        next unless $gIDsToRemap{$keyName};

        # Need to handle asset_id differently!
        # I will need to get the product_type_id from the product table.
        # This might be tricky.
        #
        if ( 'asset_id' eq $keyName ) {

            # Let's wait until the rest of the mapping is complete.
            # Then (in theory) we'll have a valid, re-mapped product_id.
            #
            $assetID = $hash->{$keyName};
            next;
        }

        my $mapping = Common::DB::Item::ClientCMIDMap->Lookup(
            client_id      => $clientID,
            id_type        => $keyName,
            client_site_id => $hash->{$keyName},
        );
        if ($mapping) {
            $hash->{$keyName} = $mapping->cm_site_id;
        } else {
            die "ERROR - unable to map $keyName : " . $hash->{$keyName};
        }
    }

    if ($assetID) {
        my $productTypeID = $hash->{product_type_id};
        if ( !$productTypeID ) {

            # Get the product id.
            # This really _must_ work, or we're hosed.
            #
            my $productID = $hash->{product_id};
            die "ERROR - attempting to remap asset_id, but cannot find product_id!" unless $productID;

            my $cmSiteProduct = RPS::DB::Item::Product->Lookup( product_id => $productID );
            die "ERROR - attempting to remap asset_id, but cannot find product with product_id $productID" unless $cmSiteProduct;
            $productTypeID = $cmSiteProduct->product_type_id;
        }

        my $assetType = 'album_id';
        if ( RPS::DB::Item::Product::kProductTypeDigitalTrack == $productTypeID ) {
            $assetType = 'track_id';
        }

        my $mapping = Common::DB::Item::ClientCMIDMap->Lookup(
            client_id      => $clientID,
            id_type        => $assetType,
            client_site_id => $assetID,
        );
        if ($mapping) {
            $hash->{'asset_id'} = $mapping->cm_site_id;
        }
    }
}

sub parsePairString {
    my ($string) = @_;

    my %resultHash;
    my @pairs = Text::ParseWords::quotewords( ',', 0, $string );
    foreach my $pair (@pairs) {
        my ( $key, $value ) = Text::ParseWords::quotewords( '=', 0, $pair );
        $resultHash{$key} = $value;
    }

    return \%resultHash;
}

sub logError {
    my ($error) = @_;

    Common::Log::Print($error);
    $gErrors .= $error . "\n";
}