Subversion Repositories SmartDukaan

package com.spice.profitmandi.service.offers;

import java.io.IOException;

import java.io.InputStream;

import java.time.LocalDate;

import java.time.YearMonth;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.stream.Collectors;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.apache.poi.ss.usermodel.Cell;

import org.apache.poi.ss.usermodel.CellType;

import org.apache.poi.ss.usermodel.Row;

import org.apache.poi.ss.usermodel.Row.MissingCellPolicy;

import org.apache.poi.xssf.usermodel.XSSFRow;

import org.apache.poi.xssf.usermodel.XSSFSheet;

import org.apache.poi.xssf.usermodel.XSSFWorkbook;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.cache.annotation.Cacheable;

import org.springframework.stereotype.Component;

import com.google.common.collect.Lists;

import com.google.gson.Gson;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;

import com.spice.profitmandi.common.model.PartnerTargetModel;

import com.spice.profitmandi.common.model.ProfitMandiConstants;

import com.spice.profitmandi.dao.entity.catalog.ItemCriteria;

import com.spice.profitmandi.dao.entity.catalog.Offer;

import com.spice.profitmandi.dao.entity.catalog.TagListing;

import com.spice.profitmandi.dao.entity.catalog.TargetSlab;

import com.spice.profitmandi.dao.enumuration.catalog.AmountType;

import com.spice.profitmandi.dao.enumuration.catalog.OfferSchemeType;

import com.spice.profitmandi.dao.model.CreateOfferRequest;

import com.spice.profitmandi.dao.model.ItemCriteriaPayout;

import com.spice.profitmandi.dao.repository.catalog.ItemCriteriaRepository;

import com.spice.profitmandi.dao.repository.catalog.ItemRepository;

import com.spice.profitmandi.dao.repository.catalog.OfferRepository;

import com.spice.profitmandi.dao.repository.catalog.OfferTargetSlabRepository;

import com.spice.profitmandi.dao.repository.catalog.TagListingRepository;

import com.spice.profitmandi.service.user.RetailerService;

@Component

public class OfferServiceImpl implements OfferService {

	private static final List<String> targets = Arrays.asList("Target 1", "Target 2", "Target 3", "Target 4",

			"Target 5");

	@Autowired

	private Gson gson;

	@Autowired

	private OfferRepository offerRepository;

	@Autowired

	private RetailerService retailerService;

	@Autowired

	private ItemCriteriaRepository itemCriteriaRepository;

	@Autowired

	private ItemRepository itemRepository;

	@Autowired

	private TagListingRepository tagListingRepository;

	@Autowired

	private OfferTargetSlabRepository targetSlabRepository;

	private static final Logger LOGGER = LogManager.getLogger(OfferServiceImpl.class);

	@Override

	public void addOfferService(CreateOfferRequest createOfferRequest) throws ProfitMandiBusinessException {

		LOGGER.info("createOfferRequest  -- {}", createOfferRequest);

		this.createOffer(createOfferRequest);

		this.createTargetSlabs(createOfferRequest);

	}

	private void createOffer(CreateOfferRequest createOfferRequest) {

		Offer offer = new Offer();

		offer.setName(createOfferRequest.getName());

		offer.setTargetType(createOfferRequest.getTargetType());

		offer.setPayoutType(createOfferRequest.getPayoutType());

		offer.setSchemeType(createOfferRequest.getSchemeType());

		offer.setIncrementalTarget(createOfferRequest.isIncrementalTarget());

		offer.setEndDate(createOfferRequest.getEndDate());

		offer.setStartDate(createOfferRequest.getStartDate());

		offer.setBrandSharePercentage(createOfferRequest.getBrandShareTerms());

		offer.setSellinPercentage(createOfferRequest.getSellinPercentage());

		offer.setOfferNotes(createOfferRequest.getOfferNotes());

		offer.setActivationBrands(createOfferRequest.getActivationBrands());

		offer.setTerms(createOfferRequest.getTerms());

		offer.setItemCriteria(gson.toJson(createOfferRequest.getItemCriteria()));

		offer.setPartnerCriteria(gson.toJson(createOfferRequest.getPartnerCriteria()));

		offerRepository.persist(offer);

		createOfferRequest.setId(offer.getId());

	}

