Subversion Repositories SmartDukaan

package com.spice.profitmandi.dao.service;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
import com.spice.profitmandi.common.model.ProfitMandiConstants;
import com.spice.profitmandi.common.util.Utils;
import com.spice.profitmandi.dao.entity.transaction.FofoSidbiSanction;
import com.spice.profitmandi.dao.repository.dtr.CreditAccountRepository;
import com.spice.profitmandi.dao.repository.transaction.FofoSidbiSanctionRepository;
import com.spice.profitmandi.service.transaction.SDCreditService;
import com.spice.profitmandi.service.wallet.WalletService;
import in.shop2020.model.v1.order.WalletReferenceType;
import org.apache.logging.log4j.LogManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
import java.util.*;
import java.util.stream.Collectors;

@Component
public class SidbiService {

    private static final org.apache.logging.log4j.Logger LOGGER = LogManager.getLogger(SidbiService.class);

    @Autowired
    FofoSidbiSanctionRepository fofoSidbiSanctionRepository;

    @Autowired
    CreditAccountRepository creditAccountRepository;

    private static final double PROCESSING_FEE = 1.18;

    private static final double STAMP_FEE = 200;

    private static final String WALLET_DEDUCTION_NARRATION = "SIDBI Processing Fee @1% + GST@18% + STAMP DUTY(Rs.200)";

    //Logic specific to Sidbi Related Sanctions
    //Assumptions that 1Lac upto 12 months
    private static final List<Integer> PRINCIPAL_DEDUCTIONS_PER_LAC = Arrays.asList(2115, 2147, 2179, 2212, 2245, 2279, 2313, 2348, 2383, 2419, 2455, 2492, 2529, 2567, 2605, 2644, 2683, 2723, 2763, 2804, 2845, 2887, 2929, 2972);
    private static final int CUTOFF_DATE = 10;

    public Map<Integer, BigDecimal> getSuggestedLimitMap() {
        Map<Integer, BigDecimal> fofoSuggetedLimitMap = new HashMap<>();
        List<FofoSidbiSanction> fofoSidbiSanctions = fofoSidbiSanctionRepository.selectAllUnsettled();
        Map<Integer, List<FofoSidbiSanction>> fofoSidbiSanctionMap = fofoSidbiSanctions.stream().collect(Collectors.groupingBy(x -> x.getFofoId()));
        for (Map.Entry<Integer, List<FofoSidbiSanction>> fofoSactionEntry : fofoSidbiSanctionMap.entrySet()) {
            List<FofoSidbiSanction> fofoSidbiSanctionList = fofoSactionEntry.getValue();
            int fofoId = fofoSactionEntry.getKey();
            BigDecimal suggestedLimit = BigDecimal.valueOf(fofoSidbiSanctionList.stream().mapToDouble(x -> x.getUnsettledAmount()).sum());
            fofoSuggetedLimitMap.put(fofoId, suggestedLimit);
        }
        LOGGER.info("GetSuggestedLimitMap - {}", fofoSuggetedLimitMap);
        return fofoSuggetedLimitMap;
    }

    private double getActualLoan(double receivedAmount) {
        double number = Math.ceil(receivedAmount / ProfitMandiConstants.ONE_LAC);
        return number * ProfitMandiConstants.ONE_LAC;
    }

    private double getProcessingDeductions(FofoSidbiSanction fofoSidbiSanction) {
        double processingDeductions = (fofoSidbiSanction.getLoanAmount() * PROCESSING_FEE / 100) + STAMP_FEE;
        System.out.println("Processing deductions  " + processingDeductions);
        return processingDeductions;
    }

    //When advance is deducted from Original disbursements then deduction happens from next month
    private double getAdvancePaid(FofoSidbiSanction fofoSidbiSanction) {
        return fofoSidbiSanction.getLoanAmount() - fofoSidbiSanction.getSanctionAmount() - this.getProcessingDeductions(fofoSidbiSanction);
    }

