Design for Splitwise

src/Main.java

@@ -0,0 +1,94 @@
+import model.Identifier;
+import model.InstructionType;
+import model.SplitType;
+import model.TransactionInput;
+import model.ValuePair;
+import service.SplitwiseMainService;
+import service.impl.SplitwiseMainServiceImpl;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class Main {
+    public static void main(String args[]) throws IOException {
+        final SplitwiseMainService splitwiseMainService = new SplitwiseMainServiceImpl();
+        final BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
+        splitwiseMainService.createUser(new Identifier("u3"));
+        splitwiseMainService.createUser(new Identifier("u2"));
+        splitwiseMainService.createUser(new Identifier("u1"));
+        splitwiseMainService.createUser(new Identifier("u4"));
+
+        while(true) {
+            try {
+                final String inputLine = reader.readLine();
+                final String[] input = inputLine.split(" ");
+                if (input[0].equals(InstructionType.EXPENSE.toString())) {
+                    final Identifier payer = new Identifier(input[1]);
+                    final Double amount = Double.parseDouble(input[2]);
+                    final Integer number = Integer.parseInt(input[3]);
+                    final List<ValuePair> valuePairs = new ArrayList<>();
+                    for(int i = 4; i < 4 + number; i++) {
+                        valuePairs.add(new ValuePair(new Identifier(input[i]), 0.0));
+                    }
+
+                    if (!input[4 + number].equals(SplitType.EQUAL.toString())) {
+                        for (int i = 5 + number; i < 5 + 2 * number; i++) {
+                            valuePairs.get(i - number - 5).setValue(Double.parseDouble(input[i]));
+                        }
+                    }
+                    final TransactionInput transactionInput =
+                        TransactionInput.builder()
+                            .amount(amount)
+                            .payer(payer)
+                            .shareParameters(valuePairs)
+                            .splitType(SplitType.valueOf(input[4 + number]))
+                            .build();
+                    splitwiseMainService.addExpense(transactionInput);
+                } else if (input[0].equals(InstructionType.SHOW.toString())) {
+                    if (input.length == 1) {
+                        formatAndDisplayAll(splitwiseMainService.getBalances());
+                    } else {
+                        final Identifier user = new Identifier(input[1]);
+                        formatAndDisplay(user, splitwiseMainService.getBalanceForUser(user), false);
+                    }
+                } else {
+                    throw new RuntimeException(String.format("Did not match any command: %s", inputLine));
+                }
+            } catch (final Exception e) {
+                System.out.println("Error: " + e.getMessage());
+            }
+        }
+    }
+
+    private static void formatAndDisplay(final Identifier user, final Map<Identifier, Double> expenseMap, final Boolean allMode) {
+        if(expenseMap.size() == 0) {
+            System.out.println("No balances");
+        }
+        expenseMap.forEach(
+            ((identifier, aDouble) -> {
+                if(aDouble > 0) {
+                    System.out.println(identifier.getValue() + " owes " + user.getValue() + " " + Math.abs(aDouble));
+                } else if (!allMode) {
+                    System.out.println(user.getValue() + " owes " + identifier.getValue() + " " + Math.abs(aDouble));
+                }
+            })
+        );
+    }
+
+    private static void formatAndDisplayAll(final Map<Identifier, Map<Identifier, Double>> allExpenseMap) {
+        if (allExpenseMap.keySet().stream()
+            .allMatch(key -> allExpenseMap.get(key).size() == 0)) {
+            System.out.println("No balances");
+            return;
+        }
+
+        allExpenseMap.forEach(
+            (userId, expenseMap)  -> {
+                formatAndDisplay(userId, expenseMap, true);
+            });
+    }
+}

src/exception/ShareTypeValidationException.java

@@ -0,0 +1,7 @@
+package exception;
+
+public class ShareTypeValidationException extends IllegalArgumentException{
+    public ShareTypeValidationException(final String msg) {
+        super(msg);
+    }
+}

src/exception/UserAlreadyExistsException.java

@@ -0,0 +1,7 @@
+package exception;
+
+public class UserAlreadyExistsException extends IllegalArgumentException {
+    public UserAlreadyExistsException(String message) {
+        super(message);
+    }
+}

src/model/Identifier.java

@@ -0,0 +1,17 @@
+package model;
+
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NonNull;
+import lombok.ToString;
+
+@Getter
+@ToString
+@EqualsAndHashCode
+public class Identifier {
+    private final String value;
+
+    public Identifier(@NonNull final String value) {
+        this.value = value;
+    }
+}

src/model/InstructionType.java

@@ -0,0 +1,6 @@
+package model;
+
+public enum InstructionType {
+    SHOW,
+    EXPENSE;
+}

src/model/SplitType.java