	@Override

	public List<CreateOfferRequest> getPublishedOffers(int fofoId, YearMonth yearMonth) {

		List<Offer> publishedOffers = offerRepository.selectAllPublishedMapByPartner(yearMonth).get(fofoId);

		List<CreateOfferRequest> createOfferRequests = new ArrayList<>();

		if (publishedOffers != null) {

			for (Offer offer : publishedOffers) {

				CreateOfferRequest createOfferRequest = this.getCreateOfferRequest(offer);

				createOfferRequests.add(createOfferRequest);

				setCriteriaPayoutAchieved(fofoId, createOfferRequest);

			}

		}

		return createOfferRequests;

	}

	private void setCriteriaPayoutAchieved(int fofoId, CreateOfferRequest createOfferRequest) {

		Map<Integer, Long> criteriaTransactionMap = null;

		if (createOfferRequest.getSchemeType().equals(OfferSchemeType.SELLIN)) {

			criteriaTransactionMap = offerRepository.getPartnerWisePurchaseSum(createOfferRequest).get(fofoId);

		} else {

			criteriaTransactionMap = offerRepository.getPartnerWiseSalesSum(createOfferRequest).get(fofoId);

		}

		LOGGER.info("I am here ------- {}", createOfferRequest.getId());

		List<com.spice.profitmandi.dao.model.ItemCriteriaPayout> itemCriteriaPayouts = createOfferRequest

				.getTargetSlabs().get(0).getItemCriteriaPayouts();

		for (com.spice.profitmandi.dao.model.ItemCriteriaPayout itemCriteriaPayout : itemCriteriaPayouts) {

			itemCriteriaPayout.setNextSlab(null);

			LOGGER.info("I am here --- {}", itemCriteriaPayout.getPayoutSlabs());

			long saleAmount = 0;

			if (criteriaTransactionMap != null

					&& criteriaTransactionMap.containsKey(itemCriteriaPayout.getItemCriteria().getId())) {

				saleAmount = criteriaTransactionMap.get(itemCriteriaPayout.getItemCriteria().getId());

			}

			itemCriteriaPayout.setAchievedValue(saleAmount);

			List<com.spice.profitmandi.service.offers.PayoutSlab> payoutSlabs = itemCriteriaPayout.getPayoutSlabs();

			for (int i = 0; i < payoutSlabs.size(); i++) {

				com.spice.profitmandi.service.offers.PayoutSlab beginSlab = payoutSlabs.get(i);

				com.spice.profitmandi.service.offers.PayoutSlab endSlab = null;

				if (payoutSlabs.size() - 1 > i) {

					endSlab = payoutSlabs.get(i + 1);

				}

				if (beginSlab.getOnwardsAmount() > saleAmount) {

					itemCriteriaPayout.setShortValue(beginSlab.getOnwardsAmount() - saleAmount);

					itemCriteriaPayout.setNextSlab(beginSlab);

					LOGGER.info("I am here");

					break;

				}

				if (endSlab != null) {

					if (beginSlab.getOnwardsAmount() <= saleAmount && endSlab.getOnwardsAmount() > saleAmount) {

						itemCriteriaPayout.setCurrentSlab(beginSlab);

						beginSlab.setSelected(true);

						itemCriteriaPayout.setNextSlab(endSlab);

						itemCriteriaPayout.setShortValue(endSlab.getOnwardsAmount() - saleAmount);

						LOGGER.info("I am here");

						break;

					}

					// Last loop

				} else {

					beginSlab.setSelected(true);

					itemCriteriaPayout.setCurrentSlab(beginSlab);

					LOGGER.info("I am here");

				}

			}

			LOGGER.info("I am here --- {}", itemCriteriaPayout);

		}

	}

	@Override

	@Cacheable(value = "allOffers", cacheManager = "thirtyMinsTimeOutCacheManager")

