package BookPub::Import::Importer::Audible::Audible1;

use strict;

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

use lib '/app/tools/bookpub/lib';
use BookPub::DB::Item::Sale;
use BookPub::Import::SaleRec;
use base 'BookPub::Import::Importer';

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

    my $fieldMap = $self->_getPrimaryFieldMap();

    # the report date is in the summary tab
    my $reportDate = $fieldMap->{reportDate};
    my $dateStr    = $args{sheets}[ $reportDate->[0] ][ $reportDate->[1] ][ $reportDate->[2] ];
    my ( $dateBegin, $dateEnd ) = $self->_getDates(
        date_begin => $dateStr,
        type       => $dateStr =~ m/[a-z\/-]/i ? undef : 'msft'
    );
    unless ( $dateBegin && $dateEnd ) {
        $self->errstr('failed to get dates');
        Common::Log::Print("bad date str: '$dateStr'");
        return undef;
    }

    my $count = $self->_processRows(
        sheets      => $args{sheets},
        fields      => $fieldMap,
        dateDefault => [ $dateBegin, $dateEnd ],

        #debug       => $args{dumper}
    );

    if ( $self->can('_getPromoFieldMap') ) {
        $count += $self->_processRows(
            sheets      => $args{sheets},
            fields      => $self->_getPromoFieldMap(),
            dateDefault => [ $dateBegin, $dateEnd ],

            #debug       => $args{dumper}
        );
    }

    return $count;
}

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

    my ( $dateBegin, $dateEnd ) = @{ $args{dateDefault} };
    my $fieldMap  = $args{fields};
    my $lines     = $args{sheets}[ $fieldMap->{sheetIndex} ];
    my $saleCount = 0;

    for ( my $i = 1 ; $i < scalar @$lines ; $i++ ) {
        my $line = $lines->[$i];

        my $svcProdID = $line->[ $fieldMap->{serviceProdID} ];
        unless ( $svcProdID =~ m/\d+/ ) {
            Common::Log::Print("skip line $i based on svcProd: '$svcProdID'");
            next;
        }

        # currently, they set units to negative (as we do) so no need to check the state of 'transaction'
        #my $transaction = $line->[ $fieldMap->{transaction} ];

        my $saleSrc = uc( $line->[ $fieldMap->{saleSrc} ] );
        my $country =
            $saleSrc eq '.COM' ? 'US'
          : $saleSrc eq 'UK'   ? 'GB'
          :                      $saleSrc;

        unless ( length($country) == 2 ) {
            $self->errstr("invalid country: '$saleSrc'");
            Common::Log::Print("invalid country: '$saleSrc'");
        }

        if ( exists $fieldMap->{date} ) {
            $dateBegin = $dateEnd = Common::Util::normalize_date( $line->[ $fieldMap->{date} ] );
            unless ($dateBegin) {
                Common::Log::Print('fall back to default date');
                ( $dateBegin, $dateEnd ) = @{ $args{dateDefault} };
            }
        }

        my $saleRec = BookPub::Import::SaleRec->new();

        # defaults
        $saleRec->formatType(BookPub::DB::Item::Sale::kFormatTypeAudioUnknown);
        $saleRec->productType(BookPub::DB::Item::Sale::kProductTypeAudioBook);
        $saleRec->currencyCode('USD');

        $saleRec->dateBegin($dateBegin);
        $saleRec->dateEnd($dateEnd);
        $saleRec->serviceProductID($svcProdID);
        $saleRec->lineNum($i);
        $saleRec->listPrice( $line->[ $fieldMap->{listPrice} ] );
        $saleRec->countryCode($country);

        $saleRec->rIsbn13( $line->[ $fieldMap->{isbn} ] );
        $saleRec->rTitle( $line->[ $fieldMap->{title} ] );
        $saleRec->rImprint( $line->[ $fieldMap->{imprint} ] );
        $saleRec->rAuthor( $line->[ $fieldMap->{author} ] );
        $saleRec->rListPrice( $line->[ $fieldMap->{listPrice} ] );

        # a single row can have both subscription and non-subscription sales reported
        # so handle them 1 at a time

        # non-subscription
        my $units = $line->[ $fieldMap->{unitsDL} ];

        #
        # *** NOTE : tmp fix for hachette ***
        #
        # since hachette doesn't allow returns from audible, we're gonna skip any return rows (for now)

        if ( $units > 0 ) {
            $saleRec->purchaseType(BookPub::DB::Item::Sale::kPurchaseTypeDownload);
            $saleRec->units($units);
            $saleRec->unitPrice( abs( $line->[ $fieldMap->{salesDL} ] / $units ) );
            $saleRec->revenue( $line->[ $fieldMap->{salesDL} ] );

            $saleRec->rRevenue( $line->[ $fieldMap->{salesDL} ] );
            $saleRec->rUnits($units);

            #$args{debug}($saleRec); # debug
            $self->_insertSale( sale => $saleRec );
            $saleCount++;
        }

        # non-subscription
        my $units = $line->[ $fieldMap->{unitsCash} ];

        #
        # *** NOTE : tmp fix for hachette ***
        #
        # since hachette doesn't allow returns from audible, we're gonna skip any return rows (for now)

        if ( $units > 0 ) {
            $saleRec->purchaseType(BookPub::DB::Item::Sale::kPurchaseTypeDownload);
            $saleRec->units($units);
            $saleRec->unitPrice( abs( $line->[ $fieldMap->{salesCash} ] / $units ) );
            $saleRec->revenue( $line->[ $fieldMap->{salesCash} ] );

            $saleRec->rRevenue( $line->[ $fieldMap->{salesCash} ] );
            $saleRec->rUnits($units);

            #$args{debug}($saleRec); # debug
            $self->_insertSale( sale => $saleRec );
            $saleCount++;
        }

        # subscription
        $units = $line->[ $fieldMap->{unitsSub} ];
        if ( $units > 0 ) {
            $saleRec->purchaseType(BookPub::DB::Item::Sale::kPurchaseTypeSubscriptionDL);
            $saleRec->units($units);
            $saleRec->unitPrice( abs( $line->[ $fieldMap->{salesSub} ] / $units ) );
            $saleRec->revenue( $line->[ $fieldMap->{salesSub} ] );

            $saleRec->rRevenue( $line->[ $fieldMap->{salesSub} ] );
            $saleRec->rUnits($units);

            #$args{debug}($saleRec); # debug
            $self->_insertSale( sale => $saleRec );
            $saleCount++;
        }
    }

    return $saleCount;
}

###
1;    # Play nicely.
###