Subversion Repositories SmartDukaan

package com.spice.profitmandi.service.scheme;

import java.time.LocalDateTime;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.HashSet;

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.springframework.beans.factory.annotation.Autowired;

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

import org.springframework.stereotype.Component;

import com.spice.profitmandi.common.enumuration.ItemType;

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

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

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

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

import com.spice.profitmandi.common.util.StringUtils;

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

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

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

import com.spice.profitmandi.dao.entity.fofo.FofoLineItem;

import com.spice.profitmandi.dao.entity.fofo.FofoOrder;

import com.spice.profitmandi.dao.entity.fofo.FofoOrderItem;

import com.spice.profitmandi.dao.entity.fofo.InventoryItem;

import com.spice.profitmandi.dao.entity.fofo.Purchase;

import com.spice.profitmandi.dao.entity.fofo.ScanRecord;

import com.spice.profitmandi.dao.entity.fofo.SchemeInOut;

import com.spice.profitmandi.dao.entity.fofo.SchemeItem;

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

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

import com.spice.profitmandi.dao.enumuration.fofo.ScanType;

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

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

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

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

import com.spice.profitmandi.dao.repository.dtr.RetailerRepository;

import com.spice.profitmandi.dao.repository.fofo.FofoLineItemRepository;

import com.spice.profitmandi.dao.repository.fofo.FofoOrderItemRepository;

import com.spice.profitmandi.dao.repository.fofo.FofoOrderRepository;

import com.spice.profitmandi.dao.repository.fofo.InventoryItemRepository;

import com.spice.profitmandi.dao.repository.fofo.PurchaseRepository;

import com.spice.profitmandi.dao.repository.fofo.ScanRecordRepository;

import com.spice.profitmandi.dao.repository.fofo.SchemeInOutRepository;

import com.spice.profitmandi.dao.repository.fofo.SchemeItemRepository;

import com.spice.profitmandi.service.authentication.RoleManager;

import com.spice.profitmandi.service.wallet.WalletService;

import in.shop2020.model.v1.order.WalletReferenceType;

@Component

public class SchemeServiceImpl implements SchemeService {

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

	@Autowired

	@Qualifier("fofoInventoryItemRepository")

	private InventoryItemRepository inventoryItemRepository;

	@Autowired

	private ScanRecordRepository scanRecordRepository;

	@Autowired

	private SchemeRepository schemeRepository;

	@Autowired

	private RoleManager roleManager;

	@Autowired

	private RetailerRepository retailerRepository;

	@Autowired

	private TagListingRepository tagListingRepository;

	@Autowired

	private RetailerSchemeRepository retailerSchemeRepository;

	@Autowired

	private SchemeInOutRepository schemeInOutRepository;

	@Autowired

	@Qualifier("catalogItemRepository")

	private ItemRepository itemRepository;

	@Autowired

	private SchemeItemRepository schemeItemRepository;

	@Autowired

	private WalletService walletService;

	@Autowired

	private FofoOrderItemRepository fofoOrderItemRepository;

	@Autowired

	private FofoLineItemRepository fofoLineItemRepository;

	@Autowired

	private PurchaseRepository purchaseRepository;

	@Autowired

	private FofoOrderRepository fofoOrderRepository;

	@Override

	public void saveScheme(int creatorId, CreateSchemeRequest createSchemeRequest) throws ProfitMandiBusinessException {

		this.validateCreateSchemeRequest(createSchemeRequest);

		Scheme scheme = this.toScheme(creatorId, createSchemeRequest);

		if (scheme.getStartDateTime().isAfter(scheme.getEndDateTime())) {

			throw new ProfitMandiBusinessException(

					ProfitMandiConstants.START_DATE + ", " + ProfitMandiConstants.END_DATE,

					scheme.getStartDateTime() + ", " + scheme.getEndDateTime(), "SCHM_VE_1005");

		}

		this.validateItemIds(createSchemeRequest);

		schemeRepository.persist(scheme);

		if (!createSchemeRequest.isRetailerAll()) {

			this.validateRetailerIds(createSchemeRequest);

			for (int retailerId : createSchemeRequest.getRetailerIds()) {

				RetailerScheme retailerScheme = new RetailerScheme();

				retailerScheme.setRetailerId(retailerId);

				retailerScheme.setSchemeId(scheme.getId());

				retailerSchemeRepository.persist(retailerScheme);

			}

		}

		for (int itemId : createSchemeRequest.getItemIds()) {

			SchemeItem schemeItem = new SchemeItem();

			schemeItem.setSchemeId(scheme.getId());

			schemeItem.setItemId(itemId);

			schemeItemRepository.persist(schemeItem);

		}

	}

	private void validateCreateSchemeRequest(CreateSchemeRequest createSchemeRequest)

