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.integrations.pinelabs.PinelabsAffordabilityService;

import com.spice.profitmandi.service.integrations.pinelabs.PinelabsOfferCacheService;

import com.spice.profitmandi.service.integrations.pinelabs.dto.OfferDiscoveryRequest;

import com.spice.profitmandi.service.integrations.pinelabs.dto.OfferDiscoveryResponse;

import com.spice.profitmandi.service.integrations.pinelabs.dto.Tenure;

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.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

    PinelabsAffordabilityService pinelabsAffordabilityService;

    // 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 PinelabsOfferCacheService pinelabsOfferCacheService;

    @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)

    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)

    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)

    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)

    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)

    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)

    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")

    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")

    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")

    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")

    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)

    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)

    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)

    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 = "/fofo/categories", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

    public ResponseEntity<?> getFofoCategories() {

        Map<Integer, Category> categoryMap = categoryRepository.selectAll();

        List<Map<String, Object>> result = new ArrayList<>();

        for (Category category : categoryMap.values()) {

            if (category.isStatus()) {

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

                cat.put("id", category.getId());

                cat.put("label", category.getLabel());

                cat.put("displayName", category.getDisplayName());

                cat.put("parentCategoryId", category.getParentCategoryId());

                cat.put("marginOnly", category.isMarginOnly());

                result.add(cat);

            }

        }

        return responseSender.ok(result);

    }

    @RequestMapping(value = "/banners/{bannerType}", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

    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)

    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)

    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)

    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.isEmpty()) {

            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"));

            // optional, since default is false

            fofoCatalogResponse.setFavourite(favouriteCatalogIds.contains(fofoCatalogResponse.getCatalogId()));

            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()));

            }

            /*Map<Integer, OfferDiscoveryResponse> pineResponse = pinelabsOfferCacheService.getCachedOffersForItems(fofoCatalogResponse.getItems().stream().map(x -> (int) x.getItem_id()).collect(Collectors.toList()));

            if (pineResponse != null && pineResponse.size() > 0) {

                fofoCatalogResponse.setPineOffers(pineResponse);

            }*/

            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());

            }