International Prices

function CalculatePrice(value, fxRate, vatRateTypes, productLocalVatRate, isGrossPrices, currencyDecimalPlaces, quantity, productClassCoefficient, priceCoefficient, productCountryVatRate, roundingRules) {
    if (value == 0)
        return (0).toFixed(currencyDecimalPlaces);

    var merchantVatRate = vatRateTypes.LocalVATRateType.Rate / 100;
    if (productLocalVatRate !== null) {
        if (productLocalVatRate == 0) {
            merchantVatRate = 0;
        } else {
            merchantVatRate = productLocalVatRate / 100;
        }
    }

    var countryVatRate = vatRateTypes.VATRateType.Rate / 100;
    if (productCountryVatRate || productCountryVatRate === 0) {
        if (productCountryVatRate == 0) {
            countryVatRate = 0;
        } else {
            countryVatRate = productCountryVatRate / 100;
        }
    }

    if (isGrossPrices) {
        if (vatRateTypes.IncludeVATTypeId == 0 ||
            vatRateTypes.IncludeVATTypeId == 8 ||
            (vatRateTypes.IncludeVATTypeId == 6 && vatRateTypes.UseCountryVAT)) {
            value = value / (1 + merchantVatRate);
            if (vatRateTypes.IncludeVATTypeId == 6) {
                value += value * countryVatRate;
            }
        }
    } else {
        if (vatRateTypes.IncludeVATTypeId == 2 ||
            vatRateTypes.IncludeVATTypeId == 4 ||
            vatRateTypes.IncludeVATTypeId == 6) {
            if (vatRateTypes.UseCountryVAT) {
                value += value * countryVatRate;
            } else {
                value += value * merchantVatRate;
            }
        }
    }

    value = value * fxRate;
    if (productClassCoefficient) {
        value = value / priceCoefficient * productClassCoefficient;
    }

    value = value.toFixed(currencyDecimalPlaces);
    if (skipRounding || roundingRules == null) {
        value = value * quantity;
    } else {
        var ranges = roundingRules.RoundingRanges;
        var range = null;
        for (var r in ranges) {
            var rg = ranges[r];
            if (rg.From < value && value <= rg.To) {
                range = rg;
                break;
            }
        }

        if (range != null) {
            // convert range to form of absolute
            range = ConvertRoundingRangeToAbsolute(value, range);
            // apply logic of absolute range rounding
            value = AbsoluteRounding(value, range) * quantity;

            if (value < 0) {
                value = 0;
            }
        }
    }

    return value;
};


function ConvertRoundingRangeToAbsolute(price, range) {
    var result = null;
    if (range.RangeBehavior == 1) {
        // range already has absolute behavior
        result = range;
    } else {
        result = new Object();
        result.RangeBehavior = range.RangeBehavior;
        result.RoundingExceptions = [];
        result.From = range.From;
        result.To = range.To;

        var int_part = Math.floor(price);

        if (range.RangeBehavior == 2) {
            //Relative Decimal 
            result.LowerTarget = int_part - 1 + range.LowerTarget;
            result.UpperTarget = int_part + range.UpperTarget;
            result.Threshold = int_part + range.Threshold;
            for (var ex in range.RoundingExceptions) {
                range.RoundingExceptions[ex].ExceptionValue += int_part;
                result.RoundingExceptions.push(range.RoundingExceptions[ex]);
            }
        } else if (range.RangeBehavior == 3) {
            // Relative Whole
            if (range.TargetBehaviorHelperValue == 0) {
                range.TargetBehaviorHelperValue = 10;
            }
            var base = Math.floor(price / range.TargetBehaviorHelperValue) * range.TargetBehaviorHelperValue;
            result.LowerTarget = base - range.TargetBehaviorHelperValue + range.LowerTarget;
            result.UpperTarget = base + range.UpperTarget;
            result.Threshold = base + range.Threshold;
            for (var ex in range.RoundingExceptions) {
                range.RoundingExceptions[ex].ExceptionValue += base;
                result.RoundingExceptions.push(range.RoundingExceptions[ex]);
            }
        } else if (range.RangeBehavior == 4) {
            // Nearest target
            if (range.TargetBehaviorHelperValue == 0) {
                range.TargetBehaviorHelperValue = 5;
            }
            var base = Math.floor(price / range.TargetBehaviorHelperValue) * range.TargetBehaviorHelperValue;
            result.LowerTarget = base - 1 + range.LowerTarget;
            result.UpperTarget = base - 1 + range.TargetBehaviorHelperValue + range.UpperTarget;
            result.Threshold = base + range.Threshold;
            for (var ex in range.RoundingExceptions) {
                range.RoundingExceptions[ex].ExceptionValue += base;
                result.RoundingExceptions.push(range.RoundingExceptions[ex]);
            }

        }

    }

    return result;
};

function AbsoluteRounding(price, range) {
    var result = null;
    // check exceptions
    if (range.RoundingExceptions.length > 0) {
        for (var e in range.RoundingExceptions) {
            ex = range.RoundingExceptions[e];
            if (price == ex.ExceptionValue) {
                result = price;
            }
        }
    }
    // no exception was found 
    if (!result) {
        // check threshold
        if (price < range.Threshold) {
            result = range.LowerTarget;
        } else {
            result = range.UpperTarget;
        }
    }

    return result;
};