    private double getDeduction(FofoSidbiSanction fofoSidbiSanction) {
        double deduction = 0d;
        LocalDate loanStartDate = fofoSidbiSanction.getCreatedOn().withDayOfMonth(5).toLocalDate();
        if (fofoSidbiSanction.getAdvanceInterestAmount() > 0d) {
            loanStartDate = loanStartDate.plusMonths(1);
        }
        int monthsBetween = (int) ChronoUnit.MONTHS.between(loanStartDate, LocalDate.now());
        LOGGER.info("loanStartDate - {}, now - {}, monthsBetween - {} ", loanStartDate, LocalDateTime.now(), monthsBetween);
        if (LocalDate.now().getDayOfMonth() < 5) {
            monthsBetween -= 1;
        }
        if (monthsBetween > 0) {
            for (int month = 1; month <= monthsBetween; month++) {
                deduction += PRINCIPAL_DEDUCTIONS_PER_LAC.get(monthsBetween - 1) * (fofoSidbiSanction.getLoanAmount() / ProfitMandiConstants.ONE_LAC);
            }
        }
        LOGGER.info("loanStartDate-  {}, Loan Amount - {}, Deduction - {}", loanStartDate, fofoSidbiSanction.getLoanAmount(), deduction);
        return deduction;
    }

    public void processDeductions() {
        List<FofoSidbiSanction> fofoSidbiSanctions = fofoSidbiSanctionRepository.selectAllUnsettled();
        LOGGER.info("Sanctions Count - {}", fofoSidbiSanctions);
        Map<Integer, List<FofoSidbiSanction>> fofoSidbiSanctionMap = fofoSidbiSanctions.stream().collect(Collectors.groupingBy(x -> x.getFofoId()));
        for (Map.Entry<Integer, List<FofoSidbiSanction>> fofoSactionEntry : fofoSidbiSanctionMap.entrySet()) {
            for (FofoSidbiSanction fofoSidbiSanction : fofoSactionEntry.getValue()) {
                //fofoSidbiSanction.setSettledAmount(0);
                fofoSidbiSanction.setSettledAmount(this.getDeduction(fofoSidbiSanction));
                if (Utils.compareDouble(fofoSidbiSanction.getSettledAmount(), fofoSidbiSanction.getLoanAmount()) == 0) {
                    fofoSidbiSanction.setSettledOn(LocalDateTime.now());
                }
            }
        }
    }

    public void createSanction(int fofoId, LocalDateTime createTimestamp, double receivedAmount) {
        //Add table here
        FofoSidbiSanction fofoSidbiSanction = new FofoSidbiSanction();
        fofoSidbiSanction.setCreatedOn(createTimestamp);
        fofoSidbiSanction.setFofoId(fofoId);
        fofoSidbiSanction.setSanctionAmount(receivedAmount);
        fofoSidbiSanction.setLoanAmount(this.getActualLoan(receivedAmount));
        fofoSidbiSanction.setAdvanceInterestAmount(this.getAdvancePaid(fofoSidbiSanction));
        fofoSidbiSanctionRepository.persist(fofoSidbiSanction);
    }

    public void migrateSanctions() throws ProfitMandiBusinessException {
        List<FofoSidbiSanction> fofoSidbiSanctions = fofoSidbiSanctionRepository.selectAll(Optional.empty());
        for (FofoSidbiSanction fofoSidbiSanction : fofoSidbiSanctions) {
            fofoSidbiSanction.setLoanAmount(this.getActualLoan(fofoSidbiSanction.getSanctionAmount()));
            fofoSidbiSanction.setAdvanceInterestAmount(this.getAdvancePaid(fofoSidbiSanction));
            if (!Arrays.asList(175139259, 175139638).contains(fofoSidbiSanction.getFofoId())) {
                issueLimit(fofoSidbiSanction);
            }
        }
    }

    @Autowired
    WalletService walletService;

    @Autowired
    SDCreditService sdCreditService;

    public void issueLimit(FofoSidbiSanction fofoSidbiSanction) throws ProfitMandiBusinessException {
        if (fofoSidbiSanction.getIssuedOn() != null) {
            throw new ProfitMandiBusinessException("Sidbi Sanction Issue",
                    "Party - " + fofoSidbiSanction.getFofoId() + " - " + fofoSidbiSanction.getLoanAmount(), "");
        }
        fofoSidbiSanction.setIssuedOn(fofoSidbiSanction.getCreatedOn().plusDays(2));
        double deductions = this.getProcessingDeductions(fofoSidbiSanction);
        walletService.consumeAmountFromWallet(fofoSidbiSanction.getFofoId(), fofoSidbiSanction.getId(), WalletReferenceType.ADVANCE_SECURITY, "Deducted to fund advance", (float) deductions, fofoSidbiSanction.getCreatedOn(), true);
        try {
            sdCreditService.fundWallet(fofoSidbiSanction.getFofoId());
        } catch(Exception e) {
            LOGGER.info("Could not fund wallet for - ", fofoSidbiSanction.getFofoId());
        }
    }
}