Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import com.eclipsesource.json.Json;
import com.eclipsesource.json.JsonArray;
import com.eclipsesource.json.JsonObject;
import com.eclipsesource.json.JsonValue;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import com.mongodb.BasicDBObject;
import com.mongodb.DBObject;
import com.spice.profitmandi.common.enumuration.SchemeType;
import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
import com.spice.profitmandi.common.model.BrandAndAddToCartEligibleModel;
import com.spice.profitmandi.common.model.ProfitMandiConstants;
import com.spice.profitmandi.common.model.UserInfo;
import com.spice.profitmandi.common.solr.SolrService;
import com.spice.profitmandi.common.web.client.RestClient;
import com.spice.profitmandi.common.web.util.ResponseSender;
import com.spice.profitmandi.dao.entity.catalog.*;
import com.spice.profitmandi.dao.entity.dtr.WebListing;
import com.spice.profitmandi.dao.entity.dtr.WebOffer;
import com.spice.profitmandi.dao.entity.fofo.*;
import com.spice.profitmandi.dao.entity.inventory.SaholicCISTable;
import com.spice.profitmandi.dao.entity.inventory.SaholicPOItem;
import com.spice.profitmandi.dao.enumuration.dtr.WebListingSource;
import com.spice.profitmandi.dao.enumuration.dtr.WebListingType;
import com.spice.profitmandi.dao.model.AmountModel;
import com.spice.profitmandi.dao.model.CreateOfferRequest;
import com.spice.profitmandi.dao.model.UserCart;
import com.spice.profitmandi.dao.repository.catalog.*;
import com.spice.profitmandi.dao.repository.dtr.*;
import com.spice.profitmandi.dao.repository.fofo.CatalogFavouriteRepository;
import com.spice.profitmandi.dao.repository.fofo.CurrentInventorySnapshotRepository;
import com.spice.profitmandi.dao.repository.fofo.SuggestedPoDetailRepository;
import com.spice.profitmandi.dao.repository.fofo.SuggestedPoRepository;
import com.spice.profitmandi.dao.repository.inventory.SaholicCISTableRepository;
import com.spice.profitmandi.dao.repository.onboarding.BrandCommitRepository;
import com.spice.profitmandi.service.authentication.RoleManager;
import com.spice.profitmandi.service.catalog.BrandsService;
import com.spice.profitmandi.service.inventory.*;
import com.spice.profitmandi.service.pricecircular.PriceCircularItemModelNew;
import com.spice.profitmandi.service.pricecircular.PriceCircularModel;
import com.spice.profitmandi.service.pricecircular.PriceCircularService;
import com.spice.profitmandi.service.pricing.PricingService;
import com.spice.profitmandi.service.scheme.SchemeService;
import com.spice.profitmandi.web.res.DealBrands;
import com.spice.profitmandi.web.res.DealObjectResponse;
import com.spice.profitmandi.web.res.DealsResponse;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.conn.HttpHostConnectException;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.json.JSONArray;
import org.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;

@Controller
@Transactional(rollbackFor = Throwable.class)
public class DealsController {

    private static final Logger logger = LogManager.getLogger(DealsController.class);
    private static final List<Integer> TAG_IDS = Arrays.asList(4);

    @Value("${python.api.host}")
    private String host;

    @Value("${new.solr.url}")
    private String solrUrl;

    @Value("${python.api.port}")
    private int port;

    @Autowired
    RestClient restClient;

    @Autowired
    SolrService solrService;

    @Autowired
    com.spice.profitmandi.web.services.SolrService webSolrService;

    @Autowired
    InventoryService inventoryService;

    // This is now unused as we are not supporting multiple companies.
    @Value("${gadgetCops.invoice.cc}")
    private String[] ccGadgetCopInvoiceTo;

    @Autowired
    private PricingService pricingService;

    @Autowired
    private CategoryRepository categoryRepository;

    @Autowired
    private SchemeService schemeService;

    @Autowired
    private SaholicInventoryService saholicInventoryService;

    @Autowired
    private Mongo mongoClient;

    @Autowired
    private ItemBucketService itemBucketService;

    @Autowired
    private UserAccountRepository userAccountRepository;

    @Autowired
    private FofoStoreRepository fofoStoreRepository;

    @Autowired
    private ResponseSender<?> responseSender;

    @Autowired
    private TagListingRepository tagListingRepository;

    @Autowired
    private ItemRepository itemRepository;
    @Autowired
    private PriceCircularService priceCircularService;

    @Autowired
    private RoleManager roleManagerService;

    @Autowired
    private SuggestedPoDetailRepository suggestedPoDetailRepository;

    @Autowired
    private SuggestedPoRepository suggestedPoRepository;

    @Autowired
    private WebOfferRepository webOfferRepository;

    @Autowired
    private ComboModelRepository comboModelRepository;

    @Autowired
    private ComboMappedModelRepository comboMappedModelRepository;

    @Autowired
    private BrandsService brandsService;

    @Autowired
    private WebListingRepository webListingRepository;

    @Autowired
    private WebProductListingRepository webProductListingRepository;

    @Autowired
    private CatalogFavouriteRepository catalogFavouriteRepository;

    @Autowired
    PartnerOnBoardingPanelRepository partnerOnBoardingPanelRepository;

    @Autowired
    PartnerDealerRepository partnerDealerRepository;

    @Autowired
    BrandCommitRepository brandCommitRepository;

    @Autowired
    CatalogRepository catalogRepository;

    @Autowired
    private CurrentInventorySnapshotRepository currentInventorySnapshotRepository;

    List<String> filterableParams = Arrays.asList("brand");

