Subversion Repositories SmartDukaan

package com.spice.profitmandi.dao.service.shopify;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.spice.profitmandi.common.enumuration.SchemeType;
import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
import com.spice.profitmandi.common.web.client.RestClient;
import com.spice.profitmandi.dao.entity.dtr.WebOffer;
import com.spice.profitmandi.dao.entity.fofo.FofoStore;
import com.spice.profitmandi.dao.repository.catalog.ItemRepository;
import com.spice.profitmandi.dao.repository.dtr.FofoStoreRepository;
import com.spice.profitmandi.dao.repository.dtr.WebOfferRepository;
import com.spice.profitmandi.dao.repository.fofo.CurrentInventorySnapshotRepository;
import com.spice.profitmandi.service.inventory.FofoAvailabilityInfo;
import com.spice.profitmandi.service.inventory.FofoCatalogResponse;
import com.spice.profitmandi.service.inventory.SaholicInventoryService;
import org.apache.commons.lang.StringUtils;
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.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;
import java.util.stream.Collectors;

@Service
@Transactional(propagation = Propagation.REQUIRES_NEW)
public class ShopifyService {

    private static final Logger logger = LogManager.getLogger(ShopifyService.class);

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

    @Autowired
    ObjectMapper objectMapper = new ObjectMapper();
    @Autowired
    ShopifyGraphQLService shopifyGraphQLService;
    @Autowired
    RestClient restClient;
    @Autowired
    FofoStoreRepository fofoStoreRepository;
    @Autowired
    ItemRepository itemRepository;
    @Autowired
    WebOfferRepository webOfferRepository;
    @Autowired
    CurrentInventorySnapshotRepository currentInventorySnapshotRepository;
    @Autowired
    SaholicInventoryService saholicInventoryService;

    // -------------------------------
    // ✅ 1. Create Product (with duplicate check)
    // -------------------------------
    public JsonNode createProduct(Map<String, Object> productInput) {
        try {
            return shopifyGraphQLService.productCreate(productInput);
        } catch (Exception e) {
            logger.error("createProduct Error: {}", e.getMessage());
            return objectMapper.createObjectNode();
        }
    }

    // -------------------------------
    // ✅ 2. Get All Products
    // -------------------------------
    public JsonNode getAllProducts() {
        try {
            String query = "query { products(first: 50) { edges { node { id title handle } } } }";
            return shopifyGraphQLService.execute(query, null);
        } catch (Exception e) {
            logger.error("getAllProducts Error: {}", e.getMessage());
            return objectMapper.createObjectNode();
        }
    }

    // -------------------------------
    // ✅ 3. Get Product by ID
    // -------------------------------
    public JsonNode getProductById(String productId) {
        try {
            String query = "query($id: ID!) { product(id: $id) { id title handle } }";
            Map<String, Object> vars = new HashMap<String, Object>();
            vars.put("id", productId);
            return shopifyGraphQLService.execute(query, vars);
        } catch (Exception e) {
            logger.error("getProductById Error: {}", e.getMessage());
            return objectMapper.createObjectNode();
        }
    }

    // -------------------------------
    // ✅ 4. Update Product by ID
    // -------------------------------
    public JsonNode updateProductById(String productId, Map<String, Object> params) {
        try {
            params.put("id", productId);
            String mutation = "mutation($input: ProductInput!) { productUpdate(input: $input) { product { id title } userErrors { field message } } }";
            Map<String, Object> vars = new HashMap<String, Object>();
            vars.put("input", params);
            return shopifyGraphQLService.execute(mutation, vars);
        } catch (Exception e) {
            logger.error("updateProductById Error: {}", e.getMessage());
            return objectMapper.createObjectNode();
        }
    }

    // -------------------------------
    // ✅ 5. Delete Product by ID
    // -------------------------------
    public JsonNode deleteProductById(String productId) {
        try {
            String mutation = "mutation($input: ProductDeleteInput!) { productDelete(input: $input) { deletedProductId userErrors { field message } } }";
            Map<String, Object> vars = new HashMap<String, Object>();
            Map<String, Object> input = new HashMap<String, Object>();
            input.put("id", productId);
            vars.put("input", input);
            return shopifyGraphQLService.execute(mutation, vars);
        } catch (Exception e) {
            logger.error("deleteProductById Error: {}", e.getMessage());
            return objectMapper.createObjectNode();
        }
    }