			throws ProfitMandiBusinessException {

		if (createSchemeRequest.getName() == null || createSchemeRequest.getName().isEmpty()) {

			throw new ProfitMandiBusinessException(ProfitMandiConstants.NAME, createSchemeRequest.getName(),

					"SCHM_VE_1000");

		}

		if (createSchemeRequest.getAmount() <= 0) {

			throw new ProfitMandiBusinessException(ProfitMandiConstants.AMOUNT, createSchemeRequest.getAmount(),

					"SCHM_VE_1001");

		}

		if (AmountType.valueOf(createSchemeRequest.getAmountType()) == AmountType.PERCENTAGE

				&& createSchemeRequest.getAmount() > 100) {

			throw new ProfitMandiBusinessException(ProfitMandiConstants.AMOUNT, createSchemeRequest.getAmount(),

					"SCHM_VE_1002");

		}

		if (createSchemeRequest.getStartDate() == null) {

			throw new ProfitMandiBusinessException(ProfitMandiConstants.START_DATE, createSchemeRequest.getStartDate(),

					"SCHM_VE_1003");

		}

		if (createSchemeRequest.getEndDate() == null) {

			throw new ProfitMandiBusinessException(ProfitMandiConstants.END_DATE, createSchemeRequest.getEndDate(),

					"SCHM_VE_1004");

		}

	}

	private Scheme toScheme(int creatorId, CreateSchemeRequest createSchemeRequest) {

		Scheme scheme = new Scheme();

		scheme.setName(createSchemeRequest.getName());

		scheme.setDescription(createSchemeRequest.getDescription());

		scheme.setType(SchemeType.valueOf(createSchemeRequest.getType()));

		scheme.setAmountType(AmountType.valueOf(createSchemeRequest.getAmountType()));

		scheme.setAmount(createSchemeRequest.getAmount());

		scheme.setStartDateTime(createSchemeRequest.getStartDate());

		scheme.setEndDateTime(createSchemeRequest.getEndDate());

		scheme.setCreatedBy(creatorId);

		scheme.setRetailerAll(createSchemeRequest.isRetailerAll());

		return scheme;

	}

	private void validateRetailerIds(CreateSchemeRequest createSchemeRequest) throws ProfitMandiBusinessException {

		if (createSchemeRequest.getRetailerIds() == null || createSchemeRequest.getRetailerIds().isEmpty()) {

			throw new ProfitMandiBusinessException(ProfitMandiConstants.RETAILER_ID,

					createSchemeRequest.getRetailerIds(), "SCHM_1001");

		}

		List<Integer> foundRetailerIds = retailerRepository.selectIdsByIds(createSchemeRequest.getRetailerIds());

		if (foundRetailerIds.size() != createSchemeRequest.getRetailerIds().size()) {

			createSchemeRequest.getRetailerIds().removeAll(foundRetailerIds);

			throw new ProfitMandiBusinessException(ProfitMandiConstants.RETAILER_ID,

					createSchemeRequest.getRetailerIds(), "SCHM_1002");

		}

	}

	private void validateItemIds(CreateSchemeRequest createSchemeRequest) throws ProfitMandiBusinessException {

		if (createSchemeRequest.getItemIds() == null || createSchemeRequest.getItemIds().isEmpty()) {

			throw new ProfitMandiBusinessException(ProfitMandiConstants.ITEM_ID, createSchemeRequest.getItemIds(),

					"SCHM_1003");

		}

		List<Integer> foundItemIds = itemRepository.selectIdsByIdsAndType(createSchemeRequest.getItemIds(),

				ItemType.SERIALIZED);

		if (foundItemIds.size() != createSchemeRequest.getItemIds().size()) {

			createSchemeRequest.getItemIds().removeAll(foundItemIds);

			throw new ProfitMandiBusinessException(ProfitMandiConstants.ITEM_ID, createSchemeRequest.getItemIds(),

					"SCHM_1004");

		}

	}

	@Override

	public Scheme getSchemeById(int schemeId) throws ProfitMandiBusinessException {

		Scheme scheme = schemeRepository.selectById(schemeId);

		if (!scheme.isRetailerAll()) {

			List<Integer> retailerIds = retailerSchemeRepository.selectRetailerIdsBySchemeId(scheme.getId());

			scheme.getRetailerIds().addAll(retailerIds);

		}

		List<Integer> itemIds = schemeItemRepository.selectItemIdsBySchemeId(scheme.getId());

		if (itemIds.size() > 0) {

			List<Item> items = itemRepository.selectByIds(new HashSet<>(itemIds));

			scheme.setItemStringMap(this.toItemStringMap(items));

		}

		return scheme;

	}

	public Map<Integer, String> toItemStringMap(List<Item> items) {

		Map<Integer, String> itemMap = new HashMap<>();

		for (Item item : items) {

			itemMap.put(item.getId(), this.getItemString(item));

		}

		return itemMap;

	}

	public String getItemString(Item item) {

		StringBuilder itemString = new StringBuilder();

		if (item.getBrand() != null && !item.getBrand().isEmpty()) {

			itemString.append(item.getBrand().trim());

		}

		itemString.append(" ");

		if (item.getModelName() != null && !item.getModelName().isEmpty()) {

			itemString.append(item.getModelName().trim());

		}

		itemString.append(" ");

		if (item.getModelNumber() != null && !item.getModelNumber().isEmpty()) {

			itemString.append(item.getModelNumber().trim());

		}

		itemString.append(" ");

		if (item.getColor() != null && !item.getColor().isEmpty()) {

			itemString.append(item.getColor().trim());

		}

		return itemString.toString();

	}

	private Set<Integer> schemeItemsToItemIds(List<SchemeItem> schemeItems) {

		Set<Integer> itemIds = new HashSet<>();

		for (SchemeItem schemeItem : schemeItems) {

			itemIds.add(schemeItem.getItemId());

		}

		return itemIds;

	}

