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

package RPS::Sale::Report::EMIPulse;
use strict;
use IO::File;
use Date::Calc;
use File::stat;

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

use RPS::DB::Item::ReportQueries::EMIPulse;
use Common::Client;
use Common::Assert;

use base 'Common::XMLObject';


# JPK - We don't really have a small, well-abstracted base class for any of these asynchronous reports.
# I wish we did, but we don't.
#
# I don't want to spend a ton of time dreaming up the perfect interface.
#
# I think we'll want to have an instance of a 'Sale::Report' object (which is not the current model at all).
# Needs a period_id parameter.
#
# !!! The current model has everything stuffed into a single file, RPS::Sale::Report.
# !!! There is a table that maps a report 'name' (i.e. 'royalty' or 'reconcilliation') to the report code, sort of.
# !!! It's pretty wacky, in my opinion.

# I can't help myself, this code is gross.   So I will start with what I think is a cleaner model for a 'sale report'.
# The current RPS::Report class is structured around web-displayed, paginated reports where the data lives in a table.
# That's not what we're doing here.
# The Report::Dynamic stuff is also totally different.... although perhaps I can structure that?


# !!! These public methods are named the same as the public method in the Report::Dynamic class.
# !!! That is deliberate...
#
# !!! I'd like to transform this into a base class, and refactor the old Report code to use this model.
#


# We may want/need to have this file zipped up.
# So let's keep that in mind...
#

use constant kGSSReportingEntity => 'RS';  # <-- just a placeholder for now.
use constant REPORT_BASE_DIR => '/app/shared/sale_report';
use constant kZIPPath => '/usr/bin/zip';


sub _init
{
    my ($self, %args) = @_;
    assert(defined $args{periodID});
    $self->{periodID} = $args{periodID};

    # The fixed width format is rather challenging to audit.
    # I'll provide an option that allow us to use tab delimiting.
    #
    if ($args{tabDelimited})
    {
        $self->{_useTabs} = 1;   
    }


    # We might want to make the ZIP archiving optional
    #
    if ($args{skipZip})
    {
        $self->{_skipZip} = 1;
    }

    return $self;
}


sub periodID
{
    my ($self) = @_;
    return $self->{periodID};
}


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

    # filename ought to be the name of the file as sent to the user.
    # which may or may not be what we call it on our filesystem.
    #
#    my $fullPath = $self->_internalFullPath();
    my $fullPath = $self->_filePath . '/' . $self->filename();

    return (-e $fullPath);
}


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

    if (! $self->{_filePath})
    {
        $self->{_filePath} = join('/', REPORT_BASE_DIR, Common::Client::Current()->ClientNameClean());
    }

    return $self->{_filePath};
}

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

    return $self->_filePath() . '/' . $self->_internalFilename();
}

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

    # !!! For now, these can be the same.
    #
#    return $self->filename();
   
    # Let's go with something different.
    # We will want to zip up the final file.
    #
    return $self->periodID() . '_Pulse.txt';
}

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

    # Just a guess for now...
    #
    if ($self->{_skipZip})
    {
        return $self->_internalFilename();
    }

    return $self->periodID().'_Pulse.zip';
}

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

    return stat($self->fullPath())->size();
}