	public Map<Integer, CreateOfferRequest> getAllOffers(YearMonth yearMonth) {

		List<Offer> allOffers = offerRepository.selectAll(yearMonth, false);

		List<CreateOfferRequest> createOfferRequests = new ArrayList<>();

		for (Offer offer : allOffers) {

			CreateOfferRequest createOfferRequest = this.getCreateOfferRequest(offer);

			createOfferRequests.add(createOfferRequest);

		}

		return createOfferRequests.stream().collect(Collectors.toMap(CreateOfferRequest::getId, x -> x));

	}

	@Override

	@Cacheable(value = "partnerOffers", cacheManager = "thirtyMinsTimeOutCacheManager")

	public CreateOfferRequest getOffer(int fofoId, int offerId) {

		Offer offer = offerRepository.selectById(offerId);

		CreateOfferRequest createOfferRequest = this.getCreateOfferRequest(offer);

		if (fofoId > 0) {

			this.setCriteriaPayoutAchieved(fofoId, createOfferRequest);

		}

		return createOfferRequest;

	}

	private CreateOfferRequest getCreateOfferRequest(Offer fromOffer) {

		CreateOfferRequest createOfferRequest = new CreateOfferRequest();

		createOfferRequest.setName(fromOffer.getName());

		createOfferRequest.setTargetType(fromOffer.getTargetType());

		createOfferRequest.setPayoutType(fromOffer.getPayoutType());

		createOfferRequest.setSchemeType(fromOffer.getSchemeType());

		createOfferRequest.setActivationBrands(fromOffer.getActivationBrands());

		createOfferRequest.setEndDate(fromOffer.getEndDate());

		createOfferRequest.setStartDate(fromOffer.getStartDate());

		createOfferRequest.setActive(fromOffer.isActive());

		createOfferRequest.setSellinPercentage(fromOffer.getSellinPercentage());

		createOfferRequest.setBrandShareTerms(fromOffer.getBrandSharePercentage());

		createOfferRequest.setOfferNotes(fromOffer.getOfferNotes());

		createOfferRequest.setTerms(fromOffer.getTerms());

		createOfferRequest.setItemCriteria(

				gson.fromJson(fromOffer.getItemCriteria(), com.spice.profitmandi.service.offers.ItemCriteria.class));

		createOfferRequest.setPartnerCriteria(gson.fromJson(fromOffer.getPartnerCriteria(), PartnerCriteria.class));

		createOfferRequest.setId(fromOffer.getId());

		createOfferRequest.setCreatedOn(fromOffer.getCreatedTimestamp());

		createOfferRequest.setItemCriteriaString(

				itemCriteriaRepository.getItemCriteriaDescription(createOfferRequest.getItemCriteria()));

		List<com.spice.profitmandi.dao.model.TargetSlab> targetSlabs = targetSlabRepository

				.getByOfferId(fromOffer.getId());

		createOfferRequest.setPartnerCriteriaString(

				retailerService.getPartnerCriteriaString(createOfferRequest.getPartnerCriteria()));

		createOfferRequest.setTargetSlabs(targetSlabs);

		for (com.spice.profitmandi.dao.model.ItemCriteriaPayout itemCriteriaPayout : createOfferRequest.getTargetSlabs()

				.get(0).getItemCriteriaPayouts()) {

			itemCriteriaPayout.setNextSlab(itemCriteriaPayout.getPayoutSlabs().get(0));

		}

		return createOfferRequest;

	}