	@Override

	public List<SchemeModel> getAllSchemeModels(LocalDateTime startDateTime, LocalDateTime endDateTime) {

		List<Scheme> schemes = schemeRepository.selectAllBetweenCreateTimestamp(startDateTime, endDateTime);

		Map<Integer, Scheme> schemeIdSchemeMap = this.toSchemeIdSchemeMap(schemes);

		List<SchemeItem> schemeItems = schemeItemRepository.selectBySchemeIds(schemeIdSchemeMap.keySet());

		Set<Integer> itemIds = this.schemeItemsToItemIds(schemeItems);

		List<Item> items = itemRepository.selectByIds(itemIds);

		Map<Integer, String> itemStringMap = this.toItemStringMap(items);

		this.addItemIdsToSchemes(schemeItems, schemeIdSchemeMap, itemStringMap);

		List<RetailerScheme> retailerSchemes = retailerSchemeRepository.selectBySchemeIds(schemeIdSchemeMap.keySet());

		this.addRetailerIdsToSchemes(retailerSchemes, schemeIdSchemeMap);

		return this.toSchemeModels(schemeIdSchemeMap);

	}

	private void addItemIdsToSchemes(List<SchemeItem> schemeItems, Map<Integer, Scheme> schemeIdSchemeMap,

			Map<Integer, String> itemStringMap) {

		for (SchemeItem schemeItem : schemeItems) {

			schemeIdSchemeMap.get(schemeItem.getSchemeId()).getItemStringMap().put(schemeItem.getItemId(),

					itemStringMap.get(schemeItem.getItemId()));

		}

	}

	private void addRetailerIdsToSchemes(List<RetailerScheme> retailerSchemes, Map<Integer, Scheme> schemeIdSchemeMap) {

		for (RetailerScheme retailerScheme : retailerSchemes) {

			schemeIdSchemeMap.get(retailerScheme.getSchemeId()).getRetailerIds().add(retailerScheme.getRetailerId());

		}

	}

	private List<SchemeModel> toSchemeModels(Map<Integer, Scheme> schemeIdSchemeMap) {

		List<SchemeModel> schemeModels = new ArrayList<>();

		for (Map.Entry<Integer, Scheme> schemeIdSchemeEntry : schemeIdSchemeMap.entrySet()) {

			schemeModels.add(this.toSchemeModel(schemeIdSchemeEntry.getValue()));

		}

		return schemeModels;

	}

	private SchemeModel toSchemeModel(Scheme scheme) {

		SchemeModel schemeModel = new SchemeModel();

		schemeModel.setSchemeId(scheme.getId());

		schemeModel.setName(scheme.getName());

		schemeModel.setDescription(scheme.getDescription());

		schemeModel.setSchemeType(scheme.getType().toString());

		schemeModel.setAmountType(scheme.getAmountType().toString());

		schemeModel.setAmount(scheme.getAmount());

		schemeModel.setStartDateTime(StringUtils.toString(scheme.getStartDateTime()));

		schemeModel.setEndDateTime(StringUtils.toString(scheme.getEndDateTime()));

		schemeModel.setCreateTimestamp(StringUtils.toString(scheme.getCreateTimestamp()));

		schemeModel.setActiveTimestamp(StringUtils.toString(scheme.getActiveTimestamp()));

		schemeModel.setExpireTimestamp(StringUtils.toString(scheme.getExpireTimestamp()));

		schemeModel.setCreatedBy(scheme.getCreatedBy());

		schemeModel.setItemStringMap(scheme.getItemStringMap());

		schemeModel.setRetailerIds(scheme.getRetailerIds());

		return schemeModel;

	}

	@Override

	public void activeSchemeById(int schemeId) throws ProfitMandiBusinessException {

		Scheme scheme = schemeRepository.selectById(schemeId);

		if (scheme.getActiveTimestamp() != null) {

			throw new ProfitMandiBusinessException(ProfitMandiConstants.ACTIVE_TIMESTAMP, scheme.getActiveTimestamp(),

					"SCHM_1005");

		}

		if (scheme.getExpireTimestamp() != null) {

			throw new ProfitMandiBusinessException(ProfitMandiConstants.EXPIRE_TIMESTAMP, scheme.getExpireTimestamp(),

					"SCHM_1006");

		}

		scheme.setActiveTimestamp(LocalDateTime.now());

		schemeRepository.persist(scheme);

		if (scheme.getType() == SchemeType.IN) {

			this.processPreviousPurchases(scheme);

		} else if (scheme.getType() == SchemeType.OUT) {

			this.processPreviousSales(scheme);

		}

	}