sub fullPath
{
    my ($self) = @_;
    my $fullPath = $self->_filePath . '/' . $self->filename();

    return $fullPath;
}

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

    unlink $self->_internalFullPath();
    unlink $self->fullPath();
}


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


    # Might want to just silently fail, but for now let's throw an exception.
    #
    die "ERROR - report file already exists" if $self->exists();


    $self->_create();
}

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

    $self->_openFileForWriting();

    $self->_writeHeader();

    $self->_writeReportData();

    $self->_writeFooter();

    $self->closeFile();
}


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

    my $fullPath = $self->_internalFullPath();


    $self->{_fh} = IO::File->new("> $fullPath")
     or die "ERROR - unable to open $fullPath for writing: $!";

    binmode($self->{_fh}, ':utf8');
}

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

    my $fullPath = $self->fullPath();


    $self->{_fh} = IO::File->new("< $fullPath")
     or die "ERROR - unable to open $fullPath for reading: $!";
}



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

    if ($self->{_fh})
    {
        close $self->{_fh};
        $self->{_fh} = undef;

        # Compress the file.
        #
        if (! $self->{_skipZip} && -e $self->_internalFullPath())
        {
            my $command = kZIPPath . " -j " . $self->fullPath() . ' ' . $self->_internalFullPath();
            my $rVal = system($command);
            if (! $rVal)
            {
                # 0 == success...
                #
                unlink $self->_internalFullPath();
            }
            else
            {
                die "ERROR - Unable to compress " . $self->_internalFullPath() . ": exit code $rVal:  $!";
            }
        }
    }
}

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

    my $time = time;
    my ($year,$month,$day, $hour,$min,$sec, $doy,$dow,$dst) = Date::Calc::Localtime($time);
    my $fileDate = sprintf("%02d%02d%02d", $year, $month, $day);

    
    $self->_writeTextPadded($time, 13);
    $self->_writeTextPadded($fileDate, 6);

    # !!! No clue what the 'GSS Reporting Entity' is yet...
    #
    $self->_writeTextPadded(kGSSReportingEntity, 2);

    $self->_writeTextPadded('HDR', 3);

    # And the fun 371 characters of wasted space...
    #
    $self->_writeTextPadded('', 371);
    $self->_writeTextPadded('0', 1);

    # End the line.
    #
    my $fh = $self->{_fh};
    print $fh "\n";
}


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

    $self->{_unitCount} = 0;

    my $dataCollection = $self->_getCollection();

    while (my $data = $dataCollection->next())
    {
        $self->_writeDataLine($data);
    }
}


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

    $self->_writeTextPadded('', 21);
    $self->_writeTextPadded('FTR', 3);
    $self->_writeTextPadded('', 31);
    $self->_writeIntegerPadded($self->{_unitCount}, 8);
    $self->_writeTextPadded('', 332);
    $self->_writeTextPadded('0', 1);

    my $fh = $self->{_fh};
    print $fh "\n";
}



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

    # I think it's safe to assume that we'll have some query set up to grab the sales we care about.
    # Whether we're going to be joining other tables in this query, well, I just don't know yet.
    # Probably...
    #

    # !!! I don't want to re-use the crappy RPS::File::Sales interface.
    #
    return RPS::DB::Item::ReportQueries::EMIPulse->GetSalesForPeriod($self->periodID());
}

my @gColumns = (
    {
        # Recording Identifier
        method => '_identifier',
        width => 18,
    },
    {
        # Date of Sale
        method => '_columnAsDate',
        field => 'date_end',
        width => 6,
    },
    {
        # Date Invoiced
        width => 6,
    },
    {
        # GSS Reporting Entity
        value => kGSSReportingEntity,
        width => 2,
    },
    {
        # GSS Selling Company
        width => 3,
    },
    {
        # DSP/MSP Code
        width => 8,
    },
    {
        # etailer code
        # !!! Not sure where this will come from...
        width => 8,
    },
    {
        # ReleaseType
        method => '_releaseType',
        width => 3,
    },
    {
        # Single or Multi-track or Other
        width => 1,
    },
    {
        # Quantity
        method => '_columnAsQuantity',
        field => 'units',
        width => 8,
    },
    {
        # Artist
        method => '_artist',
        width => 40,
    },
    {
        # Title
        method => '_title',
        width => 60,
    },
    {
        # ID Type
        method => '_idType',
        width => 1,
    },
    {
        # Segment
        width => 3,
    },
    {
        # currency
        field => 'currency_code',
        width => 3,
    },
    {
        # net value
        method => '_netValue',
        width => 20,
    },
    {
        # Filename
        field => 'filename',
        width => 35,
    },
    {
        # Material Grp
        width => 9,
    },
    {
        # Sales Type
        width => 4,
    },
    {
        # Sales Type Desc
        width => 20,
    },
    {
        # Item Cat
        width => 4,
    },
    {
        # Item Cat Desc
        width => 20,
    },
    {
        # Prod Hierarchy 
        width => 18,
    },
    {
        # Prod Hierarchy Desc
        width => 40,
    },
    {
        # Profit Centre
        width => 10,
    },
    {
        # Profit Centre Desc
        width => 40,
    },
    {
        # Sales Org
        width => 4,
    },
    {
        # Destination Country
        field => 'country_code',  # <- just a guess...
        width => 3,
    },
);

sub _writeDataLine
{
    my ($self, $dbItem) = @_;

    # There are 28 fields.
    # I doubt all of this stuff will end up in the DB::Item directly.
    #
    # The ultimate abstract way would be to create a method for each column.
    # That feels like overkill, since the majority of these columns will just
    # be outputting the value in the DB::Item.
    #
    # I'll use a config hash to make it slightly more abstract.
    #
    foreach my $column (@gColumns)
    {
        my $method = $column->{method};
        $method = '_columnAsText' unless $method;

        $self->$method($column, $dbItem);
    }

    my $fh = $self->{_fh};
    print $fh "\n";
}


