File Coverage

blib/lib/Business/RO/TaxDeduction.pm

Criterion	Covered	Total	%
statement	46	46	100.0
branch	10	10	100.0
condition	5	6	83.3
subroutine	13	13	100.0
pod	1	1	100.0
total	75	76	98.6

package Business::RO::TaxDeduction;
$Business::RO::TaxDeduction::VERSION = '0.011';
# ABSTRACT: Romanian salary tax deduction calculator

use 5.010001;
use utf8;
use Moo;
use MooX::HandlesVia;
use Math::BigFloat;
use Scalar::Util qw(blessed);
use Business::RO::TaxDeduction::Types qw(
    Int
    MathBigFloat
);
use Business::RO::TaxDeduction::Amount;
use Business::RO::TaxDeduction::Ranges;

has 'vbl' => (
    is       => 'ro',
    isa      => Int,
    required => 1,
);

has 'year' => (
    is       => 'ro',
    isa      => Int,
    default  => sub { 2016 },
);

has 'persons' => (
    is       => 'ro',
    isa      => Int,
    default  => sub { 0 },
);

has 'deduction' => (
    is      => 'ro',
    lazy    => 1,
    default => sub {
        my $self = shift;
        return Business::RO::TaxDeduction::Amount->new(
            year    => $self->year,
            persons => $self->persons,
        );
    },
);

has 'ranges' => (
    is      => 'ro',
    lazy    => 1,
    default => sub {
        my $self = shift;
        return Business::RO::TaxDeduction::Ranges->new(
            year => $self->year,
        );
    },
    handles => [ qw( vbl_min vbl_max f_min f_max ) ],
);

has 'ten' => (
    is      => 'ro',
    isa     => MathBigFloat,
    default => sub {
        return Math::BigFloat->new(10);
    },
);

sub tax_deduction {
    my $self   = shift;
    my $vbl    = $self->_round_to_int( $self->vbl );
    my $amount = $self->deduction->amount;
    if ( $vbl <= $self->vbl_min ) {
        return $amount;
    }
    elsif ( ( $vbl > $self->vbl_min ) && ( $vbl <= $self->vbl_max ) ) {
        $amount = $self->_tax_deduction_formula($vbl, $amount);
        return ( blessed $amount ) ? $amount->bstr : $amount;
    }
    else {
        return 0;               # 0 for VBL > vbl_max
    }
}

sub _tax_deduction_formula {
    my ( $self, $vbl, $base_deduction ) = @_;
    my $amount = $base_deduction * ( 1 - ( $vbl - $self->f_min ) / $self->f_max );
    return $self->_round_to_tens($amount);
}

sub _round_to_int {
    my ( $self, $amount ) = @_;
    return int( $amount + 0.5 * ( $amount <=> 0 ) );
}

sub _round_to_tens {
    my ( $self, $para_amount ) = @_;
    my $amount = Math::BigFloat->new($para_amount);

    return 0 if $amount == 0;

    my $afloor  = $amount->copy()->bfloor();
    my $amodulo = $afloor->copy()->bmod( $self->ten );

    return $amount if $amount->is_int && $amodulo == 0;
    return $afloor->bsub($amodulo)->badd( $self->ten );
}

1;

__END__