    public JsonNode getAllLocations() {
        try {
            String query = "query { locations(first: 10) { edges { node { id name } } } }";
            return shopifyGraphQLService.execute(query, null);
        } catch (Exception e) {
            logger.error("getAllLocations Error: {}", e.getMessage());
            return objectMapper.createObjectNode();
        }
    }

    public String getPrimaryLocationId() {
        try {
            JsonNode locationsResponse = getAllLocations();
            JsonNode edges = locationsResponse
                    .path("locations")
                    .path("edges");

            if (edges.isArray() && edges.size() > 0) {
                String locationId = edges.get(0).path("node").path("id").asText();
                logger.info("✅ Using Shopify Location ID: {}", locationId);
                return locationId;
            } else {
                logger.warn("⚠️ No Shopify locations found.");
                return null;
            }
        } catch (Exception e) {
            logger.error("getPrimaryLocationId Error: {}", e.getMessage());
            return null;
        }
    }

    public List<Map<String, Object>> buildAllVariantsBulk(List<FofoAvailabilityInfo> items, List<Map<String, String>> variantAttrs) {

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

        for (FofoAvailabilityInfo item : items) {
            String color = item.getColor().trim();
            String price = String.valueOf(item.getSellingPrice());
            String compareAt = String.valueOf(item.getMrp());

            for (Map<String, String> attr : variantAttrs) {
                String storageValue = attr.get("variantName").trim();
                String sku = String.valueOf(attr.get("catalogId"));
                list.add(buildVariant(color, storageValue, price, compareAt, sku));
            }
        }

        return list;
    }

    public Map<String, JsonNode> fetchVariantMapByOptions(String productId) throws Exception {
        String query =
            "query getVariants($id: ID!) { " +
                "  product(id: $id) { " +
                "    variants(first: 100) { " +
                "      edges { " +
                "        node { " +
                "          id " +
                "          title " +
                "          sku " +
                "          inventoryItem { id } " +
                "          selectedOptions { name value } " +
                "          image { originalSrc } " +
                "        } " +
                "      } " +
                "    } " +
                "  } " +
                "}";

        Map<String,Object> vars = new HashMap<>();
        vars.put("id", productId);

        JsonNode data = shopifyGraphQLService.execute(query, vars);
        JsonNode edges = data.path("product").path("variants").path("edges");

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

        for (JsonNode edge : edges) {
            JsonNode node = edge.path("node");

            String color = "", variant = "", insurance = "";

            for (JsonNode opt : node.path("selectedOptions")) {
                String name = opt.path("name").asText();
                String value = opt.path("value").asText();
                if ("Color".equalsIgnoreCase(name)) color = value;
                if ("Variant".equalsIgnoreCase(name)) variant = value;
                if ("Insurance".equalsIgnoreCase(name)) insurance = value;
            }

            String key = color + "|" + variant + "|" + insurance;
            map.put(key.trim(), node);
        }

        return map;
    }

    public List<JsonNode> getAllOrders() {
        List<JsonNode> allOrders = new ArrayList<>();
        try {
            String cursor = null;
            while (true) {
                JsonNode page = shopifyGraphQLService.getOrders(cursor);
                JsonNode ordersNode = page.path("orders");
                JsonNode edges = ordersNode.path("edges");
                for (JsonNode edge : edges) {
                    allOrders.add(edge.path("node"));
                }
                boolean hasNext = ordersNode.path("pageInfo").path("hasNextPage").asBoolean();
                if (!hasNext) break;
                cursor = ordersNode.path("pageInfo").path("endCursor").asText();
            }
        } catch (Exception e) {
            logger.error("getAllOrders Error: {}", e.getMessage());
        }
        return allOrders;
    }

    public JsonNode getOrderDetailById(String id) {
        String graphQLId = "gid://shopify/Order/" + id;
        JsonNode order = null;
        try {
            JsonNode orderNode = shopifyGraphQLService.getOrderById(graphQLId);
            order = orderNode.path("order");
        } catch (Exception e) {
            logger.error("getAllOrders Error: {}", e.getMessage());
        }

        return order;
    }