@@ -0,0 +1,84 @@
+package model;
+
+import exception.ShareTypeValidationException;
+import lombok.NonNull;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public enum SplitType {
+    EQUAL {
+        public Map<Identifier, Double> splitAmount(@NonNull final Double amount, @NonNull final List<ValuePair> shareParameters) {
+            final Integer numberOfUsers = shareParameters.size();
+            final Map<Identifier, Double> shareAmounts = new HashMap<>();
+            final Double amountToBeShared = amount / numberOfUsers;
+            shareParameters
+                .forEach(
+                    shareParameter -> shareAmounts.put(shareParameter.getKey(), truncateToTwoDecimalPlaces(amountToBeShared)));
+            adjustToTwoDecimalPlaces(shareParameters, amount, shareAmounts);
+            return shareAmounts;
+        }
+    },
+    EXACT {
+        public Map<Identifier, Double> splitAmount(@NonNull final Double amount, @NonNull final List<ValuePair> shareParameters) {
+            SplitType.validateTotal(shareParameters, amount);
+            final Map<Identifier, Double> shareAmounts = shareParameters.stream()
+                .collect(Collectors.toMap(ValuePair::getKey, valuePair -> truncateToTwoDecimalPlaces(valuePair.getValue())));
+            adjustToTwoDecimalPlaces(shareParameters, amount, shareAmounts);
+            return shareAmounts;
+        }
+    },
+    PERCENTAGE {
+        public Map<Identifier, Double> splitAmount(@NonNull final Double amount, @NonNull final List<ValuePair> shareParameters) {
+            final Map<Identifier, Double> shareAmounts = new HashMap<>();
+            SplitType.validateTotal(shareParameters, 100.0);
+            shareParameters.forEach(
+                valuePair -> shareAmounts.put(valuePair.getKey(), truncateToTwoDecimalPlaces((valuePair.getValue() * amount)/100)));
+            adjustToTwoDecimalPlaces(shareParameters, amount, shareAmounts);
+            return shareAmounts;
+        }
+    },
+    SHARES {
+        public Map<Identifier, Double> splitAmount(@NonNull final Double amount, @NonNull final List<ValuePair> shareParameters) {
+            final Map<Identifier, Double> shareAmounts = new HashMap<>();
+            final Double shareSum = shareParameters.stream()
+                .map(ValuePair::getValue)
+                .reduce((a, b) -> a + b)
+                .orElseThrow(() -> new ShareTypeValidationException("Error occurred in processing SHARES split"));
+            shareParameters.forEach(
+                valuePair -> shareAmounts.put(valuePair.getKey(), truncateToTwoDecimalPlaces((valuePair.getValue() * amount)/shareSum)));
+            adjustToTwoDecimalPlaces(shareParameters, amount, shareAmounts);
+            return shareAmounts;
+        }
+    };
+
+    private static void validateTotal(final List<ValuePair> valuePairs, final Double amount) {
+        valuePairs.stream()
+            .map(ValuePair::getValue)
+            .reduce((a, b) -> a + b)
+            .filter(sumAmount -> sumAmount.equals(amount))
+            .orElseThrow(() -> new ShareTypeValidationException("Values do not add for split"));
+    }
+
+    private static Double truncateToTwoDecimalPlaces(final Double amount) {
+        return Math.floor(amount * 100)/100;
+    }
+
+    private static void adjustToTwoDecimalPlaces(final List<ValuePair> shareParameters,
+                                                 final Double amount,
+                                                 final Map<Identifier, Double> expenses) {
+        final Double totalAmount = expenses.keySet().stream()
+            .map(expenses::get)
+            .reduce((a, b) -> a + b).get();
+
+        if (!totalAmount.equals(amount)) {
+            final Double diff = amount - totalAmount;
+            expenses.put(shareParameters.get(0).getKey(), expenses.get(shareParameters.get(0).getKey()) + diff);
+        }
+    }
+
+    public abstract Map<Identifier, Double> splitAmount(@NonNull final Double amount, @NonNull final List<ValuePair> shareParameters);
+
+}

src/model/TransactionInput.java

@@ -0,0 +1,34 @@
+package model;
+
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NonNull;
+
+import java.util.List;
+
+@Builder(toBuilder = true)
+@Getter
+public class TransactionInput {
+    @NonNull
+    private final Identifier payer;
+
+    @NonNull
+    private final SplitType splitType;
+
+    @NonNull
+    private final List<ValuePair> shareParameters;
+
+    @NonNull
+    private final Double amount;
+
+    public static class TransactionInputBuilder {
+        public TransactionInputBuilder amount(Double amount) {
+            final Double truncatedAmount = Math.floor(amount * 100)/100;
+            if(!truncatedAmount.equals(amount)) {
+                throw new IllegalArgumentException("More than two digits specified in input amount");
+            }
+            this.amount = amount;
+            return this;
+        }
+    }
+}

src/model/User.java

@@ -0,0 +1,21 @@
+package model;
+
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NonNull;
+
+import java.util.Map;
+
+@Builder
+@Getter
+public class User {
+    @NonNull
+    private Identifier identifier;
+
+    private String name;
+
+    private String email;
+
+    @NonNull
+    private Map<Identifier, Double> balances;
+}

src/model/ValuePair.java

@@ -0,0 +1,14 @@
+package model;
+
+import lombok.Data;
+import lombok.NonNull;
+
+@Data
+public class ValuePair {
+    @NonNull
+    private final Identifier key;
+
+    @NonNull
+    private Double value;
+
+}

src/service/SplitwiseMainService.java

@@ -0,0 +1,16 @@
+package service;
+
+import model.Identifier;
+import model.TransactionInput;
+
+import java.util.Map;
+
+public interface SplitwiseMainService {
+    public void createUser(Identifier userId);
+
+    public void addExpense(TransactionInput transaction);
+
+    public Map<Identifier, Map<Identifier, Double>> getBalances();
+
+    public Map<Identifier, Double> getBalanceForUser(Identifier userId);
+}