	private void processPreviousPurchases(Scheme scheme) throws ProfitMandiBusinessException {

		List<InventoryItem> inventoryItems = inventoryItemRepository.selectBetweenDates(scheme.getStartDateTime(),

				scheme.getEndDateTime());

		if (inventoryItems.isEmpty()) {

			return;

		}

		List<Integer> itemIds = schemeItemRepository.selectItemIdsBySchemeId(scheme.getId());

		if (itemIds.isEmpty()) {

			return;

		}

		List<Item> items = itemRepository.selectByIds(new HashSet<>(itemIds));

		Map<Integer, String> itemStringMap = this.toItemStringMap(items);

		List<InventoryItem> completedInventoryItems = this.toFilteredPurchaseCompletedInventoryItems(inventoryItems,

				itemIds, true);

		if (completedInventoryItems.isEmpty()) {

			return;

		}

		if (scheme.isRetailerAll()) {

			for (InventoryItem inventoryItem : completedInventoryItems) {

				float cashback = this.createSchemeInOut(scheme, inventoryItem);

				if (cashback > 0) {

					walletService.addAmountToWallet(inventoryItem.getFofoId(), inventoryItem.getPurchaseId(),

							WalletReferenceType.SCHEME_IN,

							"Added SCHEME_IN for item " + itemStringMap.get(inventoryItem.getItemId())

									+ " against invoiceNumber " + inventoryItem.getPurchase().getPurchaseReference(),

							cashback);

				}

			}

		} else {

			List<Integer> retailerIds = retailerSchemeRepository.selectRetailerIdsBySchemeId(scheme.getId());

			for (InventoryItem inventoryItem : completedInventoryItems) {

				if (retailerIds.contains(inventoryItem.getFofoId())) {

					float cashback = this.createSchemeInOut(scheme, inventoryItem);

					if (cashback > 0) {

						walletService.addAmountToWallet(inventoryItem.getFofoId(), inventoryItem.getPurchaseId(),

								WalletReferenceType.SCHEME_IN,

								"Added SCHEME_IN for item " + itemStringMap.get(inventoryItem.getItemId())

										+ " against invoiceNumber "

										+ inventoryItem.getPurchase().getPurchaseReference(),

								cashback);

					}

				}

			}

		}

	}

	private Map<Integer, Integer> toInventoryItemIdFofoOrderIdMap(List<FofoLineItem> fofoLineItems,

			Map<Integer, FofoOrderItem> fofoOrderItemIdFofoOrderItemMap) {

		Map<Integer, Integer> inventoryItemIdFofoOrderIdMap = new HashMap<>();

		for (FofoLineItem fofoLineItem : fofoLineItems) {

			inventoryItemIdFofoOrderIdMap.put(fofoLineItem.getInventoryItemId(),

					fofoOrderItemIdFofoOrderItemMap.get(fofoLineItem.getFofoOrderItemId()).getOrderId());

		}

		return inventoryItemIdFofoOrderIdMap;

	}

	private void processPreviousSales(Scheme scheme) throws ProfitMandiBusinessException {

		List<FofoOrderItem> fofoOrderItems = fofoOrderItemRepository.selectBetweenDates(scheme.getStartDateTime(),

				scheme.getEndDateTime());

		if (fofoOrderItems.isEmpty()) {

			return;

		}

		Map<Integer, FofoOrderItem> fofoOrderItemIdFofoOrderItemMap = this

				.toFofoOrderItemIdFofoOrderItemMap(fofoOrderItems);

		List<FofoLineItem> fofoLineItems = fofoLineItemRepository

				.selectByFofoOrderItemIds(fofoOrderItemIdFofoOrderItemMap.keySet());

		if (fofoLineItems.isEmpty()) {

			return;

		}

		Map<Integer, Integer> inventoryItemIdFofoOrderIdMap = this.toInventoryItemIdFofoOrderIdMap(fofoLineItems,

				fofoOrderItemIdFofoOrderItemMap);

		List<InventoryItem> inventoryItems = inventoryItemRepository

				.selectByIds(inventoryItemIdFofoOrderIdMap.keySet());

		if (inventoryItems.isEmpty()) {

			return;

		}

		List<Integer> itemIds = schemeItemRepository.selectItemIdsBySchemeId(scheme.getId());

		if (itemIds.isEmpty()) {

			return;

		}

		List<InventoryItem> completedInventoryItems = this.toFilteredPurchaseCompletedInventoryItems(inventoryItems,

				itemIds, false);

		if (scheme.isRetailerAll()) {

			for (InventoryItem inventoryItem : completedInventoryItems) {

				float cashback = this.createSchemeInOut(scheme, inventoryItem);

				if (cashback > 0) {

					walletService.addAmountToWallet(inventoryItem.getFofoId(), inventoryItem.getPurchaseId(),

							WalletReferenceType.SCHEME_OUT, "Added for SCHEME_OUT", cashback);

				}

			}

		} else {

			List<Integer> retailerIds = retailerSchemeRepository.selectRetailerIdsBySchemeId(scheme.getId());

			for (InventoryItem inventoryItem : completedInventoryItems) {

				if (retailerIds.contains(inventoryItem.getFofoId())) {

					float cashback = this.createSchemeInOut(scheme, inventoryItem);

					if (cashback > 0) {

						walletService.addAmountToWallet(inventoryItem.getFofoId(),

								inventoryItemIdFofoOrderIdMap.get(inventoryItem.getId()),

								WalletReferenceType.SCHEME_OUT, "Added for SCHEME_OUT", cashback);

					}

				}

			}

		}

	}

	private Map<Integer, FofoOrderItem> toFofoOrderItemIdFofoOrderItemMap(List<FofoOrderItem> fofoOrderItems) {

		Map<Integer, FofoOrderItem> fofoOrderItemIdFofoOrderItemMap = new HashMap<>();

		for (FofoOrderItem fofoOrderItem : fofoOrderItems) {

			fofoOrderItemIdFofoOrderItemMap.put(fofoOrderItem.getId(), fofoOrderItem);

		}

		return fofoOrderItemIdFofoOrderItemMap;

	}