	private void createTargetSlabs(CreateOfferRequest createOfferRequest) throws ProfitMandiBusinessException {

		List<com.spice.profitmandi.dao.model.TargetSlab> targetSlabs = createOfferRequest.getTargetSlabs().stream()

				.filter(x -> x.validate()).collect(Collectors.toList());

		if (targetSlabs.size() >= 0) {

			Collections.sort(targetSlabs);

			for (com.spice.profitmandi.dao.model.TargetSlab targetSlab : targetSlabs) {

				if (targetSlab.validate()) {

					List<ItemCriteriaPayout> itemCriteriaPayouts = targetSlab.getItemCriteriaPayouts();

					for (ItemCriteriaPayout itemCriteriaPayout : itemCriteriaPayouts) {

						String itemCriteriaJson = gson.toJson(itemCriteriaPayout.getItemCriteria());

						ItemCriteria itemCriteria = itemCriteriaRepository.selectByCriteria(itemCriteriaJson);

						// ItemCriteria Only once

						if (itemCriteria == null) {

							itemCriteria = new ItemCriteria();

							itemCriteria.setCriteria(gson.toJson(itemCriteriaPayout.getItemCriteria()));

							itemCriteriaRepository.persist(itemCriteria);

						}

						for (PayoutSlab payoutSlab : itemCriteriaPayout.getPayoutSlabs()) {

							TargetSlab targetSlab1 = new TargetSlab();

							targetSlab1.setOfferId(createOfferRequest.getId());

							targetSlab1.setOnwardsTarget(targetSlab.getOnwardsAmount());

							targetSlab1.setTargetDescription(targetSlab.getTargetDescription());

							targetSlab1.setPayoutTarget(payoutSlab.getOnwardsAmount());

							targetSlab1.setPayoutValue(payoutSlab.getPayoutAmount());

							targetSlab1.setItemCriteriaId(itemCriteria.getId());

							targetSlab1.setAmountType(itemCriteriaPayout.getAmountType());

							targetSlabRepository.persist(targetSlab1);

						}

					}

				}

			}

		} else {

			throw new ProfitMandiBusinessException("Invalid Target Slabs", "Invalid Target", "");

		}

	}

	@Override

	public List<CreateOfferRequest> getPublishedOffers(LocalDate date, int fofoId, int itemId) {

		List<Offer> publishedOffers = offerRepository.selectAllPublishedMapByPartner(YearMonth.from(date)).get(fofoId);

		List<CreateOfferRequest> createOfferRequests = new ArrayList<>();

		if (publishedOffers != null) {

			for (Offer offer : publishedOffers) {

				boolean found = false;

				List<com.spice.profitmandi.dao.model.TargetSlab> targetSlabs = targetSlabRepository

						.getByOfferId(offer.getId());

				CreateOfferRequest createOfferRequest = this.getCreateOfferRequest(offer);

				createOfferRequest.setTargetSlabs(targetSlabs);

				Set<com.spice.profitmandi.service.offers.ItemCriteria> itemCriteriaSet = targetSlabs.stream()

						.flatMap(x -> x.getItemCriteriaPayouts().stream()).map(x -> x.getItemCriteria()).distinct()

						.filter(x -> itemRepository.containsItem(x, itemId)).collect(Collectors.toSet());

				for (com.spice.profitmandi.dao.model.TargetSlab targetSlab : targetSlabs) {

					targetSlab.setItemCriteriaPayouts(targetSlab.getItemCriteriaPayouts().stream()

							.filter(x -> itemCriteriaSet.contains(x.getItemCriteria())).collect(Collectors.toList()));

					if (targetSlab.getItemCriteriaPayouts().size() > 0) {

						found = true;

					}

				}

				if (found) {

					createOfferRequests.add(createOfferRequest);

				}

			}

		}

		return createOfferRequests;

	}

	@Override

	public void createOffers(InputStream fileInputStream) throws Exception {

		Map<CreateOfferRequest, List<PartnerTargetModel>> offerPartnerTargetMap = this.parseFromExcel(fileInputStream);

		for (Map.Entry<CreateOfferRequest, List<PartnerTargetModel>> partnerTargetEntry : offerPartnerTargetMap

				.entrySet()) {

			CreateOfferRequest createOfferRequest = partnerTargetEntry.getKey();

			Map<List<Integer>, List<Integer>> targetPartnerMap = partnerTargetEntry.getValue().stream()

					.collect(Collectors.groupingBy(PartnerTargetModel::getTargets,

							Collectors.mapping(PartnerTargetModel::getFofoId, Collectors.toList())));

			for (Map.Entry<List<Integer>, List<Integer>> targetPartnersEntry : targetPartnerMap.entrySet()) {

				List<Integer> fofoIds = createOfferRequest.getPartnerCriteria().getFofoIds();

				List<Integer> filterFofoIds = targetPartnersEntry.getValue().stream().filter(x -> !fofoIds.contains(x))

						.collect(Collectors.toList());

				List<Integer> targets = targetPartnersEntry.getKey();

				createOfferRequest.getPartnerCriteria().setFofoIds(filterFofoIds);

				int counter = 0;

				ItemCriteriaPayout itemCriteriaPayout = createOfferRequest.getTargetSlabs().get(0)

						.getItemCriteriaPayouts().get(0);

				for (PayoutSlab payoutSlab : itemCriteriaPayout.getPayoutSlabs()) {

					payoutSlab.setOnwardsAmount(targets.get(counter));

					counter++;

				}

			}

			this.addOfferService(createOfferRequest);

		}

	}

