/ Original
public double calculatePrice(int customerId, int productId, int quantity) {
    Product product = productRepository.findById(productId);

    double singlePrice = product.getSinglePrice();
    double baseTotal = singlePrice * quantity;

    double taxRate = 0.07;
    double totalWithTax = baseTotal + (baseTotal * taxRate);

    double discount = 0.0;
    double loyaltyDiscount = 0.0;
    double bulkDiscount = 0.0;

    Customer customer = customerRepository.findById(customerId);

    if (customer.isSilver()) {
        discount = 0.10;
        if (quantity > 10) {
            bulkDiscount = 0.05;
        }
    } else if (customer.isGold()) {
        discount = 0.15;
        if (quantity > 5) {
            bulkDiscount = 0.10;
        }
    } else if (customer.isPlatinum()) {
        discount = 0.20;
        if (quantity > 3) {
            bulkDiscount = 0.15;
        }
    }

    if (customer.getYearsAsCustomer() > 5) {
        loyaltyDiscount = 0.03;
    }

    double totalDiscount = discount + bulkDiscount + loyaltyDiscount;
    if (totalDiscount > 0.30) {
        totalDiscount = 0.30;
    }

    double discountedPrice = totalWithTax - (totalWithTax * totalDiscount);
    double finalPrice = Math.round(discountedPrice * 100.0) / 100.0;

    return finalPrice;
}

// After Refactoring
public double calculatePrice(int customerId, int productId, int quantity) {
    Product product = productRepository.findById(productId);
    Customer customer = customerRepository.findById(customerId);

    double baseTotal = calculateBaseTotal(product, quantity);
    double totalWithTax = applyTax(baseTotal);
    double totalDiscount = calculateTotalDiscount(customer, quantity);
    double discountedPrice = applyDiscount(totalWithTax, totalDiscount);

    return roundToTwoDecimalPlaces(discountedPrice);
}

private double calculateBaseTotal(Product product, int quantity) {
    return product.getSinglePrice() * quantity;
}

private double applyTax(double baseTotal) {
    double taxRate = 0.07;
    return baseTotal + (baseTotal * taxRate);
}

private double calculateTotalDiscount(Customer customer, int quantity) {
    double tierDiscount = calculateTierDiscount(customer, quantity);
    double loyaltyDiscount = calculateLoyaltyDiscount(customer);
    double totalDiscount = tierDiscount + loyaltyDiscount;

    return Math.min(totalDiscount, 0.30);
}

private double calculateTierDiscount(Customer customer, int quantity) {
    double discount = 0.0;
    double bulkDiscount = 0.0;

    if (customer.isSilver()) {
        discount = 0.10;
        if (quantity > 10) bulkDiscount = 0.05;
    } else if (customer.isGold()) {
        discount = 0.15;
        if (quantity > 5) bulkDiscount = 0.10;
    } else if (customer.isPlatinum()) {
        discount = 0.20;
        if (quantity > 3) bulkDiscount = 0.15;
    }

    return discount + bulkDiscount;
}

private double calculateLoyaltyDiscount(Customer customer) {
    return customer.getYearsAsCustomer() > 5 ? 0.03 : 0.0;
}

private double applyDiscount(double total, double discountRate) {
    return total - (total * discountRate);
}

private double roundToTwoDecimalPlaces(double value) {
    return Math.round(value * 100.0) / 100.0;
}

// With Comments
private void validateProduct(Product product) {
    // Check if the product is null
    if (product == null) {
        throw new IllegalArgumentException("Product cannot be null");
    }

    // Check if the product has a valid name
    if (product.getName() == null || product.getName().trim().isEmpty()) {
        throw new IllegalArgumentException("Product must have a name");
    }

    // Check if the product price is greater than zero
    if (product.getSinglePrice() <= 0) {
        throw new IllegalArgumentException("Product price must be greater than zero");
    }

    // Check if the product category is valid
    if (!isValidCategory(product.getCategory())) {
        throw new IllegalArgumentException("Invalid product category: " + product.getCategory());
    }

    // Check if the product is active
    if (!product.isActive()) {
        throw new IllegalStateException("Product must be active");
    }
}