	private List<InventoryItem> toFilteredPurchaseCompletedInventoryItems(List<InventoryItem> inventoryItems,

			List<Integer> itemIds, boolean purchase) {

		List<InventoryItem> completedInventoryItems = new ArrayList<>();

		for (InventoryItem inventoryItem : inventoryItems) {

			if (purchase && inventoryItem.getPurchase().getCompleteTimestamp() != null

					&& itemIds.contains(inventoryItem.getItemId())) {

				completedInventoryItems.add(inventoryItem);

			} else if (!purchase && itemIds.contains(inventoryItem.getItemId())) {

				completedInventoryItems.add(inventoryItem);

			}

		}

		return completedInventoryItems;

	}

	@Override

	public void expireSchemeById(int schemeId, LocalDateTime expiryTime) throws ProfitMandiBusinessException {

		Scheme scheme = schemeRepository.selectById(schemeId);

		if (scheme == null || scheme.getActiveTimestamp() == null) {

			throw new ProfitMandiBusinessException(ProfitMandiConstants.ACTIVE_TIMESTAMP, scheme.getActiveTimestamp(),

					"SCHM_1007");

		}

		if (scheme.getExpireTimestamp() != null) {

			throw new ProfitMandiBusinessException(ProfitMandiConstants.EXPIRE_TIMESTAMP, scheme.getExpireTimestamp(),

					"SCHM_1008");

		}

		scheme.setExpireTimestamp(LocalDateTime.now());

		scheme.setEndDateTime(expiryTime);

		schemeRepository.persist(scheme);

	}

	private Map<Integer, Scheme> toSchemeIdSchemeMap(List<Scheme> schemes) {

		Map<Integer, Scheme> schemeIdSchemeMap = new HashMap<>();

		for (Scheme scheme : schemes) {

			schemeIdSchemeMap.put(scheme.getId(), scheme);

		}

		return schemeIdSchemeMap;

	}

	private Set<Integer> inventoryItemSchemesMapToSchemeIds(Map<InventoryItem, Set<Scheme>> inventoryItemSchemesMap) {

		Set<Integer> schemeIds = new HashSet<>();

		for (Map.Entry<InventoryItem, Set<Scheme>> inventoryItemSchemesEntry : inventoryItemSchemesMap.entrySet()) {

			for (Scheme scheme : inventoryItemSchemesEntry.getValue()) {

				schemeIds.add(scheme.getId());

			}

		}

		return schemeIds;

	}

	private Set<Integer> inventoryItemsToItemIds(List<InventoryItem> inventoryItems) {

		Set<Integer> itemIds = new HashSet<>();

		for (InventoryItem inventoryItem : inventoryItems) {

			itemIds.add(inventoryItem.getItemId());

		}

		return itemIds;

	}

	private Map<Integer, Set<Scheme>> toItemIdSchemesMap(List<SchemeItem> schemeItems, List<Scheme> schemes) {

		Map<Integer, Scheme> schemeIdSchemesMap = this.toSchemeIdSchemeMap(schemes);

		Map<Integer, Set<Scheme>> itemIdSchemesMap = new HashMap<>();

		for (SchemeItem schemeItem : schemeItems) {

			if (!itemIdSchemesMap.containsKey(schemeItem.getItemId())) {

				Set<Scheme> schemesSet = new HashSet<>();

				schemesSet.add(schemeIdSchemesMap.get(schemeItem.getSchemeId()));

				itemIdSchemesMap.put(schemeItem.getItemId(), schemesSet);

			} else {

				itemIdSchemesMap.get(schemeItem.getItemId()).add(schemeIdSchemesMap.get(schemeItem.getSchemeId()));

			}

		}

		return itemIdSchemesMap;

	}

	private Map<InventoryItem, Set<Scheme>> toInventoryItemSchemesMap(List<Scheme> schemes,

			List<InventoryItem> inventoryItems) {

		Set<Integer> schemeIds = new HashSet<>();

		for (Scheme scheme : schemes) {

			schemeIds.add(scheme.getId());

		}

		Set<Integer> itemIds = this.inventoryItemsToItemIds(inventoryItems);

		List<SchemeItem> schemeItems = schemeItemRepository.selectBySchemeIdsAndItemIds(schemeIds, itemIds);

		Map<Integer, Set<Scheme>> itemIdSchemesMap = this.toItemIdSchemesMap(schemeItems, schemes);

		Map<InventoryItem, Set<Scheme>> inventoryItemSchemsMap = new HashMap<>();

		for (InventoryItem inventoryItem : inventoryItems) {

			if (itemIdSchemesMap.containsKey(inventoryItem.getItemId())) {

				inventoryItemSchemsMap.put(inventoryItem, itemIdSchemesMap.get(inventoryItem.getItemId()));

			}

		}

		return inventoryItemSchemsMap;

	}

	@Override