	private Map<CreateOfferRequest, List<PartnerTargetModel>> parseFromExcel(InputStream inputStream)

			throws ProfitMandiBusinessException {

		Map<CreateOfferRequest, List<PartnerTargetModel>> offerPartnerTargetMap = new HashMap<>();

		XSSFWorkbook myWorkBook = null;

		try {

			myWorkBook = new XSSFWorkbook(inputStream);

			myWorkBook.setMissingCellPolicy(MissingCellPolicy.RETURN_BLANK_AS_NULL);

			for (int i = 0; i < myWorkBook.getNumberOfSheets(); i++) {

				XSSFSheet mySheet = myWorkBook.getSheetAt(i);

				int offerId = Integer.parseInt(mySheet.getSheetName());

				CreateOfferRequest existingOffer = this.getOffer(0, offerId);

				List<PartnerTargetModel> partnerTargetModels = new ArrayList<>();

				offerPartnerTargetMap.put(existingOffer, partnerTargetModels);

				this.printIterator(mySheet);

				LOGGER.info("rowCellNum {}", mySheet.getLastRowNum());

				for (int rowNumber = 1; rowNumber <= mySheet.getLastRowNum(); rowNumber++) {

					XSSFRow row = mySheet.getRow(rowNumber);

					LOGGER.info("row {}", row);

					PartnerTargetModel partnerTargetModel = new PartnerTargetModel();

					if (row.getCell(0) != null && row.getCell(0).getCellTypeEnum() == CellType.NUMERIC) {

						partnerTargetModel.setFofoId((int) row.getCell(0).getNumericCellValue());

					} else {

						ProfitMandiBusinessException profitMandiBusinessException = new ProfitMandiBusinessException(

								"FOFO ID", row.getCell(0).toString(), "TGLSTNG_VE_1010");

						LOGGER.error("Excel file parse error : ", profitMandiBusinessException);

						throw profitMandiBusinessException;

					}

					List<Integer> targets = new ArrayList<>();

					for (int cellNumber = 1; cellNumber <= existingOffer.getTargetSlabs().size(); cellNumber++) {

						if (row.getCell(cellNumber) != null

								&& row.getCell(cellNumber).getCellTypeEnum() == CellType.NUMERIC) {

							targets.add((int) row.getCell(cellNumber).getNumericCellValue());

						} else {

							ProfitMandiBusinessException profitMandiBusinessException = new ProfitMandiBusinessException(

									"Target Column issue at " + rowNumber + ", " + cellNumber, row.getCell(cellNumber),

									"Invalid target");

							LOGGER.error("Excel file parse error : ", profitMandiBusinessException);

							throw profitMandiBusinessException;

						}

					}

					partnerTargetModel.setTargets(targets);

					partnerTargetModels.add(partnerTargetModel);

				}

			}

			myWorkBook.close();

		} catch (ProfitMandiBusinessException pbse) {

			throw pbse;

		} catch (IOException ioException) {

			ioException.printStackTrace();

			throw new ProfitMandiBusinessException(ProfitMandiConstants.EXCEL_FILE, ioException.getMessage(),

					"EXL_VE_1000");

		} finally {

			if (myWorkBook != null) {

				try {

					myWorkBook.close();

				} catch (IOException e) {

					// TODO Auto-generated catch block

					e.printStackTrace();

				}

			}

		}

		LOGGER.info("offerPartnerTargetMap {}", offerPartnerTargetMap);

		return offerPartnerTargetMap;

	}

