package BookPub::RDAS::URL::ProductPrice::Amazon;

use URI::Escape;

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

use lib '/app/tools/bookpub/lib';
use BookPub::RDAS::Request::ProductSearch::Amazon;
use BookPub::RDAS::Request::ProductPrice::Amazon;
use BookPub::DB::Item::BookProduct;
use BookPub::Catalog::Product::Book;
use BookPub::Catalog::Book;
use BookPub::Catalog::ISBN;
use BookPub::Tracker::Service;

use base 'BookPub::RDAS::URL::ProductPrice';

use constant kBaseURL       => 'http://www.amazon.com/gp/product/';
use constant kSearchBaseURL => 'http://www.amazon.com/gp/aw/s/?k=';

sub serviceID { return BookPub::Tracker::Service::AMAZON() }

#sub _ebookSearchURL { 'http://www.amazon.com/gp/aw/s/?i=digital-text&k=%s' }
sub _ebookSearchURL    { 'http://www.amazon.com/s/?i=digital-text&field-keywords=' }
sub _physicalSearchURL { 'http://www.amazon.com/gp/aw/s/?k=' }

sub _searchRequestObject {
    my $self = shift;
    return new BookPub::RDAS::Request::ProductSearch::Amazon(@_);
}

sub _ebookFormatPriority { qw( 031 023 022 029 000 ) }
sub _allowNameMatch      { 1 }
sub _searchISBN10        { }

sub _searchName {
    my $self = shift;
    my $book = shift || die;

    my $result = $book->Title();

    return $result;
}

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

    my $url = $args{url};

    return unless ($url);

    my ($asin) = $url =~ /a=(.*)$/;
    ($asin) = $url =~ /\/gp\/aw\/d\/([\w\d]+)\// unless ($asin);
    ($asin) = $url =~ /\/dp\/([\w\d]+)\//        unless ($asin);

    return unless ($asin);

    return kBaseURL . $asin;
}

sub _validateFromISBN {
    my $self    = shift;
    my %args    = @_;
    my $request = $args{request};
    my $product = $args{product};

    assert($request);
    assert($product);

    if ( $product->isEBook() ) {
        return $self->SUPER::_validateFromISBN(@_);
    }

    return 1;
}

sub _generateWithISBN {
    my $self    = shift;
    my %args    = @_;
    my $product = $args{product} || return;

    return $self->SUPER::_generateWithISBN(%args) if ( $product->isEBook() );

    #return if( $product->isEBook() );

    my $url = kBaseURL . $product->ISBN10() if ( $product->ISBN10 );
    if ( !$url && $product->ISBN13 ) {
        my $converted = BookPub::Catalog::ISBN->new( isbn13 => $product->ISBN13 );
        $url = kBaseURL . $converted->ISBN10 if ($converted);
    }

    if ($url) {
        $self->_storeURL( url => $url, productID => $product->ProductID );
        return $url;
    }

    return $self->SUPER::_generateWithISBN(%args);
}

sub _getServicePriceTypeID {
    my $self    = shift;
    my $product = shift;
    my $url     = $self->_parseURL( url => shift );

    return 0 unless ($product);
    return 0 unless ($url);

    Log->info(" ++ Fetching page to determine price type from $url");
    my $fetcher = new BookPub::RDAS::Request::ProductPrice::Amazon( url => $url, nosave => 1 );
    $fetcher->parse() if ( $fetcher->fetch() );

    my $parser = $fetcher->parser || return;

    my $priceType = $parser->PriceType;

    if ($priceType) {
        return 41 if ( $priceType eq 'agency' );
        return 42 if ( $priceType eq 'agencyplustax' );
    } else {
        return 1;
    }
}

sub _handleMismatchErrors {
    my $self       = shift;
    my $mismatches = shift;

    foreach $mismatch (@$mismatches) {
        my $url = $self->_parseURL( url => $mismatch->{url} );
        my $productID = $mismatch->{productID};

        next unless ( $url && $productID );

        $self->_storeURL( url => $url, productID => $productID, note => "Price type mismatch", invalid => 1 );
    }
}

1;