	public void processSchemeIn(int purchaseId, int retailerId) throws ProfitMandiBusinessException {

		LOGGER.info("Trying to process SchemeIn with purchaseId [{}] and retailerId [{}]", purchaseId, retailerId);

		Purchase purchase = purchaseRepository.selectByIdAndFofoId(purchaseId, retailerId);

		LOGGER.info("purchase is completed = {}", (purchase.getCompleteTimestamp() != null));

		if (purchase.getCompleteTimestamp() != null) {

			List<Scheme> schemes = schemeRepository.selectActiveAll(SchemeType.IN, purchase.getCompleteTimestamp());

			float totalCashback = 0;

			if (schemes.isEmpty()) {

				return;

			}

			List<InventoryItem> inventoryItems = inventoryItemRepository.selectByPurchaseId(purchaseId);

			inventoryItems.stream().filter(x -> !x.getLastScanType().equals(ScanType.PURCHASE_RET_BAD)

					&& !x.getLastScanType().equals(ScanType.PURCHASE_RET));

			Map<InventoryItem, Set<Scheme>> inventoryItemSchemesMap = this.toInventoryItemSchemesMap(schemes,

					inventoryItems);

			if (inventoryItemSchemesMap.isEmpty()) {

				return;

			}

			Map<InventoryItem, Set<Scheme>> allInventoryItemSchemesMap = new HashMap<>();

			Set<Integer> itemIds = new HashSet<>();

			for (Map.Entry<InventoryItem, Set<Scheme>> inventoryItemSchemesEntry : inventoryItemSchemesMap.entrySet()) {

				Set<Scheme> notAllSchemes = new HashSet<>();

				Set<Scheme> allSchemes = new HashSet<>();

				for (Scheme scheme : inventoryItemSchemesEntry.getValue()) {

					if (!scheme.isRetailerAll()) {

						notAllSchemes.add(scheme);

					} else {

						allSchemes.add(scheme);

					}

				}

				allInventoryItemSchemesMap.put(inventoryItemSchemesEntry.getKey(), allSchemes);

				itemIds.add(inventoryItemSchemesEntry.getKey().getItemId());

			}

			int itemsCount = 0;

			for (Map.Entry<InventoryItem, Set<Scheme>> allInventoryItemSchemesEntry : allInventoryItemSchemesMap

					.entrySet()) {

				float inventoryItemCashback = 0;

				for (Scheme scheme : allInventoryItemSchemesEntry.getValue()) {

					InventoryItem inventoryItem = allInventoryItemSchemesEntry.getKey();

					float cashback = this.createSchemeInOut(scheme, inventoryItem);

					inventoryItemCashback += cashback;

				}

				if (inventoryItemCashback > 0) {

					totalCashback += inventoryItemCashback;

					itemsCount++;

				}

			}

			LOGGER.info("Items count for purchase id {} is {}", purchaseId, itemsCount);

			if (itemsCount > 0) {

				walletService.addAmountToWallet(retailerId, purchaseId, WalletReferenceType.SCHEME_IN,

						"Added for SCHEME IN against invoice " + purchase.getPurchaseReference() + " (total "

								+ itemsCount + " pcs)",

						totalCashback);

				LOGGER.info("Added Rs.{} for SCHEME IN against invoice {} total pcs({}) {}", totalCashback,

						purchase.getPurchaseReference(), itemsCount);

				purchase.setCashback(purchase.getCashback() + totalCashback);

				purchaseRepository.persist(purchase);

			}

		}

	}

	private float createSchemeInOut(Scheme scheme, InventoryItem inventoryItem) {

		List<SchemeInOut> schemeInOuts = schemeInOutRepository.selectByScheme(scheme.getId(), inventoryItem.getId());

		float amount = 0;

		if (schemeInOuts.stream().filter(x -> x.getRolledBackTimestamp() == null).collect(Collectors.toList())

				.size() == 0) {

			SchemeInOut schemeInOut = new SchemeInOut();

			amount = this.getAmount(inventoryItem, scheme);

			schemeInOut.setSchemeId(scheme.getId());

			schemeInOut.setInventoryItemId(inventoryItem.getId());

			schemeInOut.setAmount(amount);

			schemeInOutRepository.persist(schemeInOut);

		}

		return amount;

	}

	// We are maintaining price drop after grn

	private float getAmount(InventoryItem inventoryItem, Scheme scheme) {

		float amount = 0;

		float dpForCalc = 0;

		float taxableSellingPrice = 0;

		float totalTaxRate = inventoryItem.getIgstRate() + inventoryItem.getSgstRate() + inventoryItem.getCgstRate();

		if (scheme.getAmountType() == AmountType.PERCENTAGE) {

			if (scheme.getType().equals(SchemeType.IN)) {

				dpForCalc = inventoryItem.getUnitPrice() - inventoryItem.getPriceDropAmount();

			} else {

				try {

					dpForCalc = tagListingRepository.selectByItemId(inventoryItem.getItemId()).getSellingPrice();

				} catch (Exception e) {

					LOGGER.info("Could not find tag Listing entry in {}", inventoryItem.getItemId());

					e.printStackTrace();

				}

			}

			taxableSellingPrice = dpForCalc / (1 + totalTaxRate / 100);

			amount = taxableSellingPrice * scheme.getAmount() / 100;

			System.out.println(String.format("%d\t%s\t%d\t%d\t%s\t%s\t%s\t%f\t%f\t%f\t%f", inventoryItem.getId(),

					inventoryItem.getSerialNumber(), inventoryItem.getItemId(), scheme.getId(), scheme.getName(),

					scheme.getType(), scheme.getAmountType(), dpForCalc, taxableSellingPrice, scheme.getAmount(),

					amount));

		} else {

			amount = scheme.getAmount();

			System.out.println(String.format("%d\t%s\t%d\t%d\t%s\t%s\t%s\t%f\t%f\t%d\t%f", inventoryItem.getId(),

					inventoryItem.getSerialNumber(), inventoryItem.getItemId(), scheme.getId(), scheme.getName(),

					scheme.getType(), scheme.getAmountType(), dpForCalc, taxableSellingPrice, 0, amount));

		}

		return amount;

	}