	private void printIterator(XSSFSheet sheet) {

		Iterator<Row> rowIterator = sheet.iterator();

		while (rowIterator.hasNext()) {

			Row row = rowIterator.next();

			// For each row, iterate through all the columns

			Iterator<Cell> cellIterator = row.cellIterator();

			while (cellIterator.hasNext()) {

				Cell cell = cellIterator.next();

				// Check the cell type and format accordingly

				switch (cell.getCellType()) {

				case Cell.CELL_TYPE_NUMERIC:

					System.out.print(cell.getNumericCellValue() + "t");

					break;

				case Cell.CELL_TYPE_STRING:

					System.out.print(cell.getStringCellValue() + "t");

					break;

				}

			}

			System.out.println("");

		}

	}

	@Override

	public Map<Integer, CreateOfferRequest> getPublishedOffers(LocalDate date, int fofoId, String brand) {

		// TODO Auto-generated method stub

		return null;

	}

	@Override

	@Cacheable(value = "slabPayoutMap", cacheManager = "thirtyMinsTimeOutCacheManager")

	public Map<Integer, Map<Integer, Long>> getSlabPayoutMap(CreateOfferRequest createOfferRequest) {

		Map<Integer, Map<Integer, Long>> itemSlabPayoutMap = new HashMap<>();

		List<com.spice.profitmandi.dao.model.TargetSlab> targetSlabs = createOfferRequest.getTargetSlabs();

		com.spice.profitmandi.dao.model.TargetSlab targetSlab = targetSlabs.get(0);

		List<ItemCriteriaPayout> payouts = targetSlab.getItemCriteriaPayouts();

		for (ItemCriteriaPayout itemCriteriaPayout : payouts) {

			com.spice.profitmandi.service.offers.ItemCriteria itemCriteria = itemCriteriaPayout.getItemCriteria();

			List<Integer> itemIds = itemRepository.getItems(itemCriteria);

			for (PayoutSlab payoutSlab : Lists.reverse(itemCriteriaPayout.getPayoutSlabs())) {

				if (itemCriteriaPayout.getAmountType().equals(AmountType.FIXED)) {

					for (Integer itemId : itemIds) {

						if (!itemSlabPayoutMap.containsKey(itemId)) {

							itemSlabPayoutMap.put(itemId, new LinkedHashMap<>());

						}

						itemSlabPayoutMap.get(itemId).put(payoutSlab.getOnwardsAmount(),

								(long) payoutSlab.getPayoutAmount());

					}

				} else if (itemCriteriaPayout.getAmountType().equals(AmountType.SLAB_FIXED)) {

					for (Integer itemId : itemIds) {

						if (!itemSlabPayoutMap.containsKey(itemId)) {

							itemSlabPayoutMap.put(itemId, new LinkedHashMap<>());

						}

						itemSlabPayoutMap.get(itemId).put(payoutSlab.getOnwardsAmount(),

								(long) (payoutSlab.getPayoutAmount() / payoutSlab.getOnwardsAmount()));

					}

				} else if (itemCriteriaPayout.getAmountType().equals(AmountType.PERCENTAGE)) {

					List<TagListing> tagListings = tagListingRepository.selectByItemIdsAndTagIds(new HashSet<>(itemIds),

							null);

					for (TagListing tagListing : tagListings) {

						float taxableSellingPrice = tagListing.getSellingPrice() / (1 + 18f / 100);

						if (!itemSlabPayoutMap.containsKey(tagListing.getItemId())) {

							itemSlabPayoutMap.put(tagListing.getItemId(), new LinkedHashMap<>());

						}

						itemSlabPayoutMap.get(tagListing.getItemId()).put(payoutSlab.getOnwardsAmount(),

								(long) (taxableSellingPrice * payoutSlab.getPayoutAmount() / 100));

					}

				}

			}

		}

		return itemSlabPayoutMap;

	}

}