private boolean isValidCategory(String category) {
    return category != null && List.of("Electronics", "Books", "Clothing", "Food").contains(category);
}

// Without comments
private void validateProduct(Product product) {
    ensureProductIsNotNull(product);
    ensureProductHasName(product);
    ensurePriceIsPositive(product);
    ensureCategoryIsValid(product);
    ensureProductIsActive(product);
}

private void ensureProductIsNotNull(Product product) {
    if (product == null) {
        throw new IllegalArgumentException("Product cannot be null");
    }
}

private void ensureProductHasName(Product product) {
    if (product.getName() == null || product.getName().trim().isEmpty()) {
        throw new IllegalArgumentException("Product must have a name");
    }
}

private void ensurePriceIsPositive(Product product) {
    if (product.getSinglePrice() <= 0) {
        throw new IllegalArgumentException("Product price must be greater than zero");
    }
}

private void ensureCategoryIsValid(Product product) {
    if (!isValidCategory(product.getCategory())) {
        throw new IllegalArgumentException("Invalid product category: " + product.getCategory());
    }
}

private void ensureProductIsActive(Product product) {
    if (!product.isActive()) {
        throw new IllegalStateException("Product must be active");
    }
}

private boolean isValidCategory(String category) {
    return category != null && List.of("Electronics", "Books", "Clothing", "Food").contains(category);
}

// With multiple returns
private double calculateProductDiscount(Customer customer, int quantity) {
    if (customer.isPlatinum()) {
        if (quantity > 10) {
            return 0.25;
        }
        return 0.20;
    }

    if (customer.isGold()) {
        if (quantity > 10) {
            return 0.20;
        }
        return 0.15;
    }

    if (customer.isSilver()) {
        if (quantity > 10) {
            return 0.15;
        }
        return 0.10;
    }

    return 0.0;
}

کد بعدی

//With single return
private double calculateProductDiscount(Customer customer, int quantity) {
    double discount = 0.0;

    if (customer.isPlatinum()) {
        discount = (quantity > 10) ? 0.25 : 0.20;
    } else if (customer.isGold()) {
        discount = (quantity > 10) ? 0.20 : 0.15;
    } else if (customer.isSilver()) {
        discount = (quantity > 10) ? 0.15 : 0.10;
    }

    return discount;
}

public String determineAccessLevel(User user, Resource resource) {
    if (user == null || resource == null) {
        return "DENIED";
    }

    if (!user.isActive()) {
        return "DENIED";
    }

    if (user.isAdmin()) {
        return "FULL_ACCESS";
    } else if (user.isManager() && resource.isInternal()) {
        return "limitED_ACCESS";
    } else if (user.isEmployee()) {
        switch (resource.getType()) {
            case "PUBLIC":
                return "READ_ONLY";
            case "CONFIDENTIAL":
                if (user.hasClearance()) {
                    return "limitED_ACCESS";
                } else {
                    return "DENIED";
                }
            default:
                return "DENIED";
        }
    }

    return "DENIED";
}

public String determineAccessLevel(User user, Resource resource) {
    String accessLevel;

    if (isInvalid(user, resource)) {
        accessLevel = "DENIED";
    } else if (isAdmin(user)) {
        accessLevel = "FULL_ACCESS";
    } else if (isManagerAccess(user, resource)) {
        accessLevel = "limitED_ACCESS";
    } else if (isEmployee(user)) {
        accessLevel = getEmployeeAccessLevel(user, resource);
    } else {
        accessLevel = "DENIED";
    }

    return accessLevel;
}

private boolean isInvalid(User user, Resource resource) {
    return user == null || resource == null || !user.isActive();
}

private boolean isAdmin(User user) {
    return user.isAdmin();
}

private boolean isManagerAccess(User user, Resource resource) {
    return user.isManager() && resource.isInternal();
}

private boolean isEmployee(User user) {
    return user.isEmployee();
}

private String getEmployeeAccessLevel(User user, Resource resource) {
    switch (resource.getType()) {
        case "PUBLIC":
            return "READ_ONLY";
        case "CONFIDENTIAL":
            return user.hasClearance() ? "limitED_ACCESS" : "DENIED";
        default:
            return "DENIED";
    }
}