	@Override

	public void processSchemeOut(int fofoOrderId, int retailerId) throws ProfitMandiBusinessException {

		FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndOrderId(retailerId, fofoOrderId);

		List<ScanRecord> scanRecords = scanRecordRepository.selectAllByOrderId(fofoOrderId);

		Set<Integer> inventoryItemIds = scanRecords.stream().map(x -> x.getInventoryItemId())

				.collect(Collectors.toSet());

		Set<InventoryItem> inventoryItems = inventoryItemRepository.selectByIds(inventoryItemIds).stream()

				.filter(x -> x.getSerialNumber() != null && !x.getSerialNumber().equals(""))

				.collect(Collectors.toSet());

		if (inventoryItems.size() == 0) {

			return;

		}

		float totalCashback = 0;

		int count = 0;

		Set<Scheme> allFixedSchemes = schemeRepository.selectActiveAll(SchemeType.OUT, fofoOrder.getCreateTimestamp())

				.stream().filter(scheme -> scheme.getAmountType().equals(AmountType.FIXED)).collect(Collectors.toSet());

		for (InventoryItem inventoryItem : inventoryItems) {

			int itemCashback = 0;

			Purchase purchase = purchaseRepository.selectByIdAndFofoId(inventoryItem.getPurchaseId(), retailerId);

			Set<Integer> schemeIds = new HashSet<>(

					schemeItemRepository.selectSchemeIdByItemId(inventoryItem.getItemId()));

			Set<Scheme> schemes = schemeRepository.selectActiveAll(SchemeType.OUT, purchase.getCompleteTimestamp())

					.stream().filter(x -> x.getAmountType().equals(AmountType.PERCENTAGE)).collect(Collectors.toSet());

			schemes.addAll(allFixedSchemes);

			schemes = schemes.stream().filter(x -> schemeIds.contains(x.getId())).collect(Collectors.toSet());

			for (Scheme scheme : schemes) {

				itemCashback += this.createSchemeInOut(scheme, inventoryItem);

			}

			if (itemCashback > 0) {

				count++;

				totalCashback += itemCashback;

			}

		}

		if (count > 0) {

			walletService.addAmountToWallet(retailerId, fofoOrderId, WalletReferenceType.SCHEME_OUT,

					"Sales margin for invoice number " + fofoOrder.getInvoiceNumber() + ". Total " + count + " pc(s)",

					totalCashback);

			fofoOrder.setCashback(totalCashback);

			fofoOrderRepository.persist(fofoOrder);

		}

	}

	@Override

	public void rollbackSchemes(List<Integer> inventoryItemIds, int rollbackReference, String rollbackReason)

			throws Exception {

		Set<Integer> inventoryItemIdSet = new HashSet<>(inventoryItemIds);

		float amountToRollback = 0;

		List<SchemeInOut> schemes = schemeInOutRepository.selectByInventoryItemIds(inventoryItemIdSet);

		for (SchemeInOut schemeInOut : schemes) {

			if (schemeInOut.getRolledBackTimestamp() == null) {

				schemeInOut.setRolledBackTimestamp(LocalDateTime.now());

				schemeInOutRepository.persist(schemeInOut);

				amountToRollback += schemeInOut.getAmount();

			}

		}

		if (amountToRollback > 0) {

			int inventoryItemId = inventoryItemIds.get(0);

			Integer fofoId = inventoryItemRepository.selectById(inventoryItemId).getFofoId();

			walletService.rollbackAmountFromWallet(fofoId, amountToRollback, rollbackReference,

					WalletReferenceType.SCHEME_IN, rollbackReason);

		}

	}

	@Override

	public Map<String, Object> getSchemes(Set<Integer> roleIds, int offset, int limit)

			throws ProfitMandiBusinessException {

		Map<String, Object> map = new HashMap<>();

		List<Scheme> schemes = null;

		long size = 0;

		if (roleManager.isAdmin(roleIds)) {

			schemes = schemeRepository.selectAll(offset, limit);

			size = schemeRepository.selectAllCount();

		} else {

			schemes = schemeRepository.selectActiveAll(offset, limit);

			size = schemeRepository.selectAllActiveCount();

		}

		map.put("schemes", schemes);

		map.put("start", offset + 1);

		map.put("size", size);

		if (schemes.size() < limit) {

			map.put("end", offset + schemes.size());

		} else {

			map.put("end", offset + limit);

		}

		return map;

	}

	@Override

	public List<Scheme> getPaginatedSchemes(Set<Integer> roleIds, int offset, int limit)

