package RPS::Import::Sony::v36;

use strict;
use warnings;

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

use parent 'RPS::Import::ImporterMixed';

sub physical { 2 }

sub _fieldMapExtended {
    {
        physical => {
            option1 => {
                labelName       => 'C',
                dateBegin       => 'A2',
                dateEnd         => 'A2',
                productType     => 'H',
                clientProductID => 'F',
                artistName      => 'D',
                upc             => 'G',
                albumName       => 'E',
                retail          => 'I',
                sales           => 'J',
                salesRevenue    => 'O',
                returns         => 'K',
                returnsRevenue  => 'P',
                totalRevenue    => 'Q',
                mediaType       => 'H',
                units           => 'L',
            },
        },
        digital => {
            option1 => {
                labelName        => 'H',
                countryCode      => 'E',
                dateBegin        => 'A',
                dateEnd          => 'A',
                clientProductID  => 'N',
                artistName       => 'L',
                upc              => 'O',
                albumName        => 'M',
                isrc             => 'S',
                units            => 'AB',
                currencyCode     => 'J',
                price            => 'W',
                mediaType        => 'P',
            },
        },
    };
}

sub _unverifiedFieldMapExtended {
    {
        physical => {
            option1 => {
                netUnits => 'L',
            },
        }
    };
}

sub _headerIdentifierExtended {
    {
        physical => {
            option1 => { upc => 'UPC' }
        },
        digital  => {
            option1 => { upc => 'Dim Release Manufacturer Upc' }
        },
    };
}

my %typesMap = (
    # physical
    '12" maxi-single vinyl' => {
        product_type => RPS::File::Sale::TYPE_LP5,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    '7" vinyl single' => {
        product_type => RPS::File::Sale::TYPE_LP5,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    'cd ep' => {
        product_type => RPS::File::Sale::TYPE_CD,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    'compact disc' => {
        product_type => RPS::File::Sale::TYPE_CD,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    'vinyl lp record' => {
        product_type => RPS::File::Sale::TYPE_LP,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    # digital
    'music' => {
        media_type => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
);

sub channel    { RPS::File::Sale::CHANNEL_RETAIL }
sub priceLevel { RPS::File::Sale::PLEVEL_FULL }
sub formatType { RPS::File::Sale::FORMAT_STREAM }

sub saleDates {
    my $self = shift;
    my $startDate = $self->_getByFieldName('dateBegin') || '';

    my ($year, $month, $day, $dateBegin, $dateEnd);
    if ( $startDate =~ m/^([a-zA-Z]{3})[\s-](\d{2})$/ ) {
        my %monthes = (
            jan => 1, feb => 2, mar => 3, apr => 4,  may => 5,  jun => 6,
            jul => 7, aug => 8, sep => 9, oct => 10, nov => 11, dec => 12,
        );
        $month = $monthes{ lc($1) } if exists $monthes{ lc($1) };
        ($year, $day) = ($2, 1);
        $startDate = sprintf( "%04d-%02d-%02d", $year, $month, $day );
    }

    if ( ($month, $day, $year) = $startDate =~ /(\d{2})\/(\d{2})\/(\d{4})/ ) {
        $startDate = sprintf( "%04d-%02d-%02d", $year, $month, $day );
    }

    if ( $startDate =~ /\d{4}-\d{2}-\d{2}/ ) {
        ($dateBegin, $dateEnd) = $self->_getDates( date_begin => $startDate );
    }

    return ($dateBegin, $dateEnd);
}

sub countryCode   {
    my $self = shift;

    if ( $self->dataType eq 'physical' ) {
        return 'CA';
    }
    elsif ( $self->dataType eq 'digital' ) {
        my $name = $self->_getByFieldName('countryCode');
        my $oCountry = Common::Country->Get($name);
        return $oCountry ? $oCountry->alpha2() : $name;
    }

    return;
}
sub currencyCode {
    my $self = shift;

    if ( $self->dataType eq 'physical' ) {
        return 'CAD';
    }
    elsif ( $self->dataType eq 'digital' ) {
        return $self->_getByFieldName('currencyCode');
    }

    return;
}

sub productType {
    my $self = shift;

    if ( $self->dataType eq 'physical' ) {
        my $type = lc($self->_getByFieldName('productType') || '');
        return exists $typesMap{$type}{product_type} ? $typesMap{$type}{product_type} : undef;
    }
    elsif ( $self->dataType eq 'digital' ) {
        return RPS::File::Sale::TYPE_TRACK;
    }

    return $self->handleError( "Product type not set: " . RPS::DB::Item::SaleImportError::kErrorNonqualifying );
}

sub mediaType {
    my $self = shift;
    my $type = lc($self->_getByFieldName('mediaType') || '');
    return exists $typesMap{$type}{media_type} ? $typesMap{$type}{media_type} : undef;
}

sub sales {
    my $self = shift;
    my $sales = $self->_getByFieldName('sales') || 0;
    return $sales > 0 ? $sales : 0;
}

sub salesRevenue {
    my $self = shift;
    my $revenue = $self->_getByFieldName('salesRevenue') || 0;
    return $revenue > 0 ? $revenue : 0;
}

sub returns {
    my $self = shift;
    my $returns = $self->_getByFieldName('returns') || 0;
    return $returns < 0 ? abs($returns) : 0;
}

sub returnsRevenue {
    my $self = shift;
    my $revenue = $self->_getByFieldName('returnsRevenue') || 0;
    return $revenue < 0 ? abs($revenue) : 0;
}

sub totalRevenue {
    my $self = shift;
    return $self->salesRevenue - abs($self->returnsRevenue);
}


1;