    public List<FofoCatalogResponse> getAllDocs(FofoStore fofoStore) throws Exception {

        Map<String, String> params = new HashMap<String, String>();
        List<String> mandatoryQ = new ArrayList<String>();
        mandatoryQ.add("+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", "10");

        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 getCatalogResponse(docs, fofoStore.getId());

    }

    public List<FofoCatalogResponse> getAllDocsPaginated(FofoStore fofoStore, int batchSize) throws Exception {
        List<FofoCatalogResponse> allProducts = new ArrayList<>();
        int start = 0;

        while (true) {
            Map<String, String> params = new HashMap<>();
            params.put("q", "+active_b:true AND show_default_b:true");
            params.put("fl", "*, [child parentFilter=id:catalog* childFilter=active_b:true ]");
            params.put("wt", "json");
            params.put("rows", String.valueOf(batchSize));
            params.put("start", String.valueOf(start));

            String response = restClient.get(SchemeType.HTTP, solrUrl, 8984, "solr/demo/select", params);
            JSONObject solrResponseJSONObj = new JSONObject(response).getJSONObject("response");
            int numFound = solrResponseJSONObj.getInt("numFound");
            JSONArray docs = solrResponseJSONObj.getJSONArray("docs");

            if (docs.length() == 0) break;

            List<FofoCatalogResponse> batch = getCatalogResponse(docs, fofoStore.getId());
            allProducts.addAll(batch);

            start += batchSize;
            if (start >= numFound) break;

            logger.info("Fetched {} / {} products from Solr", Math.min(start, numFound), numFound);
        }

        logger.info("Total products fetched from Solr: {}", allProducts.size());
        return allProducts;
    }

    public List<FofoCatalogResponse> getAllDocsPaginatedForWarehouse(int batchSize) throws Exception {
        List<FofoCatalogResponse> allProducts = new ArrayList<>();
        int start = 0;

        while (true) {
            Map<String, String> params = new HashMap<>();
            params.put("q", "+active_b:true AND show_default_b:true");
            params.put("fl", "*, [child parentFilter=id:catalog* childFilter=active_b:true ]");
            params.put("wt", "json");
            params.put("rows", String.valueOf(batchSize));
            params.put("start", String.valueOf(start));

            String response = restClient.get(SchemeType.HTTP, solrUrl, 8984, "solr/demo/select", params);
            JSONObject solrResponseJSONObj = new JSONObject(response).getJSONObject("response");
            int numFound = solrResponseJSONObj.getInt("numFound");
            JSONArray docs = solrResponseJSONObj.getJSONArray("docs");

            if (docs.length() == 0) break;

            List<FofoCatalogResponse> batch = getCatalogResponse(docs, 0);
            allProducts.addAll(batch);

            start += batchSize;
            if (start >= numFound) break;

            logger.info("Fetched {} / {} products from Solr (warehouse)", Math.min(start, numFound), numFound);
        }

        logger.info("Total products fetched from Solr (warehouse): {}", allProducts.size());
        return allProducts;
    }