sub _columnAsText
{
    my ($self, $column, $dbItem) = @_;
    assert($column->{width});

    my $value;
    if (defined $column->{value})
    {
        $value = $column->{value};
    }
    elsif ($column->{field})
    {
        my $f = $column->{field};
        $value = $dbItem->$f();
    }

    $self->_writeTextPadded($value, $column->{width});
}

sub _columnAsDate
{
    my ($self, $column, $dbItem) = @_;
    assert($column->{width});
    assert($column->{field});

    my $f = $column->{field};
    my $value = $dbItem->$f();

    my @chunks = split('-', $value);
    my $y = substr($chunks[0], 2, 2);
    my $m = $chunks[1];
    my $d = $chunks[2];

    $self->_writeTextPadded(sprintf("%02d%02d%02d", $y, $m, $d), $column->{width});
}


sub _columnAsQuantity
{
    my ($self, $column, $dbItem) = @_;
    assert($column->{width});
    assert($column->{field});

    my $f = $column->{field};
    my $value = $dbItem->$f();

    $self->{_unitCount} += $value;

    $self->_writeIntegerPadded($value, $column->{width});
}


sub _netValue
{
    my ($self, $column, $dbItem) = @_;
    assert($column->{width});

    my $units = $dbItem->units();
    my $price = $dbItem->price();

    # Anything else I need to do here?  Currency conversion, etc?
    #
    $self->_writeDecimalPadded(($units * $price), $column->{width});
}


sub _identifier
{
    my ($self, $column, $dbItem) = @_;
    assert($column->{width});

    # Which column we look at will depend on the product type.
    #
    my $id;
    if ($dbItem->product_type eq 'T')
    {
        $id = $dbItem->digital_isrc;
    }
    else
    {
        $id = $dbItem->digital_icpn;
    }

    $self->_writeTextPadded($id, $column->{width});
}

sub _releaseType
{
    my ($self, $column, $dbItem) = @_;
    assert($column->{width});

    # Which column we look at will depend on the product type.
    #
    my $type;
    if ($dbItem->product_type eq 'T')
    {
        $type = 'S';
    }
    else
    {
        $type = 'M';
    }

    $self->_writeTextPadded($type, $column->{width});
}

sub _idType
{
    my ($self, $column, $dbItem) = @_;
    assert($column->{width});

    # Which column we look at will depend on the product type.
    #
    my $type;
    if ($dbItem->product_type eq 'T')
    {
        $type = 'I';
    }
    else
    {
        $type = 'U';
    }

    $self->_writeTextPadded($type, $column->{width});
}

sub _artist
{
    my ($self, $column, $dbItem) = @_;
    assert($column->{width});

    # Which column we look at will depend on the product type.
    #
    my $name;
    if ($dbItem->product_type eq 'T')
    {
        $name = $dbItem->track_artist;
    }
    else
    {
        $name = $dbItem->album_artist;
    }

    $self->_writeTextPadded($name, $column->{width});
}

sub _title
{
    my ($self, $column, $dbItem) = @_;
    assert($column->{width});

    # Which column we look at will depend on the product type.
    #
    my $name;
    if ($dbItem->product_type eq 'T')
    {
        $name = $dbItem->track_title;
    }
    else
    {
        $name = $dbItem->album_title;
    }

    $self->_writeTextPadded($name, $column->{width});
}

sub _writeTextPadded
{
    my ($self, $string, $width) = @_;

    my $fh = $self->{_fh};

    # Truncate the string if necessary
    #
    $string = substr($string, 0, $width);

    my $padding = $width - length($string);
    if (length($string))
    {
        print $fh $string;
    }

    if ($self->{_useTabs})
    {
        print $fh "\t";
    }
    else
    {
        if ($padding)
        {
            print $fh ' ' x $padding;
        }
    }
}

sub _writeIntegerPadded
{
    my ($self, $number, $width) = @_;
    my $paddedString = sprintf("%0".$width."d", $number);

    my $fh = $self->{_fh};
    print $fh $paddedString;

    if ($self->{_useTabs})
    {
        print $fh "\t";
    }
}

sub _writeDecimalPadded
{
    my ($self, $number, $width) = @_;
    assert($width > 6);

    # Going to assume that we reserve 6 characters for the denominator.
    # All the rest are used for the minus sign, if any, the numerator, and the decimal point.
    #
    # !!! Note, not using RSMath rounding here....
    #
    my $paddedString = sprintf("%0".$width.".06f", $number);

    my $fh = $self->{_fh};
    print $fh $paddedString;

    if ($self->{_useTabs})
    {
        print $fh "\t";
    }
}



1;