    @RequestMapping(value = "/fofo/buckets", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
    @Transactional(readOnly = true)
    public ResponseEntity<?> getBuckets(HttpServletRequest request) throws ProfitMandiBusinessException {
        logger.info("Request " + request.getParameterMap());
        return responseSender.ok(itemBucketService.getBuckets(Optional.of(true)));
    }

    @RequestMapping(value = "/fofo/bucket", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
    @Transactional(readOnly = true)
    public ResponseEntity<?> getBucketDetails(HttpServletRequest request, @RequestParam int id) throws ProfitMandiBusinessException {
        List<ItemQuantityPojo> iqPojo = itemBucketService.getBucketDetails(id);
        Map<Integer, Integer> itemIdsQtyMap = iqPojo.stream().collect(Collectors.toMap(x -> x.getItemId(), x -> x.getQuantity()));
        Set<Integer> catalogIds = itemRepository.selectByIds(itemIdsQtyMap.keySet()).stream().map(x -> x.getCatalogItemId()).collect(Collectors.toSet());
        Map<String, String> params = new HashMap<>();
        List<String> mandatoryQ = new ArrayList<>();
        mandatoryQ.add(
                String.format("+catalogId_i:(%s) +{!parent which=\"id:catalog*\"}", StringUtils.join(catalogIds, " ")));
        params.put("start", "0");
        params.put("rows", "100");
        params.put("q", StringUtils.join(mandatoryQ, " "));
        params.put("fl", "*, [child parentFilter=id:catalog*]");

        params.put("wt", "json");
        String response = null;
        try {
            response = restClient.get(SchemeType.HTTP, solrUrl, 8984, "solr/demo/select", params);
        } catch (HttpHostConnectException e) {
            throw new ProfitMandiBusinessException("", "", "Could not connect to host");
        }
        JSONObject solrResponseJSONObj = new JSONObject(response).getJSONObject("response");
        JSONArray docs = solrResponseJSONObj.getJSONArray("docs");
        List<FofoCatalogResponse> dealResponse = getCatalogSingleSkuResponse(docs, itemIdsQtyMap, false);

        Bucket bucket = itemBucketService.getBuckets(Optional.of(true)).stream().filter(x -> x.getId() == id).collect(Collectors.toList()).get(0);
        bucket.setFofoCatalogResponses(dealResponse);
        return responseSender.ok(bucket);
    }

    @RequestMapping(value = "/fofo/suggestedPo", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
    @Transactional(readOnly = true)
    public ResponseEntity<?> getSuggestedPo(HttpServletRequest request, @RequestParam int id) throws ProfitMandiBusinessException {
        int userId = (int) request.getAttribute("userId");
        UserCart uc = userAccountRepository.getUserCart(userId);
        int fofoId = uc.getUserId();
        SuggestedPo  suggestedPo = suggestedPoRepository.selectAllOpenPoByFofoId(fofoId).get(0);
        if(suggestedPo == null){
            throw new ProfitMandiBusinessException("", "", "Open po is not available in list");
        }
        List<SuggestedPoDetail> mpd = suggestedPoDetailRepository.selectByPoId(suggestedPo.getId());
        Map<Integer, Integer> itemIdsQtyMap = mpd.stream().collect(Collectors.toMap(x -> x.getItemId(), x -> x.getQuantity()));

        Set<Integer> catalogIds = itemRepository.selectByIds(itemIdsQtyMap.keySet()).stream().map(x -> x.getCatalogItemId()).collect(Collectors.toSet());
                Map<String, String> params = new HashMap<>();
        List<String> mandatoryQ = new ArrayList<>();
        mandatoryQ.add(
                String.format("+catalogId_i:(%s) +{!parent which=\"id:catalog*\"}", StringUtils.join(catalogIds, " ")));
        params.put("start", "0");
        params.put("rows", "100");
        params.put("q", StringUtils.join(mandatoryQ, " "));
        params.put("fl", "*, [child parentFilter=id:catalog*]");

        params.put("wt", "json");
        String response = null;
        try {
            response = restClient.get(SchemeType.HTTP, solrUrl, 8984, "solr/demo/select", params);
        } catch (HttpHostConnectException e) {
            throw new ProfitMandiBusinessException("", "", "Could not connect to host");
        }
        JSONObject solrResponseJSONObj = new JSONObject(response).getJSONObject("response");
        JSONArray docs = solrResponseJSONObj.getJSONArray("docs");
        List<FofoCatalogResponse> dealResponse = getCatalogSingleSkuResponse(docs, itemIdsQtyMap, false);

        return responseSender.ok(dealResponse);
    }

    @RequestMapping(value = "/suggestedPo/status", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
    @ApiImplicitParams({@ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header")})
    @ApiOperation(value = "")
    public ResponseEntity<?> changeSuggestedPoStatus(HttpServletRequest request, @RequestParam int id) throws ProfitMandiBusinessException {
        SuggestedPo suggestedPo = suggestedPoRepository.selectById(id);
        suggestedPo.setStatus("closed");
        //suggestedPo.setStatus(SuggestedPoStatus.valueOf("closed"));

        return responseSender.ok(true);
    }

    @RequestMapping(value = "/fofo/fovourites", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
    @Transactional(readOnly = true)
    public ResponseEntity<?> getFavourites(HttpServletRequest request) throws Exception {

        int userId = (int) request.getAttribute("userId");
        UserCart uc = userAccountRepository.getUserCart(userId);
        int fofoId = uc.getUserId();
        List<FofoCatalogResponse> dealResponse = new ArrayList<>();
        Set<Integer> catalogIds = catalogFavouriteRepository.selectBypartnerId(fofoId).stream().map(x -> x.getCatalogId()).collect(Collectors.toSet());
        if (!catalogIds.isEmpty()) {
            dealResponse = webSolrService.dealResponse(catalogIds, fofoId);
        }
        return responseSender.ok(dealResponse);
    }

    @RequestMapping(value = "/favourites/manage", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE)
    @ApiImplicitParams({@ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header")})
    @ApiOperation(value = "")
    public ResponseEntity<?> mangeFavourites(HttpServletRequest request, @RequestParam int catalogId) throws ProfitMandiBusinessException {

        int userId = (int) request.getAttribute("userId");
        UserCart uc = userAccountRepository.getUserCart(userId);
        int fofoId = uc.getUserId();

        CatalogFavourite catalogFavourite = catalogFavouriteRepository.selectBypartnerAndCatalogId(fofoId, catalogId);

        if (catalogFavourite == null) {
            catalogFavourite = new CatalogFavourite();
            catalogFavourite.setCatalogId(catalogId);
            catalogFavourite.setFofoId(fofoId);
            catalogFavourite.setCreatedTimestamp(LocalDateTime.now());
            catalogFavouriteRepository.persist(catalogFavourite);

        } else {
            catalogFavouriteRepository.deleteByPartnerAndCatalogId(fofoId, catalogId);
        }
        return responseSender.ok(true);
    }

    private String getCommaSeparateTags(int userId) throws ProfitMandiBusinessException {
        UserCart uc = userAccountRepository.getUserCart(userId);
        List<Integer> tagIds = pricingService.getTagsIdsByRetailerId(uc.getUserId());
        List<String> strTagIds = new ArrayList<>();
        for (Integer tagId : tagIds) {
            strTagIds.add(String.valueOf(tagId));
        }
        return String.join(",", strTagIds);
    }

    @RequestMapping(value = "/fofo/similar-models/{modelId}", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
    @Transactional(readOnly = true)
    public ResponseEntity<?> similarModels(HttpServletRequest httpServletRequest, @PathVariable int modelId) throws Throwable {
        UserInfo userInfo = (UserInfo) httpServletRequest.getAttribute("userInfo");
        //FofoStore fs = fofoStoreRepository.selectByRetailerId(userInfo.getRetailerId());

        JSONObject jsonObject = solrService.getContentByCatalogIds(Arrays.asList(modelId)).get(modelId);

        JSONArray similarModelsArray = jsonObject.getJSONArray("similarModels_ii");
        List<Integer> similarCatalogIds = new ArrayList<>();
        for (int j = 0; j < similarModelsArray.length(); j++) {
            similarCatalogIds.add(similarModelsArray.getInt(j));
        }

        Map<String, String> params = new HashMap<>();
        List<String> mandatoryQ = new ArrayList<>();

        mandatoryQ.add(String.format(
                "+{!parent which=\"catalogId_i:(" + StringUtils.join(similarCatalogIds, " ") + ")\"} AND active_b:true AND show_default_b:true"));

        params.put("q", StringUtils.join(mandatoryQ, " "));
        params.put("fl", "*, [child parentFilter=id:catalog* childFilter=active_b:true ]");
        params.put("wt", "json");
        params.put("rows", similarCatalogIds.size() + "");
        try {
            String response = restClient.get(SchemeType.HTTP, solrUrl, 8984, "solr/demo/select", params);
            JSONObject solrResponseJSONObj = new JSONObject(response).getJSONObject("response");
            JSONArray docs = solrResponseJSONObj.getJSONArray("docs");
            return responseSender.ok(this.getCatalogResponse(docs, false, userInfo.getRetailerId()).stream().filter(x -> x.isInStock()).collect(Collectors.toList()));
        } catch (HttpHostConnectException e) {
            throw new ProfitMandiBusinessException("", "", "Could not connect to host");
        }
    }

    @ApiImplicitParams({@ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header")})
    @RequestMapping(value = "/fofo", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
    @Transactional(readOnly = true)
    public ResponseEntity<?> getFofo(HttpServletRequest request, @RequestParam(value = "categoryId", required = false, defaultValue = "3") String categoryId, @RequestParam(value = "offset") int offset,
                                     @RequestParam(value = "limit") int limit, @RequestParam(value = "sort", required = false) String sort, @RequestParam(value = "brand", required = false) String brand, @RequestParam(value = "subCategoryId", required = false) int subCategoryId, @RequestParam(value = "q", required = false) String queryTerm, @RequestParam(value = "hotDeal", required = false) boolean hotDeal, @RequestParam(value = "endPoint", required = false) String endPoint,@RequestParam(value = "group", required = false) boolean group) throws Throwable {
        List<FofoCatalogResponse> dealResponse;
        UserInfo userInfo = (UserInfo) request.getAttribute("userInfo");
        FofoStore fs = fofoStoreRepository.selectByRetailerId(userInfo.getRetailerId());
        sort = "w" + fs.getWarehouseId() + "_i desc";

        logger.info("endPoint {}", endPoint);
        logger.info("group Column {}", group);

        if (endPoint != null && !endPoint.trim().isEmpty()) {
            WebListing webListing = webListingRepository.selectByUrl(endPoint);
            dealResponse = this.getDealResponses(userInfo, fs, webListing, offset, limit);

        } else {

            dealResponse = this.getCatalogResponse(
                    solrService.getSolrDocs(queryTerm, categoryId, offset, limit, sort, brand, subCategoryId, hotDeal, group,true), hotDeal, userInfo.getRetailerId());
        }

        Map<Integer, List<Integer>> similarModelMap = dealResponse.stream().filter(x -> x.getSimilarModelIds() != null && x.getSimilarModelIds().size() > 0)
                .collect(Collectors.toMap(x -> x.getCatalogId(), x -> x.getSimilarModelIds()));
        Set<Integer> similarModelIds = similarModelMap.values().stream().flatMap(x -> x.stream()).collect(Collectors.toSet());
        logger.info("similarModelIds - {}", similarModelIds);
        if (similarModelIds.size() > 0) {

            Map<Integer, FofoCatalogResponse> similarCatalogResponsesMap = this.getSimpleDocs(fs, similarModelIds).stream().collect(Collectors.toMap(x -> x.getCatalogId(), x -> x));
            logger.info("Similar Catalog ResponseMap - {}", similarCatalogResponsesMap.keySet());

            for (FofoCatalogResponse deal : dealResponse) {
                if (similarModelMap.containsKey(deal.getCatalogId())) {
                    List<Integer> similarCatalogIds = similarModelMap.get(deal.getCatalogId());
                    logger.info("Similar Catalog Ids - {}", similarCatalogIds);
                    List<FofoCatalogResponse> similarModels = similarCatalogIds.stream().filter(x -> similarCatalogResponsesMap.containsKey(x)).map(x -> similarCatalogResponsesMap.get(x)).collect(Collectors.toList());
                    deal.setSimilarModels(similarModels);
                }
            }
        }
        return responseSender.ok(dealResponse);
    }

    private List<FofoCatalogResponse> getSimpleDocs(FofoStore fofoStore, Set<Integer> catalogIds) throws Exception {
        List<FofoCatalogResponse> fofoCatalogResponses = new ArrayList<>();


        Map<String, String> params = new HashMap<>();
        List<String> mandatoryQ = new ArrayList<>();

        mandatoryQ.add(String.format(
                "+{!parent which=\"catalogId_i:(" + StringUtils.join(catalogIds, " ") + ")\"} AND active_b:true AND show_default_b:true"));

        params.put("q", StringUtils.join(mandatoryQ, " "));
        params.put("fl", "*, [child parentFilter=id:catalog* childFilter=active_b:true ]");
        params.put("wt", "json");
        params.put("rows", catalogIds.size() + "");

        String response = restClient.get(SchemeType.HTTP, solrUrl, 8984, "solr/demo/select", params);
        JSONObject solrResponseJSONObj = new JSONObject(response).getJSONObject("response");
        JSONArray docs = solrResponseJSONObj.getJSONArray("docs");
        int warehouseId = fofoStore.getWarehouseId();
        Map<Integer, List<SaholicPOItem>> poItemAvailabilityMap = saholicInventoryService.getSaholicPOItems().get(warehouseId);

        // Pre-fetch all itemIds for batch CIS query
        List<Integer> allItemIds = new ArrayList<>();
        for (int i = 0; i < docs.length(); i++) {
            JSONObject doc = docs.getJSONObject(i);
            if (doc.has("_childDocuments_")) {
                for (int j = 0; j < doc.getJSONArray("_childDocuments_").length(); j++) {
                    allItemIds.add(doc.getJSONArray("_childDocuments_").getJSONObject(j).getInt("itemId_i"));
                }
            }
        }
        // Batch fetch CIS data
        Map<Integer, List<SaholicCISTable>> cisDataByItemId = saholicCISTableRepository
                .selectByItemWarehouse(allItemIds, warehouseId).stream()
                .collect(Collectors.groupingBy(SaholicCISTable::getItemId));

        for (int i = 0; i < docs.length(); i++) {
            JSONObject doc = docs.getJSONObject(i);
            FofoCatalogResponse fofoCatalogResponse = this.toFofoCatalogResponse(doc);
            if (doc.has("_childDocuments_")) {
                String modelColorClass = "grey";
                FofoAvailabilityInfo fdiAnyColour = null;
                // Iterating itemIds
                for (int j = 0; j < doc.getJSONArray("_childDocuments_").length(); j++) {
                    JSONObject childItem = doc.getJSONArray("_childDocuments_").getJSONObject(j);
                    int itemId = childItem.getInt("itemId_i");

                    List<SaholicCISTable> currentAvailability = cisDataByItemId.getOrDefault(itemId, new ArrayList<>());
                    List<SaholicPOItem> poItemAvailability = null;
                    if (poItemAvailabilityMap != null) {
                        poItemAvailability = poItemAvailabilityMap.get(itemId);
                    }

                    for (SaholicCISTable saholicCISTable : currentAvailability) {
                        saholicCISTable.setWarehouseName(
                                ProfitMandiConstants.WAREHOUSE_MAP.get(saholicCISTable.getWarehouseFrom()));
                    }


                    String poColor = "grey";
                    boolean active = false;
                    if (currentAvailability != null && currentAvailability.stream().collect(Collectors.summingInt(SaholicCISTable::getNetAvailability)) > 0) {
                        poColor = "green";
                        modelColorClass = "green";
                    } else if (poItemAvailability != null && poItemAvailability.stream().collect(Collectors.summingInt(SaholicPOItem::getUnfulfilledQty)) > 0) {
                        if (currentAvailability != null && poItemAvailability.stream().collect(Collectors.summingInt(SaholicPOItem::getUnfulfilledQty)) + currentAvailability.stream().collect(Collectors.summingInt(SaholicCISTable::getNetAvailability)) <= 0) {
                            poColor = "grey";
                        } else {
                            poColor = "yellow";
                            if (!modelColorClass.equals("green")) {
                                modelColorClass = poColor;
                            }
                        }
                    }

                }
                fofoCatalogResponse.setInStock(!modelColorClass.equals("grey"));
            }

            fofoCatalogResponses.add(fofoCatalogResponse);
        }

        return fofoCatalogResponses;
    }

    private FofoCatalogResponse toFofoCatalogResponse(JSONObject doc) {
        FofoCatalogResponse fofoCatalogResponse = new FofoCatalogResponse();
        fofoCatalogResponse.setCatalogId(doc.getInt("catalogId_i"));
        fofoCatalogResponse.setImageUrl(doc.getString("imageUrl_s"));
        fofoCatalogResponse.setTitle(doc.getString("title_s"));
        fofoCatalogResponse.setMop(doc.getFloat("mop_f"));
        fofoCatalogResponse.setDp(doc.getFloat("dp_f"));
        fofoCatalogResponse.setBrand(doc.getJSONArray("brand_ss").getString(0));
        return fofoCatalogResponse;
    }

    @RequestMapping(value = "/online-deals", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
    @ApiImplicitParams({@ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header")})
    @ApiOperation(value = "Get online deals")
    @Transactional(readOnly = true)
    public ResponseEntity<?> getOnlineDeals(HttpServletRequest request, @RequestParam(value = "categoryId") String
            categoryId, @RequestParam(value = "offset") String offset, @RequestParam(value = "limit") String
                                                    limit, @RequestParam(value = "sort", required = false) String
                                                    sort, @RequestParam(value = "direction", required = false) String
                                                    direction, @RequestParam(value = "filterData", required = false) String filterData) throws Throwable {
        logger.info("Request " + request.getParameterMap());
        String response = null;
        int userId = (int) request.getAttribute("userId");

        String uri = "/deals/" + userId;
                Map<String, String> params = new HashMap<>();
        params.put("offset", offset);
        params.put("limit", limit);
        params.put("categoryId", categoryId);
        params.put("direction", direction);
        params.put("sort", sort);
        params.put("source", "online");
        params.put("filterData", filterData);
        /*
         * if (userInfo.getRoleNames().contains(RoleType.FOFO.toString())) {
         * params.put("tag_ids", getCommaSeparateTags(userId)); }
         */
        List<Object> responseObject = new ArrayList<>();
        try {
            response = restClient.get(SchemeType.HTTP, host, port, uri, params);
        } catch (HttpHostConnectException e) {
            throw new ProfitMandiBusinessException("", "", "Could not connect to host");
        }

        JsonArray result_json = Json.parse(response).asArray();
        for (JsonValue j : result_json) {
            // logger.info("res " + j.asArray());
            List<Object> innerObject = new ArrayList<>();
            for (JsonValue jsonObject : j.asArray()) {
                innerObject.add(toDealObject(jsonObject.asObject()));
            }
            if (innerObject.size() > 0) {
                responseObject.add(innerObject);
            }
        }
        return responseSender.ok(responseObject);
    }

    private Object toDealObject(JsonObject jsonObject) {
        if (jsonObject.get("dealObject") != null && jsonObject.get("dealObject").asInt() == 1) {
            return new Gson().fromJson(jsonObject.toString(), DealObjectResponse.class);
        }
        return new Gson().fromJson(jsonObject.toString(), DealsResponse.class);
    }

    @RequestMapping(value = ProfitMandiConstants.URL_BRANDS, method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
    @ApiImplicitParams({@ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header")})
    @ApiOperation(value = "Get brand list and count for category")
    @Transactional(readOnly = true)
    public ResponseEntity<?> getBrands(HttpServletRequest request, @RequestParam(value = "category_id") String
            category_id) throws ProfitMandiBusinessException {
        logger.info("Request " + request.getParameterMap());
        String response = null;
        // TODO: move to properties
        String uri = ProfitMandiConstants.URL_BRANDS;
                Map<String, String> params = new HashMap<>();
        params.put("category_id", category_id);
        List<DealBrands> dealBrandsResponse = null;
        try {
            response = restClient.get(SchemeType.HTTP, host, port, uri, params);
        } catch (HttpHostConnectException e) {
            throw new ProfitMandiBusinessException("", "", "Could not connect to host");
        }

        dealBrandsResponse = new Gson().fromJson(response, new TypeToken<List<DealBrands>>() {
        }.getType());

        return responseSender.ok(dealBrandsResponse);
    }

    @RequestMapping(value = ProfitMandiConstants.URL_UNIT_DEAL, method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
    @ApiImplicitParams({@ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header")})
    @ApiOperation(value = "Get unit deal object")
    @Transactional(readOnly = true)
    public ResponseEntity<?> getUnitDeal(HttpServletRequest request, @PathVariable(value = "id") long id) throws
            ProfitMandiBusinessException {
        String response = null;
        // TODO: move to properties
        String uri = "getDealById/" + id;
        System.out.println("Unit deal " + uri);
                Map<String, String> params = new HashMap<>();
        DealsResponse dealsResponse = null;
        try {
            response = restClient.get(SchemeType.HTTP, host, port, uri, params);
        } catch (HttpHostConnectException e) {
            throw new ProfitMandiBusinessException("", "", "Could not connect to host");
        }

        JsonObject result_json = Json.parse(response).asObject();
        if (!result_json.isEmpty()) {
            dealsResponse = new Gson().fromJson(response, DealsResponse.class);
            Iterator<AvailabilityInfo> iter = dealsResponse.getAvailabilityInfo().iterator();
            while (iter.hasNext()) {
                AvailabilityInfo ai = iter.next();
                if (ai.getAvailability() <= 0)
                    iter.remove();
            }
        }
        return responseSender.ok(dealsResponse);
    }

    @RequestMapping(value = "/partnerdeals/{id}", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
    @ApiImplicitParams({@ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header")})
    @ApiOperation(value = "Get unit deal object")
    @Transactional(readOnly = true)
    public ResponseEntity<?> getUnitFocoDeal(HttpServletRequest request, @PathVariable(value = "id") long id) throws
            Exception {
        List<FofoCatalogResponse> dealResponse = new ArrayList<>();
        List<Integer> tagIds = Arrays.asList(4);
        UserInfo userInfo = (UserInfo) request.getAttribute("userInfo");
        if (roleManagerService.isPartner(userInfo.getRoleIds())) {
            String categoryId = "(3 OR 6)";
            UserCart uc = userAccountRepository.getUserCart(userInfo.getUserId());
                        Map<String, String> params = new HashMap<>();
            List<String> mandatoryQ = new ArrayList<>();
            String catalogString = "catalog" + id;

            mandatoryQ.add(String.format("+(categoryId_i:%s) +(id:%s) +{!parent which=\"id:%s\"} tagId_i:(%s)", categoryId, catalogString, catalogString, StringUtils.join(tagIds, " ")));

            params.put("q", StringUtils.join(mandatoryQ, " "));
            params.put("fl", "*, [child parentFilter=id:catalog*]");
            params.put("sort", "rank_i asc, create_s desc");
            params.put("wt", "json");
            String response = null;
            try {
                response = restClient.get(SchemeType.HTTP, solrUrl, 8984, "solr/demo/select", params);
            } catch (HttpHostConnectException e) {
                throw new ProfitMandiBusinessException("", "", "Could not connect to host");
            }
            JSONObject solrResponseJSONObj = new JSONObject(response).getJSONObject("response");
            JSONArray docs = solrResponseJSONObj.getJSONArray("docs");
            dealResponse = getCatalogResponse(docs, false, userInfo.getRetailerId());
        } else {
            return responseSender.badRequest(
                    new ProfitMandiBusinessException("Retailer id", userInfo.getUserId(), "NOT_FOFO_RETAILER"));
        }
        return responseSender.ok(dealResponse.get(0));
    }


    @RequestMapping(value = "/suggestedPoDeals", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE)
    public ResponseEntity<?> suggestedPoDeals(HttpServletRequest request,@RequestBody Set<Integer>catalogIds) throws Exception {

        int userId = (int) request.getAttribute("userId");
        UserCart uc = userAccountRepository.getUserCart(userId);
        int fofoId = uc.getUserId();
        List<FofoCatalogResponse> dealResponse = new ArrayList<>();
        if (!catalogIds.isEmpty()) {
            dealResponse = webSolrService.dealResponse(catalogIds, fofoId);
        }
        return responseSender.ok(dealResponse);
    }

    @RequestMapping(value = "/fofo/brands", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
    @Transactional(readOnly = true)
    public ResponseEntity<?> getBrandsToDisplay(HttpServletRequest request,
                                                @RequestParam(required = false, defaultValue = "0") int categoryId) throws Exception {
        UserInfo userInfo = (UserInfo) request.getAttribute("userInfo");
        logger.info("userInfo [{}]", userInfo);
        List<BrandCatalog> brandsDisplay = brandsService.getBrandsToDisplay(categoryId);
        //List<DBObject> brandsDisplay = mongoClient.getMongoBrands(userInfo.getRetailerId(), userInfo.getEmail(), categoryId);
        return new ResponseEntity<>(brandsDisplay, HttpStatus.OK);
    }

    @RequestMapping(value = "/fofo/brandCatalog", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
    @Transactional(readOnly = true)
    public ResponseEntity<?> getBrands(HttpServletRequest request,
                                       @RequestParam(required = false, defaultValue = "0") int categoryId) throws Exception {
        UserInfo userInfo = (UserInfo) request.getAttribute("userInfo");
        logger.info("userInfo [{}]", userInfo);

        List<BrandCatalog> brandsDisplay = brandsService.getBrands(userInfo.getRetailerId(), userInfo.getEmail(), categoryId);
        return new ResponseEntity<>(brandsDisplay, HttpStatus.OK);
    }

    @RequestMapping(value = "/fofo/accessory/all-categories", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
    @Transactional(readOnly = true)
    public ResponseEntity<?> getSubCategoriesToDisplay(HttpServletRequest request) throws Exception {
        UserInfo userInfo = (UserInfo) request.getAttribute("userInfo");
        logger.info("userInfo [{}]", userInfo);
        List<DBObject> subCategoriesDisplay = this.getSubCategoriesToDisplay();
        return new ResponseEntity<>(subCategoriesDisplay, HttpStatus.OK);
    }

    private List<DBObject> getSubCategoriesToDisplay() throws Exception {
        List<DBObject> subCategories = new ArrayList<>();
                Map<String, String> params = new HashMap<>();
        params.put("q", "categoryId_i:6");
        params.put("group", "true");
        params.put("group.field", "subCategoryId_i");
        params.put("wt", "json");
        params.put("rows", "50");
        params.put("fl", "subCategoryId_i");
        String response = null;
        try {
            response = restClient.get(SchemeType.HTTP, solrUrl, 8984, "solr/demo/select", params);
        } catch (HttpHostConnectException e) {
            throw new ProfitMandiBusinessException("", "", "Could not connect to host");
        }
        JSONObject solrResponseJSONObj = new JSONObject(response).getJSONObject("grouped");
        JSONArray groups = solrResponseJSONObj.getJSONObject("subCategoryId_i").getJSONArray("groups");
        List<Integer> categoryIds = new ArrayList<>();
        for (int i = 0; i < groups.length(); i++) {
            JSONObject groupObject = groups.getJSONObject(i);
            int subCategoryId = groupObject.getInt("groupValue");
            int quantity = groupObject.getJSONObject("doclist").getInt("numFound");
            categoryIds.add(subCategoryId);
        }

        List<Category> categories = categoryRepository.selectByIds(categoryIds);
        AtomicInteger i = new AtomicInteger(0);
        categories.forEach(x -> {
            DBObject dbObject = new BasicDBObject();
            dbObject.put("name", x.getLabel());
            dbObject.put("subCategoryId", x.getId());
            dbObject.put("rank", i.incrementAndGet());
            dbObject.put("categoryId", 6);
            dbObject.put("url", "https://images.smartdukaan.com/uploads/campaigns/" + x.getId() + ".png");
            subCategories.add(dbObject);
        });

        return subCategories;

    }

    @RequestMapping(value = "/banners/{bannerType}", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
    @Transactional(readOnly = true)
    public ResponseEntity<?> getBanners(@PathVariable String bannerType) {
        return new ResponseEntity<>(mongoClient.getBannersByType(bannerType), HttpStatus.OK);
    }

    @RequestMapping(value = "/deals/subCategories", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
    @Transactional(readOnly = true)
    public ResponseEntity<?> getSubcategoriesToDisplay() {
        return new ResponseEntity<>(mongoClient.getSubcategoriesToDisplay(), HttpStatus.OK);
    }

    @ApiImplicitParams({@ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header")})
    @RequestMapping(value = "/deals/skus/{skus}", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
    @Transactional(readOnly = true)
    public ResponseEntity<?> getDealsBySkus(@PathVariable String skus) throws ProfitMandiBusinessException {
        StringBuffer sb = new StringBuffer("/getDealsForNotification/");
        String uri = sb.append(skus).toString();
                String response;
        try {
            response = restClient.get(SchemeType.HTTP, host, port, uri, new HashMap<>());
        } catch (HttpHostConnectException e) {
            throw new ProfitMandiBusinessException("", "", "Could not connect to host");
        }
        JsonArray result_json = Json.parse(response).asArray();
        List<Object> responseObject = new ArrayList<>();
        for (JsonValue j : result_json) {
            // logger.info("res " + j.asArray());
            List<Object> innerObject = new ArrayList<>();
            for (JsonValue jsonObject : j.asArray()) {
                innerObject.add(toDealObject(jsonObject.asObject()));
            }
            if (innerObject.size() > 0) {
                responseObject.add(innerObject);
            }
        }
        return responseSender.ok(responseObject);
    }

    @RequestMapping(value = "/partner/listing", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
    @Transactional(readOnly = true)
    public ResponseEntity<?> getPartnersListing(HttpServletRequest request) throws Exception {
        List<WebListing> webListings = webListingRepository.selectAllWebListingByType(Optional.of(true), WebListingSource.partner);
        UserInfo userInfo = (UserInfo) request.getAttribute("userInfo");

        // Pre-fetch FofoStore once (instead of N times inside getDealResponses)
        FofoStore fs = fofoStoreRepository.selectByRetailerId(userInfo.getRetailerId());

        for (WebListing webListing : webListings) {
            webListing.setFofoCatalogResponses(getDealResponses(userInfo, fs, webListing, 0, 20));
        }
        return responseSender.ok(webListings);
    }

    private List<FofoCatalogResponse> getDealResponses(UserInfo userInfo, FofoStore fs, WebListing webListing, int offset,
                                                       int limit) throws Exception {

        Map<String, String> params = new HashMap<>();
        List<String> mandatoryQ = new ArrayList<>();

        params.put("sort", "w" + fs.getWarehouseId() + "_i desc");

        List<Integer> webProducts = null;
        if (webListing.getType().equals(WebListingType.solr)) {
            logger.info("solrtype {}", webListing.getSolrQuery());
            mandatoryQ.add(String.format("+{!parent which=\"" + webListing.getSolrQuery() + "\"} AND active_b:true AND show_default_b:true"));
        } else {
            logger.info("solrtype2 {}", webListing.getSolrQuery());

            webProducts = webProductListingRepository.selectAllByWebListingId(webListing.getId(), offset, limit).stream().filter(x -> x.getRank() > 0).map(x -> x.getEntityId()).collect(Collectors.toList());

            if (webProducts.size() == 0) {
                return new ArrayList<>();
            }

            mandatoryQ.add(String.format(
                    "+{!parent which=\"catalogId_i:(" + StringUtils.join(webProducts, " ") + ")\"} AND active_b:true AND show_default_b:true"));

        }
        params.put("q", StringUtils.join(mandatoryQ, " "));
        params.put("fl", "*, [child parentFilter=id:catalog* childFilter=active_b:true ]");

        params.put("start", String.valueOf(offset));
        params.put("rows", String.valueOf(limit));
        params.put("wt", "json");
        String response = null;
        try {
            response = restClient.get(SchemeType.HTTP, solrUrl, 8984, "solr/demo/select", params);
        } catch (HttpHostConnectException e) {
            throw new ProfitMandiBusinessException("", "", "Could not connect to host");
        }
        JSONObject solrResponseJSONObj = new JSONObject(response).getJSONObject("response");
        JSONArray docs = solrResponseJSONObj.getJSONArray("docs");
        List<FofoCatalogResponse> dealResponse = getCatalogResponse(docs, false, userInfo.getRetailerId());

        if (webProducts != null && webListing.getUrl().equals("new-launches")) {
            List<Integer> webProductsFinal = webProducts;
            dealResponse = dealResponse.stream().sorted(Comparator.comparing(x -> webProductsFinal.indexOf(x.getCatalogId()))).collect(Collectors.toList());

        }

        return dealResponse;
    }

    @Autowired
    private SaholicCISTableRepository saholicCISTableRepository;

    private List<FofoCatalogResponse> getCatalogResponse(JSONArray docs, boolean hotDeal, int fofoId) throws
            Exception {
        List<FofoCatalogResponse> dealResponse = new ArrayList<>();
        List<Integer> tagIds = Arrays.asList(4);
        List<Integer> itemIds = new ArrayList<>();
        Map<Integer, Integer> partnerStockAvailabilityMap = null;
        if (docs.length() > 0) {
            for (int i = 0; i < docs.length(); i++) {
                JSONObject doc = docs.getJSONObject(i);
                if (doc.has("_childDocuments_")) {
                    for (int j = 0; j < doc.getJSONArray("_childDocuments_").length(); j++) {
                        JSONObject childItem = doc.getJSONArray("_childDocuments_").getJSONObject(j);
                        int itemId = childItem.getInt("itemId_i");
                        itemIds.add(itemId);
                    }
                }
            }
            if (itemIds.size() == 0) {
                return dealResponse;
            }
        }
        // get warehouse Id
        int warehouseId = fofoStoreRepository.selectByRetailerId(fofoId).getWarehouseId();
        Map<Integer, List<SaholicPOItem>> poItemAvailabilityMap = saholicInventoryService.getSaholicPOItems().get(warehouseId);
        List<Integer> catalogIds = new ArrayList<>();
        for (int i = 0; i < docs.length(); i++) {
            JSONObject doc = docs.getJSONObject(i);
            catalogIds.add(doc.getInt("catalogId_i"));
        }
        List<CreateOfferRequest> allSchemOffers = null;
        Map<Integer, PriceCircularItemModelNew> priceCircularItemModelMap = new HashMap<>();
        if (catalogIds.size() > 0) {
            PriceCircularModel priceCircularModel = priceCircularService.getPriceCircularByOffer(fofoId, catalogIds, LocalDate.now());
            allSchemOffers = priceCircularModel.getOffers();

            List<PriceCircularItemModelNew> priceCircularItemModelNews = priceCircularModel.getPriceCircularItemModelNews();
            if (priceCircularItemModelNews != null) {
                priceCircularItemModelMap = priceCircularItemModelNews.stream().collect(Collectors.toMap(x -> x.getCatalogId(), x -> x));
            }
        }

        /*List<CatalogFavourite> catalogFavourites = catalogFavouriteRepository.selectBypartnerId(fofoId);
        List<Integer> catalogFavouriteIds = new ArrayList<>();
        if (!catalogFavourites.isEmpty()) {
            catalogFavouriteIds = catalogFavourites.stream().map(x -> x.getCatalogId()).collect(Collectors.toList());
        }

        if (!catalogFavourites.isEmpty()) {
            catalogFavourites.stream().collect(Collectors.toMap(x -> x.getCatalogId(), x -> x));
        }*/

        if (fofoId > 0) {
            partnerStockAvailabilityMap = currentInventorySnapshotRepository.selectItemsStock(fofoId).stream().collect(Collectors.toMap(x -> x.getItemId(), x -> x.getAvailability()));
            logger.info("partnerStockAvailabilityMap: {}",partnerStockAvailabilityMap);
        }
        List<CatalogFavourite> catalogFavouriteList = catalogFavouriteRepository.selectBypartnerId(fofoId);
        Set<Integer> favouriteCatalogIds = catalogFavouriteList.stream()
                .map(CatalogFavourite::getCatalogId)
                .collect(Collectors.toSet());

        // Pre-fetch CIS data for all items (batch query instead of N+1)
        Map<Integer, List<SaholicCISTable>> cisDataByItemId = saholicCISTableRepository
                .selectByItemWarehouse(itemIds, warehouseId).stream()
                .collect(Collectors.groupingBy(SaholicCISTable::getItemId));

        // Pre-fetch all Items (batch query instead of N+1)
        Map<Integer, Item> itemMap = itemRepository.selectByIds(new HashSet<>(itemIds)).stream()
                .collect(Collectors.toMap(Item::getId, x -> x));

        // Pre-fetch cashback data for all catalogs (batch query instead of N+1)
        Map<Integer, Float> cashbackMap = schemeService.getCatalogSchemeCashBack(fofoId, catalogIds);

        // Pre-fetch web offers (call once instead of inside loop)
        Map<Integer, List<WebOffer>> webOffersMap = webOfferRepository.selectAllActiveOffers();

        // Pre-fetch combo models (call once instead of inside loop)
        Map<Integer, List<ComboModel>> comboModelsByCatalogId = comboModelRepository.selectByWarehouseId(warehouseId)
                .stream().collect(Collectors.groupingBy(ComboModel::getCatalogId));

        for (int i = 0; i < docs.length(); i++) {
            Map<Integer, FofoAvailabilityInfo> fofoAvailabilityInfoMap = new HashMap<>();
            JSONObject doc = docs.getJSONObject(i);
            FofoCatalogResponse fofoCatalogResponse = new FofoCatalogResponse();
            fofoCatalogResponse.setCatalogId(doc.getInt("catalogId_i"));
            fofoCatalogResponse.setImageUrl(doc.getString("imageUrl_s"));
            fofoCatalogResponse.setTitle(doc.getString("title_s"));
            fofoCatalogResponse.setSuperCatalogTitle(doc.getString("superCatalog_s"));
            fofoCatalogResponse.setSuperCatalogId(doc.getInt("superCatalog_i"));
            fofoCatalogResponse.setSuperCatalogVariants(doc.getString("superCatalogVariants_s"));

            if (favouriteCatalogIds.contains(fofoCatalogResponse.getCatalogId())) {
                fofoCatalogResponse.setFavourite(true);
            } else {
                fofoCatalogResponse.setFavourite(false); // optional, since default is false
            }
            List<WebOffer> webOffers = webOffersMap.get(fofoCatalogResponse.getCatalogId());

            //logger.info("webOffers {}", webOffers);
            if (webOffers != null && webOffers.size() > 0) {
                fofoCatalogResponse.setWebOffers(webOffers);
                fofoCatalogResponse.setOffers(webOffers.stream().map(x -> x.getTitle()).collect(Collectors.toList()));

            }

            List<ComboModel> comboModels = comboModelsByCatalogId.get(fofoCatalogResponse.getCatalogId());

            //logger.info("comboModels {}", comboModels);

            if (comboModels != null && comboModels.size() > 0) {
                fofoCatalogResponse.setComboModels(comboModels);
            }

            try {
                fofoCatalogResponse.setFeature(doc.getString("feature_s"));
            } catch (Exception e) {
                fofoCatalogResponse.setFeature(null);
                logger.info("Could not find Feature_s for {}", fofoCatalogResponse.getCatalogId());
            }

            fofoCatalogResponse.setBrand(doc.getJSONArray("brand_ss").getString(0));
            logger.info("labelss {}", doc.has("label_ss"));

            if (doc.has("label_ss")) {
                logger.info("label {}", doc.getJSONArray("label_ss"));

                JSONArray arr = doc.getJSONArray("label_ss");
                Set<String> labels = new HashSet<String>();
                for (int j = 0; j < arr.length(); j++) {
                    labels.add(arr.getString(j));
                }

                fofoCatalogResponse.setLabels(new ArrayList<>(labels));

            }
            if (doc.has("similarModels_ii")) {
                JSONArray similarModelsArray = doc.getJSONArray("similarModels_ii");
                List<Integer> similarCatalogIds = new ArrayList<>();
                for (int j = 0; j < similarModelsArray.length(); j++) {
                    similarCatalogIds.add(similarModelsArray.getInt(j));
                }
                fofoCatalogResponse.setSimilarModelIds(similarCatalogIds);
            }

            if (doc.has("_childDocuments_")) {
                String modelColorClass = "grey";
                FofoAvailabilityInfo fdiAnyColour = null;
                // Iterating itemIds
                for (int j = 0; j < doc.getJSONArray("_childDocuments_").length(); j++) {
                    PriceCircularItemModelNew priceCircularItemModel = priceCircularItemModelMap.get(fofoCatalogResponse.getCatalogId());
                    JSONObject childItem = doc.getJSONArray("_childDocuments_").getJSONObject(j);
                    int itemId = childItem.getInt("itemId_i");
                    float sellingPrice = (float) childItem.getDouble("sellingPrice_f");
                    int partnerAvailability = partnerStockAvailabilityMap.get(itemId) == null ? 0 : partnerStockAvailabilityMap.get(itemId);
                    if (!fofoAvailabilityInfoMap.containsKey(itemId)) {
                        FofoAvailabilityInfo fdi = new FofoAvailabilityInfo();
                        List<SaholicCISTable> currentAvailability = cisDataByItemId.getOrDefault(itemId, new ArrayList<>());
                        List<SaholicPOItem> poItemAvailability = null;
                        if (poItemAvailabilityMap != null) {
                            poItemAvailability = poItemAvailabilityMap.get(itemId);
                        }

                        if (priceCircularItemModel != null) {
                            fdi.setNlc((float) priceCircularItemModel.getNetNlc());
                        }

                        for (SaholicCISTable saholicCISTable : currentAvailability) {
                            saholicCISTable.setWarehouseName(
                                    ProfitMandiConstants.WAREHOUSE_MAP.get(saholicCISTable.getWarehouseFrom()));
                        }

                        Map<Integer, SaholicCISTable> map = currentAvailability.stream().collect(Collectors.toMap(SaholicCISTable::getWarehouseFrom, x -> x));
                        if (poItemAvailability != null) {
                            for (SaholicPOItem saholicPOItem : poItemAvailability) {
                                if (map.containsKey(saholicPOItem.getWarehouseFrom())) {
                                    map.get(saholicPOItem.getWarehouseFrom()).setPopendingQty(saholicPOItem.getUnfulfilledQty());
                                } else {
                                    SaholicCISTable saholicCISTable = new SaholicCISTable();
                                    saholicCISTable.setAvailability(0);
                                    saholicCISTable.setReserved(0);
                                    saholicCISTable.setItemId(itemId);
                                    saholicCISTable.setWarehouseId(warehouseId);
                                    saholicCISTable.setPopendingQty(saholicPOItem.getUnfulfilledQty());
                                    saholicCISTable.setWarehouseFrom(saholicPOItem.getWarehouseFrom());
                                    saholicCISTable.setWarehouseName(
                                            ProfitMandiConstants.WAREHOUSE_MAP.get(saholicPOItem.getWarehouseFrom()));
                                    map.put(saholicPOItem.getWarehouseFrom(), saholicCISTable);
                                }
                            }
                        }
                        fdi.setSaholicCISTableList(new ArrayList<>(map.values()));
                        String poColor = "grey";
                        boolean active = false;
                        if (currentAvailability != null && currentAvailability.stream().collect(Collectors.summingInt(SaholicCISTable::getNetAvailability)) > 0) {
                            poColor = "green";
                            modelColorClass = "green";
                        } else if (poItemAvailability != null && poItemAvailability.stream().collect(Collectors.summingInt(SaholicPOItem::getUnfulfilledQty)) > 0) {
                            if (currentAvailability != null && poItemAvailability.stream().collect(Collectors.summingInt(SaholicPOItem::getUnfulfilledQty)) + currentAvailability.stream().collect(Collectors.summingInt(SaholicCISTable::getNetAvailability)) <= 0) {
                                poColor = "grey";
                            } else {
                                poColor = "yellow";
                                if (!"green".equals(modelColorClass)) {
                                    modelColorClass = poColor;
                                }
                            }
                        }
                        fdi.setColorClass(poColor);
                        fdi.setSellingPrice(sellingPrice);
                        fdi.setActive(active);
                        fdi.setMrp(childItem.getDouble("mrp_f"));
                        fdi.setMop((float) childItem.getDouble("mop_f"));
                        fdi.setColor(childItem.has("color_s") ? childItem.getString("color_s") : "");
                        if (fdi.getColor().equalsIgnoreCase("any colour")) {
                            fdiAnyColour = fdi;
                        }
                        fdi.setBrand((String) doc.getJSONArray("brand_ss").get(0));
                        fdi.setCategoryId(doc.getInt("subCategoryId_i"));
                        fdi.setTagId(childItem.getInt("tagId_i"));
                        fdi.setItem_id(itemId);
                        fdi.setCatalog_id(doc.getInt("catalogId_i"));
                        Float cashBack = cashbackMap.get(fofoCatalogResponse.getCatalogId());
                        cashBack = cashBack == null ? 0 : cashBack;
                        fdi.setCashback(cashBack);
                        fdi.setMinBuyQuantity(1);
                        if (hotDeal) {
                            if (currentAvailability != null) {
                                fdi.setAvailability(currentAvailability.stream().collect(Collectors.summingInt(SaholicCISTable::getNetAvailability)));
                            } else {
                                fdi.setAvailability(0);
                            }
                            fdi.setPartnerAvailability(partnerAvailability);
                        } else {
                            // Lets consider that its out of stock
                            fdi.setAvailability(400);
                            Item item = itemMap.get(itemId);
                            // In case its tampered glass moq should be
                            if (item != null && item.getCategoryId() == 10020) {
                                fdi.setMinBuyQuantity(5);
                            }
                        }
                        fdi.setQuantityStep(1);
                        fdi.setMaxQuantity(Math.min(fdi.getAvailability(), 400));
                        fofoAvailabilityInfoMap.put(itemId, fdi);
                    }
                }
                if (fdiAnyColour != null) {
                    fdiAnyColour.setColorClass(modelColorClass);
                }
                fofoCatalogResponse.setInStock(!modelColorClass.equals("grey"));
            }
            if (fofoAvailabilityInfoMap.values().size() > 0) {
                List<FofoAvailabilityInfo> availabilityList = fofoAvailabilityInfoMap.values().stream().sorted(Comparator.comparing(FofoAvailabilityInfo::getAvailability).reversed()).collect(Collectors.toList());
                fofoCatalogResponse.setItems(availabilityList);
                if (priceCircularItemModelMap.containsKey(fofoCatalogResponse.getCatalogId())) {
                    PriceCircularItemModelNew priceCircularItemModel = priceCircularItemModelMap.get(fofoCatalogResponse.getCatalogId());
                    if (priceCircularItemModel.getSlabPayouts() != null) {
                        List<CreateOfferRequest> schemeOffers = new ArrayList<>();
                        List<Map<Integer, AmountModel>> slabPayouts = priceCircularItemModel.getSlabPayouts();
                        Iterator<Map<Integer, AmountModel>> iterator = slabPayouts.iterator();
                        int iteratorCount = 0;
                        while (iterator.hasNext()) {
                            Map<Integer, AmountModel> slabPayoutMap = iterator.next();
                            if (slabPayoutMap != null) {
                                schemeOffers.add(allSchemOffers.get(iteratorCount));
                            } else {
                                iterator.remove();
                            }
                            iteratorCount++;
                        }
                        fofoCatalogResponse.setSchemeOffers(schemeOffers);
                    }
                    fofoCatalogResponse.setPriceCircularItemModel(priceCircularItemModel);
                }
                dealResponse.add(fofoCatalogResponse);
            }
        }
        return dealResponse;

    }

    private List<FofoCatalogResponse> getCatalogSingleSkuResponse(JSONArray
                                                                          docs, Map<Integer, Integer> itemFilter, boolean hotDeal) throws ProfitMandiBusinessException {
        List<FofoCatalogResponse> dealResponse = new ArrayList<>();
        List<Integer> tagIds = Arrays.asList(4);

        Map<Integer, TagListing> itemTagListingMap = tagListingRepository.selectByItemIdsAndTagIds(itemFilter.keySet(), new HashSet<>(tagIds)).stream().collect(Collectors.toMap(x -> x.getItemId(), x -> x));

        // Pre-fetch all items (batch query instead of N+1)
        Map<Integer, Item> itemMap = itemRepository.selectByIds(itemFilter.keySet()).stream()
                .collect(Collectors.toMap(Item::getId, x -> x));

        for (int i = 0; i < docs.length(); i++) {
            Map<Integer, FofoAvailabilityInfo> fofoAvailabilityInfoMap = new HashMap<>();
            JSONObject doc = docs.getJSONObject(i);

            for (int j = 0; j < doc.getJSONArray("_childDocuments_").length(); j++) {
                JSONObject childItem = doc.getJSONArray("_childDocuments_").getJSONObject(j);
                int itemId = childItem.getInt("itemId_i");
                TagListing tl = itemTagListingMap.get(itemId);
                if (tl == null) {
                    continue;
                }
                if (hotDeal) {
                    if (!tl.isHotDeals()) {
                        continue;
                    }
                }
                float sellingPrice = (float) childItem.getDouble("sellingPrice_f");
                if (fofoAvailabilityInfoMap.containsKey(itemId)) {
                    if (fofoAvailabilityInfoMap.get(itemId).getSellingPrice() > sellingPrice) {
                        fofoAvailabilityInfoMap.get(itemId).setSellingPrice(sellingPrice);
                        fofoAvailabilityInfoMap.get(itemId).setMop((float) childItem.getDouble("mop_f"));
                    }
                } else {
                    FofoAvailabilityInfo fdi = new FofoAvailabilityInfo();
                    fdi.setSellingPrice((float) childItem.getDouble("sellingPrice_f"));
                    fdi.setMop((float) childItem.getDouble("mop_f"));
                    fdi.setMop((float) tl.getMrp());
                    fdi.setColor(childItem.has("color_s") ? childItem.getString("color_s") : "");
                    fdi.setTagId(childItem.getInt("tagId_i"));
                    fdi.setItem_id(itemId);
                    fdi.setCatalog_id(doc.getInt("catalogId_i"));
                    Item item = itemMap.get(itemId);
                    // In case its tampered glass moq should be 5
                    if (item != null && item.getCategoryId() == 10020) {
                        fdi.setMinBuyQuantity(10);
                    } else {
                        fdi.setMinBuyQuantity(1);
                    }
                    fdi.setAvailability(itemFilter.get(itemId));
                    fdi.setQuantityStep(1);
                    fdi.setMaxQuantity(Math.min(fdi.getAvailability(), 100));
                    fofoAvailabilityInfoMap.put(itemId, fdi);
                }
            }
            if (fofoAvailabilityInfoMap.values().size() > 0) {
                for (FofoAvailabilityInfo fofoAvailabilityInfo : fofoAvailabilityInfoMap.values()) {
                    FofoCatalogResponse ffdr = new FofoCatalogResponse();
                    ffdr.setCatalogId(doc.getInt("catalogId_i"));
                    ffdr.setImageUrl(doc.getString("imageUrl_s"));
                    ffdr.setTitle(doc.getString("title_s"));
                    try {
                        ffdr.setFeature(doc.getString("feature_s"));
                    } catch (Exception e) {
                        ffdr.setFeature(null);
                        logger.info("Could not find Feature_s for {}", ffdr.getCatalogId());
                    }
                    ffdr.setBrand(doc.getJSONArray("brand_ss").getString(0));
                    ffdr.setItems(Arrays.asList(fofoAvailabilityInfo));
                    dealResponse.add(ffdr);
                }
            }
        }
        return dealResponse;

    }

    @RequestMapping(value = "/combo", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
    @Transactional(readOnly = true)
    public ResponseEntity<?> getBanners(@RequestParam int catalogId, @RequestParam int warehouseId) {
        List<ComboModel> comboModels = comboModelRepository.selectByCatalogIdAndWarehouseId(catalogId, warehouseId);
        return responseSender.ok(comboModels);
    }

    @RequestMapping(value = "/checkCombo", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
    @Transactional(readOnly = true)
    public ResponseEntity<?> checkCombo(HttpServletRequest request, @RequestParam int catalogId,
                                        @RequestParam int warehouseId, @RequestParam int qty) throws Exception {
        boolean isCombo = false;
        ComboModel comboModel = comboModelRepository.selectByCatalogIdWarehouseIdAndQty(catalogId, warehouseId, qty);
        if (comboModel != null) {
            isCombo = true;
        }

        return responseSender.ok(isCombo);
    }

    @GetMapping(value = "/partner/wodCompleteBrands", produces = MediaType.APPLICATION_JSON_VALUE)
    @Transactional(readOnly = true)
    public ResponseEntity<?> getWodcompletBrands(HttpServletRequest request) throws Exception {
        UserInfo userInfo = (UserInfo) request.getAttribute("userInfo");
        BrandAndAddToCartEligibleModel brandAndAddToCartEligibleModel = brandsService.wodcompletBrands(userInfo.getRetailerId());
        return responseSender.ok(brandAndAddToCartEligibleModel);

    }

}