    private List<FofoCatalogResponse> getCatalogResponse(JSONArray docs, int fofoId) throws ProfitMandiBusinessException {
        Map<Integer, Integer> ourItemAvailabilityMap = null;
        Map<Integer, Integer> partnerStockAvailabilityMap = new HashMap<>();
        List<FofoCatalogResponse> dealResponse = new ArrayList<>();
        if (docs.length() > 0) {
            HashSet<Integer> itemsSet = new HashSet<>();
            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");
                        itemsSet.add(itemId);
                    }
                }
            }
            if (itemsSet.isEmpty()) {
                return dealResponse;
            }
            if (fofoId > 0) {
                partnerStockAvailabilityMap = currentInventorySnapshotRepository.selectItemsStock(fofoId).stream().collect(Collectors.toMap(x -> x.getItemId(), x -> x.getAvailability()));
            }
            ourItemAvailabilityMap = saholicInventoryService.getTotalAvailabilityByItemIds(new ArrayList<>(itemsSet));
        }

        for (int i = 0; i < docs.length(); i++) {
            Map<Integer, FofoAvailabilityInfo> fofoAvailabilityInfoMap = new HashMap<>();
            JSONObject doc = docs.getJSONObject(i);
            FofoCatalogResponse ffdr = new FofoCatalogResponse();
            ffdr.setCatalogId(doc.getInt("catalogId_i"));
            ffdr.setImageUrl(doc.getString("imageUrl_s"));
            ffdr.setTitle(doc.getString("title_s"));
            ffdr.setSuperCatalogTitle(doc.getString("superCatalog_s"));
            ffdr.setSuperCatalogId(doc.getInt("superCatalog_i"));
            ffdr.setSuperCatalogVariants(doc.getString("superCatalogVariants_s"));
            List<WebOffer> webOffers = webOfferRepository.selectAllActiveOffers().get(ffdr.getCatalogId());
            if (webOffers != null && webOffers.size() > 0) {
                ffdr.setOffers(webOffers.stream().map(x -> x.getTitle()).collect(Collectors.toList()));
            }
            try {
                ffdr.setFeature(doc.getString("feature_s"));
            } catch (Exception e) {
                ffdr.setFeature(null);
            }
            ffdr.setBrand(doc.getJSONArray("brand_ss").getString(0));

            if (doc.has("_childDocuments_")) {
                for (int j = 0; j < doc.getJSONArray("_childDocuments_").length(); j++) {
                    try {
                        JSONObject childItem = doc.getJSONArray("_childDocuments_").getJSONObject(j);
                        int itemId = childItem.getInt("itemId_i");
                        ffdr.setIsSmartPhone(itemRepository.selectById(itemId).isSmartPhone());
                        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(sellingPrice);
                            fdi.setMrp(childItem.getDouble("mrp_f"));
                            fdi.setMop((float) childItem.getDouble("mop_f"));
                            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"));
                            fdi.setCashback(0);
                            fdi.setMinBuyQuantity(1);
                            int partnerAvailability = partnerStockAvailabilityMap.get(itemId) == null ? 0 : partnerStockAvailabilityMap.get(itemId);
                            int ourStockAvailability = ourItemAvailabilityMap.get(itemId) == null ? 0 : Math.max(0, ourItemAvailabilityMap.get(itemId));
                            fdi.setActive(partnerAvailability > 0);
                            fdi.setPartnerAvailability(partnerAvailability);
                            fdi.setAvailability(Math.min(5, ourStockAvailability + partnerAvailability));
                            fdi.setQuantityStep(1);
                            fdi.setMaxQuantity(fdi.getAvailability());
                            fofoAvailabilityInfoMap.put(itemId, fdi);
                        }
                    } catch (Exception e) {
                        logger.warn("Skipping stale item in Solr doc catalogId={}: {}", doc.getInt("catalogId_i"), e.getMessage());
                    }
                }
            }
            if (fofoAvailabilityInfoMap.values().size() > 0) {
                ffdr.setItems(fofoAvailabilityInfoMap.values().stream().sorted(Comparator.comparing(FofoAvailabilityInfo::isActive, Comparator.reverseOrder()).thenComparingInt(y -> -y.getAvailability())).collect(Collectors.toList()));
                dealResponse.add(ffdr);
            }
        }
        return dealResponse.stream().sorted(Comparator.comparing(FofoCatalogResponse::getItems, (s1, s2) -> (s2.get(0).isActive() ? 1 : 0) - (s1.get(0).isActive() ? 1 : 0)).thenComparing(FofoCatalogResponse::getItems, (x, y) -> y.get(0).getAvailability() - x.get(0).getAvailability())).collect(Collectors.toList());
    }

    private List<Map<String, String>> buildSelectedOptions(String color, String storage) {

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

        Map<String, String> c = new HashMap<>();
        c.put("name", "Colour");
        c.put("value", color);
        selectedOptions.add(c);

        Map<String, String> s = new HashMap<>();
        s.put("name", "Storage");
        s.put("value", storage);
        selectedOptions.add(s);

        return selectedOptions;
    }

    private Map<String, Object> buildVariant(String color, String storage, String price, String compareAt, String sku) {
        Map<String, Object> v = new HashMap<>();

        v.put("selectedOptions", this.buildSelectedOptions(color, storage));
        v.put("price", price);
        v.put("compareAtPrice", compareAt);
        v.put("sku", sku);

        return v;
    }
}