package RPS::Import::Boomkat;

#Version 1 created from specs in Fog Bugz Case 9556

use strict;

use Date::Calc qw(Days_in_Month Decode_Month);

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

#use Common::Util;
use Common::Util qw(normalize_date normalize_isrc);
use Common::Consts qw(%COUNTRY_CODE %CODE_TO_COUNTRY);

use lib '/app/tools/data_classes/lib';
use Client::Service;

use lib '/app/tools/rps/lib';
use RPS::File::Sale;
use RPS::Import::Importer;
use base 'RPS::Import::Importer';

my %field_map = (
    1 => {
        service           => 1,
        date              => 3,
        artist            => 4,
        title             => 5,
        label             => 6,
        product_type      => 7,
        client_product_id => 9,
        upc               => 10,
        isrc              => 11,
        units             => 17,
        price             => 18,
        currency_code     => 22,
        country_code      => 23,
    },
    2 => {
        service           => 1,
        date              => 3,
        artist            => 4,
        title             => 5,
        label             => 6,
        product_type      => 7,
        client_product_id => 9,
        upc               => 10,
        isrc              => 11,
        units             => 17,
        price             => 18,
        currency_code     => 20,
        country_code      => 21,
    },
);

my %product_type_map = (
    "b_album"  => RPS::File::Sale::TYPE_ALBUM,
    "b_ep"     => RPS::File::Sale::TYPE_ALBUM,
    "b_single" => RPS::File::Sale::TYPE_TRACK
);

#public methods

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

    my $lines    = $args{lines};
    my $version  = $args{file}->VersionNum();
    my $fileName = $args{file}->OrigFileName();
    my @sheets   = @{ $args{sheets} };

    return undef unless ($lines);

    my $linenum = 1;

    my $offsets = $field_map{$version};
    my %errors  = ();

    $linenum = 1;

    foreach my $line (@$lines) {

        my $f_service = $line->[ $offsets->{service} ];
        my $f_date    = $line->[ $offsets->{date} ];
        my $artist    = $line->[ $offsets->{artist} ];
        my $title     = $line->[ $offsets->{title} ];
        my $album;
        my $track;
        my $label             = $line->[ $offsets->{label} ];
        my $f_product_type    = lc $line->[ $offsets->{product_type} ];
        my $client_product_id = $line->[ $offsets->{client_product_id} ];
        my $upc               = $line->[ $offsets->{upc} ];
        my $isrc              = $line->[ $offsets->{isrc} ];
        my $units             = $line->[ $offsets->{units} ];
        my $price             = $line->[ $offsets->{price} ];
        my $currency_code     = $line->[ $offsets->{currency_code} ];
        my $country_code      = $line->[ $offsets->{country_code} ];

        my ( $date_begin, $date_end );

        ( $date_begin, $date_end ) = $self->_getDates( date_begin => $f_date, type => "iso" );

        my $product_type;

        if ( $f_product_type =~ /track/ ) {
            $product_type = RPS::File::Sale::TYPE_TRACK;
        } elsif ( $f_product_type =~ /release/ ) {
            $product_type = RPS::File::Sale::TYPE_ALBUM;
        }

        my $format     = RPS::File::Sale::FORMAT_DOWNLOAD;
        my $media_type = RPS::DB::Item::MediaType::kMediaTypeAudio;

        if (   $artist
            && $title
            && $label
            && $f_product_type
            && $units =~ /\d+/
            && $price =~ /\d+/
            && $f_date
            && $currency_code
            && $country_code ) {
            if ( ( $units == 0 ) && ( $price == 0 ) ) {
                $linenum++;
                next;
            }

            unless ( $date_begin && $date_end ) {
                $self->errstr("Couldn't get dates from: $f_date line number: $linenum");
                print STDERR "Couldn't get dates from: $f_date line number: $linenum\n";
                return undef;
            }

            unless ($product_type) {
                $self->errstr("Unknown product type: $f_product_type at linenum: $linenum");
                print STDERR "Unknown product type: $f_product_type at linenum: $linenum\n";
                return undef;
            }

            unless ( $Common::Consts::CODE_TO_COUNTRY{$country_code} ) {
                $self->errstr("Unknown country code: $country_code at line number: $linenum");
                print STDERR "Unknown country code: $country_code at line number: $linenum\n";
                return undef;
            }

            if ( $product_type eq RPS::File::Sale::TYPE_ALBUM ) {
                $album = $title;
            } elsif ( $product_type eq RPS::File::Sale::TYPE_TRACK ) {
                $track = $title;
            }

            my $sale = RPS::Import::SaleRec->new();
            $sale->dateBegin($date_begin);
            $sale->dateEnd($date_end);
            $sale->artistName($artist);
            $sale->albumName($album);
            $sale->trackName($track) if ( $product_type eq RPS::File::Sale::TYPE_TRACK );
            $sale->labelName($label);
            $sale->productType($product_type);
            $sale->clientProductID($client_product_id);
            $sale->upc($upc);
            $sale->isrc($isrc) if ( $product_type eq RPS::File::Sale::TYPE_TRACK );
            $sale->currencyCode($currency_code);
            $sale->countryCode($country_code);

            #$sale->serviceID($service_id);
            $sale->formatType($format);
            $sale->mediaType($media_type);
            $sale->lineNum($linenum);

            if ( ( $units == 0 ) && ( $price != 0 ) ) {

                if ( $price < 0 ) {
                    $sale->units(-1);
                    $sale->price( abs $price );
                    $self->_insertSale( sale => $sale );

                    $sale->units(1);
                    $sale->price(0);
                    $self->_insertSale( sale => $sale );
                } elsif ( $price > 0 ) {
                    $sale->units(1);
                    $sale->price($price);
                    $self->_insertSale( sale => $sale );

                    $sale->units(-1);
                    $sale->price(0);
                    $self->_insertSale( sale => $sale );
                }
            } else {

                if ( ( $units > 0 ) && ( $price > 0 ) ) {
                    $price /= $units;
                } elsif ( ( $units > 0 ) && ( $price < 0 ) ) {
                    $price = ( abs $price ) / $units;
                    $units *= -1;
                } elsif ( ( $units < 0 ) && ( $price > 0 ) ) {
                    $price = $price / ( abs $units );
                } elsif ( ( $units < 0 ) && ( $price < 0 ) ) {
                    $price = ( abs $price ) / ( abs $units );
                }

                $sale->units($units);
                $sale->price($price);

                #$args{dumper}($sale);  ## for cmd-line testing
                $self->_insertSale( sale => $sale );
            }
        }

        $linenum++;

    }

    return $linenum;
}

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