			throws ProfitMandiBusinessException {

		LOGGER.info("requested offset=[{}], limit = [{}]", offset, limit);

		List<Scheme> schemes = null;

		if (roleManager.isAdmin(roleIds)) {

			schemes = schemeRepository.selectAll(offset, limit);

		} else {

			schemes = schemeRepository.selectActiveAll(offset, limit);

		}

		return schemes;

	}

	@Override

	public void reverseSchemes(List<InventoryItem> inventoryItems, int priceDropId, String reversalReason)

			throws Exception {

		Map<Integer, List<InventoryItem>> purchaseInventoryListMap = inventoryItems.stream()

				.collect(Collectors.groupingBy(InventoryItem::getPurchaseId, Collectors.toList()));

		for (Map.Entry<Integer, List<InventoryItem>> purchaseEntry : purchaseInventoryListMap.entrySet()) {

			float amountToCredit = 0;

			float amountToDebit = 0;

			int purchaseId = purchaseEntry.getKey();

			List<InventoryItem> purchaseInventoryItemList = purchaseEntry.getValue();

			Map<Integer, InventoryItem> inventoryItemsMap = purchaseInventoryItemList.stream()

					.collect(Collectors.toMap(x -> x.getId(), x -> x));

			List<SchemeInOut> schemeInOuts = schemeInOutRepository.selectByInventoryItemIds(inventoryItemsMap.keySet());

			List<Integer> schemeIds = schemeInOuts.stream().map(x -> x.getSchemeId()).collect(Collectors.toList());

			Map<Integer, Scheme> schemesMap = schemeRepository.selectBySchemeIds(schemeIds, 0, schemeIds.size())

					.stream().collect(Collectors.toMap(x -> x.getId(), x -> x));

			for (SchemeInOut schemeInOut : schemeInOuts) {

				InventoryItem ii = inventoryItemsMap.get(schemeInOut.getInventoryItemId());

				Scheme scheme = schemesMap.get(schemeInOut.getSchemeId());

				if (scheme.getType().equals(SchemeType.OUT))

					continue;

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

					continue;

				}

				if (schemeInOut.getRolledBackTimestamp() == null) {

					float newAmount = getAmount(ii, scheme);

					if (schemeInOut.getAmount() - newAmount >= 0.01f) {

						schemeInOut.setRolledBackTimestamp(LocalDateTime.now());

						schemeInOutRepository.persist(schemeInOut);

						SchemeInOut sioNew = new SchemeInOut();

						sioNew.setAmount(newAmount);

						sioNew.setInventoryItemId(schemeInOut.getInventoryItemId());

						sioNew.setSchemeId(schemeInOut.getSchemeId());

						schemeInOutRepository.persist(sioNew);

						amountToCredit += sioNew.getAmount();

						amountToDebit += schemeInOut.getAmount();

					}

				}

			}

			int fofoId = inventoryItems.get(0).getFofoId();

			if (amountToDebit > 0) {

				walletService.addAmountToWallet(fofoId, purchaseId, WalletReferenceType.SCHEME_IN, reversalReason,

						-amountToDebit);

			}

			if (amountToCredit > 0) {

				walletService.addAmountToWallet(fofoId, purchaseId, WalletReferenceType.SCHEME_IN, reversalReason,

						amountToCredit);

			}

		}

	}

	@Override

	public void reverseSchemes(List<InventoryItem> inventoryItems, int reversalReference, String reversalReason,

			SchemeType schemeType) throws ProfitMandiBusinessException {

		Map<Integer, InventoryItem> inventoryItemsMap = inventoryItems.stream()

				.collect(Collectors.toMap(x -> x.getId(), x -> x));

		List<SchemeInOut> schemeInOuts = schemeInOutRepository.selectByInventoryItemIds(inventoryItemsMap.keySet());

		List<Integer> schemeIds = schemeInOuts.stream().map(x -> x.getSchemeId()).collect(Collectors.toList());

		float amount = 0;

		Map<Integer, Scheme> schemesMap = schemeRepository.selectBySchemeIds(schemeIds, 0, schemeIds.size()).stream()

				.collect(Collectors.toMap(x -> x.getId(), x -> x));

		for (SchemeInOut schemeInOut : schemeInOuts) {

			Scheme scheme = schemesMap.get(schemeInOut.getSchemeId());

			if (scheme.getType().equals(schemeType)) {

				if (schemeInOut.getRolledBackTimestamp() == null) {

					schemeInOut.setRolledBackTimestamp(LocalDateTime.now());

					schemeInOutRepository.persist(schemeInOut);

					amount += schemeInOut.getAmount();

				}

			}

		}

		int fofoId = inventoryItems.get(0).getFofoId();

		WalletReferenceType walletReferenceType = schemeType.equals(SchemeType.OUT) ? WalletReferenceType.SCHEME_OUT

				: WalletReferenceType.SCHEME_IN;

		if (amount > 0) {

			walletService.rollbackAmountFromWallet(fofoId, amount, reversalReference, walletReferenceType,

					reversalReason);

		}

	}

	/*

	 * @Override public void updateSchmesForModel(int catalogId) throws

	 * ProfitMandiBusinessException { List<Item> items =

	 * itemRepository.selectAllByCatalogItemId(catalogId); Map<Integer, Scheme>

	 * schemes = schemeRepository .selectAllByItemIds(items.stream().map(x ->

	 * x.getId()).collect(Collectors.toList()));

	 * 

	 * }

	 */

}