package com.napa.pulse.service.impl;

import com.napa.pulse.dao.interfaces.AcoDAO;
import com.napa.pulse.dao.interfaces.SessionDAO;
import com.napa.pulse.dto.*;
import com.napa.pulse.entity.pulseui.*;
import com.napa.pulse.entity.security.User;
import com.napa.pulse.exception.PulseException;
import com.napa.pulse.service.interfaces.SessionService;
import com.napa.pulse.utils.PulseConstants;
import com.napa.pulse.utils.informatica.InformaticaServiceClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.cache.annotation.CacheResult;
import javax.servlet.http.HttpServletResponse;
import java.math.BigDecimal;
import java.util.*;

/**
 * Session Service Implementation for the session
 *
 * @author Tathagata Bhattacharya Created: Feb 09, 2015
 */

@Service
public class SessionServiceImpl implements SessionService {

    private static final Logger LOGGER = LoggerFactory.getLogger(SessionServiceImpl.class);

    @Autowired
    private SessionDAO sessionDAO;

    @Autowired
    private AcoDAO acoDAO;

    @Autowired
    private InformaticaServiceClient informaticaServiceClient;
    @Autowired
    SessionServiceImpl(SessionDAO sessionDAO) {
        this.sessionDAO = sessionDAO;
    }

    /*
     * (non-Javadoc)
     *
     * @see
     * com.napa.pulse.service.interfaces.SessionService#getSessionDetails(java.util.
     * List, java.util.List, java.util.List, java.util.List, java.util.List)
     */
    @Override
    public List<Map<String, Object>> getSessionList(String[] statusTypes, Integer[] siteIds, Integer[] siteGroups,
                                                    Integer[] statusIds, String[] createdDates,String[] ExpirationDates, Integer[] createdByIds,
                                                    User user, String userAccessSites, String[] finalizeDateArray) throws Exception {
        return sessionDAO.getSessionList(statusTypes, siteIds, siteGroups, statusIds, createdDates,ExpirationDates, createdByIds, user,
                userAccessSites, finalizeDateArray);
    }

    @Override
    public List<Map<String, Object>> getAllSessions(User user, String userAccessSites) {
        return sessionDAO.getAllSessions(user, userAccessSites);
    }

    /*
     * (non-Javadoc)
     *
     * @see
     * com.napa.pulse.service.interfaces.SessionService#createNewSession(java.lang.
     * Integer, java.lang.Boolean, java.lang.Boolean, java.lang.Boolean,
     * java.lang.String, java.lang.Integer[], java.lang.Integer[],
     * com.napa.pulse.entity.pulseui.ProductGroupOrderReturn[],
     * com.napa.pulse.entity.pulseui.HierarchyOrderReturn[])
     */
    @Override
    public ActionResultItem<BigDecimal> createNewSession ( User user , Boolean perCarOrder , Boolean includeFleets ,
                                                           Boolean includeSystems , Boolean includeSpecials ,
                                                           Boolean includeObsoletes , Boolean includeOverstocks ,Boolean includeSupersede,
                                                           Boolean includeKeylinesOrders , Boolean includeKeylinesReturns ,
                                                           Boolean includeLessThanStdPkg ,Double includeWeekSupplyOption,String weekSupplyOptionName,  Boolean useInvestmentCollections ,
                                                           Boolean provideStoreDepth , Boolean includeSoldNotStocked , Boolean includeNewNumbers ,
                                                           Boolean orderAllSkus , Boolean returnAllSKUs, Integer dollarLimit , String comment , Integer siteGroupObj ,
                                                           Integer[] sitesArray , ProductGroupOrderReturn[] productGroupsArray ,ProductGroupOrderReturn[] groupCodeArray,
                                                           SiteFleet[] fleetGroupsArray , CustomProductGroup customProductGroup ,CustomGroupCodeProductGroup customGroupCodeProductGroupObj,Boolean isGroupCode,
                                                           String userAccessSites , Integer[] skuArray , ProductLinesData[] productLineIdArray , ProductLinesData[] allProductLines , ProductLinesData[] siteProductLines, Integer includeOrders ,
                                                           Integer includeReturns , Date expirationDate , String includeDaysCount , Integer perCarMinMaxValue ,
                                                           String salesHistoryValue , String displayQty , String sessionType , String includeHubSpokeOrderOption ,
                                                           String includeHubSpokeReturnOption , Boolean applicationPartsOnly ,LeadTimeStatusDTO[] leadTime) throws Exception {
        /*
         * Single site vs Site Group change: - If a Saved Group was used then display
         * the description of the corresponding Saved Group as value.
         *
         * - If a Custom Group was used then: - If resulting list of Sites for the
         * session is a single site then display the description of the Site. - If
         * resulting list of Sites for the session is greater than 1 then display
         * 'Custom Group' as value.
         *
         */

        String savedGroup;
        if (siteGroupObj != null) {
            savedGroup = sessionDAO.getSiteGroupName(siteGroupObj);
        } else {
            if (sitesArray.length == 1) {
                int val = sitesArray[0];
                savedGroup = sessionDAO.getSiteName(val);
            } else {
                savedGroup = "Custom Group";
            }
        }

        Set<Integer> fleetGroupIds = new HashSet<>();
        if (fleetGroupsArray != null) {
            for (SiteFleet siteFleet : fleetGroupsArray) {
                if (siteFleet.getFleetGroupIds() != null) {
                    fleetGroupIds.addAll(siteFleet.getFleetGroupIds());
                }
            }
        }

        BigDecimal sessionId = sessionDAO.createNewSession(user, perCarOrder, includeFleets, includeSystems,
                includeSpecials, includeObsoletes, includeOverstocks,includeSupersede, includeKeylinesOrders, includeKeylinesReturns,
                includeLessThanStdPkg,includeWeekSupplyOption,weekSupplyOptionName,  useInvestmentCollections, provideStoreDepth, includeSoldNotStocked, includeNewNumbers, orderAllSkus, returnAllSKUs, dollarLimit, comment, siteGroupObj, sitesArray,
                productGroupsArray, groupCodeArray, fleetGroupIds.<Integer>toArray(new Integer[0]), customProductGroup,customGroupCodeProductGroupObj,isGroupCode, savedGroup,
                userAccessSites, skuArray, productLineIdArray,allProductLines, siteProductLines , includeOrders, includeReturns, expirationDate, includeDaysCount, perCarMinMaxValue
                ,salesHistoryValue,displayQty, sessionType, includeHubSpokeOrderOption, includeHubSpokeReturnOption, applicationPartsOnly,leadTime);

        if (sessionId == null) {
            return new ActionResultItem<>("cannotCreateSession");
        } else {
            return new ActionResultItem<>(sessionId);
        }
    }

    /*
     * (non-Javadoc)
     *
     * @see
     * com.napa.pulse.service.interfaces.SessionService#finalizeSession(java.lang.
     * Integer, java.lang.Integer, com.napa.pulse.entity.pulseui.Transmission[])
     */
    @Override
    public ActionResult finalizeSession(Integer userId, Integer sessionId, Transmission[] transmissionArray) {

        if (sessionDAO.isMinMax(sessionId)) {
            sessionDAO.finalizeMinMaxSession(userId, sessionId, transmissionArray,0,false);
            informaticaServiceClient.startMinMaxWorkflowFinalize();
        } else {
            if (sessionDAO.isACO(sessionId)) {
                sessionDAO.finalizeACOSession(userId, sessionId, transmissionArray);
            }else {
                sessionDAO.finalizeSession(userId, sessionId, transmissionArray);
            }
            informaticaServiceClient.startWorkflowFinalize();
        }

        // Sends Informatica an event that a session has been finalized
        return new ActionResult(true);
    }

    /*
     * (non-Javadoc)
     *
     * @see
     * com.napa.pulse.service.interfaces.SessionService#getSessionTransmissions(java
     * .lang.Integer, java.lang.Integer)
     */
    @Override
    public ActionResultItem<List<Transmission>> getSessionTransmissionsMinMax(User user, Integer sessionId) {
        return new ActionResultItem<>(sessionDAO.getSessionTransmissionsMinMax(user, sessionId));
    }

    /*
     * (non-Javadoc)
     *
     * @see
     * com.napa.pulse.service.interfaces.SessionService#getSessionTransmissions(java
     * .lang.Integer, java.lang.Integer)
     */
    @Override
    public ActionResultItem<List<Transmission>> getSessionTransmissions(User user, Integer sessionId) {
        return new ActionResultItem<>(sessionDAO.getSessionTransmissions(user, sessionId));
    }

    /*
     * (non-Javadoc)
     *
     * @see
     * com.napa.pulse.service.interfaces.SessionService#resendTransmission(java.lang
     * .String, java.lang.Integer)
     */
    @Override
    public ActionResult resendTransmission(String orderReturn, int transmissionId) {
        if (sessionDAO.resendTransmission(orderReturn, transmissionId).isSuccess()) {
            // Sends Informatica an event that a session has been finalized
            informaticaServiceClient.startWorkflowFinalize();
            return new ActionResult(true);
        } else {
            return new ActionResult(false);
        }
    }

    /*
     * (non-Javadoc)
     *
     * @see com.napa.pulse.service.interfaces.SessionService#
     * getSessionSitesHasOrdersOrReturns(java.lang.Integer, java.lang.Integer)
     */
    @Override
    public ActionResultItem<List<Map<String, Object>>> getSessionSitesWithOrderReturn(Integer userId, Integer sessionId) {
        if (sessionDAO.isACO(sessionId)) {
            return new ActionResultItem<>(sessionDAO.getACOSessionSitesWithOrderReturn(userId, sessionId));
        }
        if (sessionDAO.isMinMax(sessionId)){
            return new ActionResultItem<>(sessionDAO.getMinMaxSessionSitesWithOrderReturn(userId, sessionId));
        }
        else {
            return new ActionResultItem<>(sessionDAO.getSessionSitesWithOrderReturn(userId, sessionId));
        }
    }

    /*
     * (non-Javadoc)
     *
     * @see
     * com.napa.pulse.service.interfaces.SessionService#updateSessionTransmissions(
     * java.lang.Integer, java.lang.Integer,
     * com.napa.pulse.entity.pulseui.Transmission[])
     */
    @Override
    public ActionResult updateSessionTransmissions(Integer userId, Integer sessionId, Transmission[] transmissions) {
        sessionDAO.updateSessionTransmissions(userId, sessionId, transmissions);
        return new ActionResult(true);
    }

    /*
     * (non-Javadoc)
     *
     * @see com.napa.pulse.service.interfaces.SessionService#getSessionSites(int)
     */
    @Override
    @CacheResult(cacheName = PulseConstants.CACHE_SESSION_SITES)
    public List<Map<String, Object>> getSessionSites(int sessionId) {
        return sessionDAO.getSessionSites(sessionId);
    }
    @Override
    public ActionResultItem<Map<Integer, HierarchyItem>> getHierarchyTreeForSession(int sessionId, int siteId,
                                                                                    User user) {
        Map<Integer, HierarchyItem> treeMap = sessionDAO.getHierarchyTreeForSession(sessionId, siteId, user);

        if (treeMap == null) {
            return new ActionResultItem<>(
                    "Could not retrieve hierarchy tree for sessionId " + sessionId);
        } else {
            return new ActionResultItem<>(treeMap);
        }
    }

    @Override
    public ActionResult updateSessionTransmissionStatusId(Integer transmissionId, String type, String newStatus) {
        return sessionDAO.updateSessionTransmissionStatusId(transmissionId, type, newStatus);
    }

    @Override
    public List<SessionDetailsDTO> getSessionDetails(User user, Integer sessionId) {
        return sessionDAO.getSessionDetails(user, sessionId);
    }

    /*
     * (non-Javadoc)
     *
     * @see
     * com.napa.pulse.service.interfaces.SessionService#getSessionTypesAndCount()
     */
    @Override
    public Map<String, Integer> getSessionTypesAndCount(User user, String userAccessSites) {
        return sessionDAO.getSessionTypesAndCount(user, userAccessSites);
    }

    @Override
    public List<Map<String, Object>> getCreatedUserList() {
        return sessionDAO.getCreatedUserList();
    }

    /*
     * (non-Javadoc)
     *
     * @see com.napa.pulse.service.interfaces.SessionService#getSessionStatusList()
     */
    @Override
    public List<Map<String, Object>> getSessionStatusList(User user) {
        return sessionDAO.getSessionStatusList(user);
    }

    /*
     * (non-Javadoc)
     *
     * @see com.napa.pulse.service.interfaces.SessionService#getSessionSiteList()
     */
    @Override
    public List<Map<String, Object>> getSessionSiteList(User user, String userAccessSites) {
        return sessionDAO.getSessionSiteList(user, userAccessSites);
    }

    /*
     * (non-Javadoc)
     *
     * @see
     * com.napa.pulse.service.interfaces.SessionService#getSessionSiteGroupList(java
     * .lang.Integer)
     */
    @Override
    public List<Map<String, Object>> getSessionSiteGroupList(Integer userId) {
        return sessionDAO.getSessionSiteGroupList(userId);
    }

    /*
     * (non-Javadoc)
     *
     * @see
     * com.napa.pulse.service.interfaces.SessionService#getSessionDashboardData(int,
     * int, int, java.lang.String, java.lang.String, boolean, boolean,
     * java.lang.Boolean, java.lang.Integer, java.lang.Integer)
     */
    public void getSessionDashboardData(Integer sessionId, Integer pageNumber, Integer numberOfRecordsPerPage,
                                        String sortBy, String sortingOrder, Boolean isReturns, Boolean isOrders,
                                        Boolean isInSession, Integer siteId, Integer level, Integer hierarchyId,
                                        String exportType, Boolean isUnReviewed, Boolean aggressiveLeft,
                                        Boolean aggressiveRight, Boolean dnsCount, Boolean sjCount, Boolean highSkuEdit,
                                        Integer highSkuEditHierarchyId, Boolean isDeclineOrder, Boolean isDeclineReturn,
                                        Integer hierarchyLevel, HttpServletResponse response, User user) throws Exception {

        sessionDAO.getSessionDashboardData(sessionId, pageNumber, numberOfRecordsPerPage, sortBy, sortingOrder,
                isReturns, isOrders, isInSession, siteId, level, hierarchyId, exportType, isUnReviewed, aggressiveLeft,
                aggressiveRight, dnsCount, sjCount, highSkuEdit, highSkuEditHierarchyId, isDeclineOrder,
                isDeclineReturn, hierarchyLevel, response, user);
    }

    /*
     * (non-Javadoc)
     *
     * @see
     * com.napa.pulse.service.interfaces.SessionService#getMinMaxSessionDashboardData(int,String,String,int,int,
     * java.lang.String)
     */
    public void getMinMaxSessionDashboardData(Integer sessionId, String minMaxSiteIds,String minMaxLineAbbr, String minMaxGroupCode, Boolean minMaxisReviewed,String isMinMaxSkus,String sortBy, String sortingOrder, Integer pageNumber, Integer numberOfRecordsPerPage, String exportType,
                                              HttpServletResponse response, User user) throws Exception {

        sessionDAO.getMinMaxSessionDashboardData(sessionId, minMaxSiteIds,minMaxLineAbbr, minMaxGroupCode,minMaxisReviewed, isMinMaxSkus,sortBy, sortingOrder, pageNumber, numberOfRecordsPerPage, exportType, response, user);
    }

    public ActionResultItem<List<Map<String, Object>>> updateSkuDashboardTableSetReviewedList(Integer sessionId,
                                                                                              DashboardList[] dashboardListArr) {
        return sessionDAO.updateSkuDashboardTableSetReviewedList(sessionId, dashboardListArr);
    }
    public ActionResultItem<List<Map<String, Object>>> updateSkuDashboardTableSetReviewedFilter(SKUDashboardTableData skuDashboardTableData) {
        return sessionDAO.updateSkuDashboardTableSetReviewedFilter(skuDashboardTableData);
    }



    @Override
    public int getSessionTypeCount(String sessionType, User user) {
        return sessionDAO.getSessionTypeCount(sessionType, user);
    }

    /*
     * (non-Javadoc)
     *
     * @see
     * com.napa.pulse.service.interfaces.SessionService#getPendingTransmissions()
     */
    @Override
    public int getPendingTransmissions(String responsibleUserAccessSites) {
        return sessionDAO.getPendingTransmissions(responsibleUserAccessSites);
    }

    /*
     * (non-Javadoc)
     *
     * @see com.napa.pulse.service.interfaces.SessionService#getActiveUserCount()
     */
    @Override
    public int getActiveUserCount() {
        return sessionDAO.getActiveUserCount();
    }

    /*
     * (non-Javadoc)
     *
     * @see com.napa.pulse.service.interfaces.SessionService#getOverdueReturn()
     */
    @Override
    public int getOverdueReturn(String responsibleUserAccessSites) {
        return sessionDAO.getOverdueReturn(responsibleUserAccessSites);
    }

    /*
     * (non-Javadoc)
     *
     * @see com.napa.pulse.service.interfaces.SessionService#getOverdueReturn()
     */
    @Override
    public int getPendingApprovals(User user) {
        return sessionDAO.getPendingApprovals(user);
    }

    /*
     * (non-Javadoc)
     *
     * @see
     * com.napa.pulse.service.interfaces.SessionService#getSessionOrderReturnTotals(
     * int)
     */
    @Override
    public List<Map<String, Object>> getSessionOrderReturnTotals(int sessionId) {
        if (sessionDAO.isACO(sessionId)) {
            return sessionDAO.getACOSessionOrderReturnTotals(sessionId);
        }
        if (sessionDAO.isMinMax(sessionId)){
            return sessionDAO.getMinMaxSessionTotals(sessionId);
        } else {
            return sessionDAO.getSessionOrderReturnTotals(sessionId);
        }
    }

    /*
     * (non-Javadoc)
     *
     * @see com.napa.pulse.service.interfaces.SessionService#
     * getSessionOrderReturnTotalsDetails(int)
     */
    @Override
    public List<Map<String, Object>> getSessionOrderReturnTotalsDetails(int sessionId) {
        if (sessionDAO.isACO(sessionId)) {
            return sessionDAO.getACOSessionOrderReturnTotals(sessionId);
        }
        if (sessionDAO.isMinMax(sessionId)) {
            return sessionDAO.getMinMaxSessionOrderReturnTotals(sessionId, 0, false);
        }
        else {
            return sessionDAO.getSessionOrderReturnTotalsDetails(sessionId);
        }
    }

    /*
     * (non-Javadoc)
     *
     * @see
     * com.napa.pulse.service.interfaces.SessionService#saveMinMax()
     */
    @Override
    public ActionResultItem<List<Map<String, Object>>> saveMinMax(User user,
                                                                  Integer sessionId, Integer siteId, String partNumber,
                                                                  Integer minQty, Integer maxQty, String fieldAbbr) throws PulseException {
        return sessionDAO.saveMinMax(user, sessionId, siteId, partNumber, minQty, maxQty,fieldAbbr);
    }

    /*
     * (non-Javadoc)
     *
     * @see
     * com.napa.pulse.service.interfaces.SessionService#getRecommendationChart(int)
     */
    @Override
    public List<Map<String, Object>> getRecommendationChart(int sessionId, boolean isOrders, boolean isReturns,
                                                            Boolean isInSession, Integer siteId, Integer hierarchyId,
                                                            Integer hierarchyLevel) {
        return sessionDAO.getRecommendationChart(sessionId, isOrders, isReturns, isInSession, siteId, hierarchyId,
                hierarchyLevel);
    }

    /*
     * (non-Javadoc)
     *
     * @see
     * com.napa.pulse.service.interfaces.SessionService#getHierarchicalNames(java.
     * lang.Integer)
     */
    @Override
    public List<Map<String, Object>> getHierarchicalNames(Integer sessionId, User user) {
        return sessionDAO.getHierarchicalNames(sessionId, user);
    }

    /*
     * (non-Javadoc)
     *
     * @see
     * com.napa.pulse.service.interfaces.SessionService#getHierarchicalNames(java.
     * lang.Integer, java.lang.Integer)
     */
    @Override
    public List<Map<String, Object>> getHierarchicalNames(Integer sessionId, Integer hierarchyId, User user) {
        return sessionDAO.getHierarchicalNames(sessionId, hierarchyId, user);
    }

    /*
     * (non-Javadoc)
     *
     * @see
     * com.napa.pulse.service.interfaces.SessionService#getSessionDashboardCnt(int,
     * boolean, boolean, java.lang.Boolean, java.lang.Integer, java.lang.Integer)
     */
    @Override
    public Integer getSessionDashboardCnt(int sessionId, boolean isReturns, boolean isOrders, Boolean isInSession,
                                          Integer siteId, Integer level, Integer hierarchyId, Boolean isUnreviewed,
                                          Boolean aggressiveLeft, Boolean aggressiveRight, Boolean dnsCount, Boolean sjCount,
                                          Boolean highSkuEdit, Integer highSkuEditHierarchyId, Boolean isDeclineOrder,
                                          Boolean isDeclineReturn, Integer hierarchyLevel) {
        return sessionDAO.getSessionDashboardCnt(sessionId, isReturns, isOrders, isInSession, siteId, level,
                hierarchyId, isUnreviewed, aggressiveLeft, aggressiveRight, dnsCount, sjCount, highSkuEdit,
                highSkuEditHierarchyId, isDeclineOrder, isDeclineReturn, hierarchyLevel);
    }

    @Override
    public Integer getMinMaxSessionDashboardCnt(int sessionId, String minMaxSiteIds, String minMaxLineAbbr, String minMaxGroupCode, Boolean minMaxisReviewed,String isMinMaxSkus) {
        return sessionDAO.getMinMaxSessionDashboardCnt(sessionId, minMaxSiteIds, minMaxLineAbbr, minMaxGroupCode, minMaxisReviewed,isMinMaxSkus);
    }

    /*
     * (non-Javadoc)
     *
     * @see
     * com.napa.pulse.service.interfaces.SessionService#getInventoryHistory(java.
     * lang.Integer, java.lang.Integer)
     */
    @Override
    public List<Map<String, Object>> getInventoryHistory(Integer siteId, Integer hierarchyId) {
        return sessionDAO.getInventoryHistory(siteId, hierarchyId);
    }

    @Override
    public List<Map<String, Object>> getInventoryHistory(int sessionId, boolean isOrders, boolean isReturns,
                                                         Boolean isInSession, Integer siteId, Integer hierarchyId) {
        return sessionDAO.getInventoryHistory(sessionId, isOrders, isReturns, isInSession, siteId, hierarchyId);
    }

    /*
     * (non-Javadoc)
     *
     * @see
     * com.napa.pulse.service.interfaces.SessionService#getSessionSiteParameters(
     * java.lang.Integer, java.lang.Integer, java.lang.Integer)
     */
    @Override
    public List<SessionSiteParameterDTO> getSessionSiteParameters(Integer sessionId, Integer siteId, Integer parentId) {
        return sessionDAO.getSessionSiteParameters(sessionId, siteId, parentId);
    }

    /*
     * (non-Javadoc)
     *
     * @see
     * com.napa.pulse.service.interfaces.SessionService#getSessionSiteParameters(
     * java.lang.Integer, java.lang.Integer, java.util.List)
     */
    @Override
    public List<SessionSiteParameterDTO> getSessionSiteParameters(Integer sessionId, Integer siteId,
                                                                  Integer[] nodeIds) {
        return sessionDAO.getSessionSiteParameters(sessionId, siteId, nodeIds);
    }

    @Override
    public String getSessionState(Integer sessionId, User user) {
        return sessionDAO.getSessionState(sessionId, user);
    }

    @Override
    public ActionResult deleteSession(int sessionId, int userId) {
        int sessionStatus = sessionDAO.getSessionStatus(sessionId);
        if (sessionStatus == 2 || sessionStatus == 4) {
            LOGGER.info("Delete session| Marked sessionId " + sessionId + " as expired; userId " + userId);
            sessionDAO.markSessionStatusExpired(sessionId);
        } else {
            LOGGER.info("Delete session| Marked sessionId " + sessionId + " as deleted; userId " + userId);
            sessionDAO.markSessionStatusDeleted(sessionId);
            sessionDAO.deleteSession(sessionId, userId);
        }

        boolean isAco = sessionDAO.isACO(sessionId);
        for (Integer siteId : sessionDAO.getSitesFromSession(sessionId)) {
            sessionDAO.insertDeletedSessionLog(sessionId, siteId, userId);

            if (isAco) {
                for (HierarchyNode node : acoDAO.getAcoHierarchiesFromSession(sessionId)) {
                    acoDAO.deleteAcoSiteHierarchy(siteId, node.getNodeId());
                }
            }
        }

        return new ActionResult(true);
    }

    @Override
    public boolean validateUserSessionAccess(Integer sessionId, Integer userId, String userAccessSites) {
        return sessionDAO.validateUserSessionAccess(sessionId, userId, userAccessSites);
    }

    @Override
    public boolean checkEmptySiteGroup(Integer siteGroupObj, String userAccessSites) {
        return sessionDAO.checkEmptySiteGroup(siteGroupObj, userAccessSites);
    }

    @Override
    public List<SessionPreferencesDTO> sessionReviewPreferenceSettings(int sessionId) {
        return sessionDAO.sessionReviewPreferenceSettings(sessionId);
    }

    @Override
    public void updateSessionComment(int sessionId, String comment, String expirationDate) throws Exception {
        sessionDAO.updateSessionComment(sessionId, comment, expirationDate);
    }

    @Override
    public ActionResultItem<Map<Integer, HierarchyItem>> getSelectedProductTree(Integer sessionId,
                                                                                Integer productGroupId, User user) {
        return new ActionResultItem<>(sessionDAO.getSelectedProductTree(sessionId, productGroupId, user));
    }

    @Override
    public ActionResultItem<Map<String, List<GroupCodes>>> getSelectedGroupCodes(Integer sessionId,
                                                                                Integer productGroupId, User user) {
        return new ActionResultItem<>(sessionDAO.getSelectedGroupCodes(sessionId, productGroupId, user));
    }

    @Override
    public List<Map<String, Object>> getProductGroupsForSession(Integer sessionId) {
        return sessionDAO.getProductGroupsForSession(sessionId);
    }

    @Override
    public List<Map<String, Object>> getGroupCodesForSession(Integer sessionId) {
        return sessionDAO.getGroupCodesForSession(sessionId);
    }

    @Override
    public List<BigDecimal> getFleetGroupsForSession(Integer sessionId) {
        return sessionDAO.getFleetGroupsForSession(sessionId);
    }

    @Override
    public Object[] validateSKUs(SKUValidationDTO[] skusArray,Integer id,Boolean isCustomSelection) throws Exception {
        return sessionDAO.validateSKUs(skusArray,id,isCustomSelection);
    }

    @Override
    public List<Map<String, Object>> getCustomSkuSessionProducts(int sessionId) {
        return sessionDAO.getCustomSkuSessionProducts(sessionId);
    }

    @Override
    public Map<String,List<Map<String, Object>>> getMinMaxSessionProducts(Integer[] siteId){
        return sessionDAO.getMinMaxSessionProducts(siteId);
    }

    @Override
    public List<Map<String, Object>> getMinMaxSessionSelectedProducts(int sessionId,Integer siteId){
        return sessionDAO.getMinMaxSessionSelectedProducts(sessionId,siteId);
    }

    @Override
    public List<Map<String, Object>> getDropdownSites( List<Site> accessSites){
        return sessionDAO.getDropdownSites( accessSites);
    }

    @Override
    public String getMinMaxSessionAdditionalSettings(int sessionId){
        return sessionDAO.getMinMaxSessionAdditionalSettings(sessionId);
    }

    @Override
    public List<Map<String, Object>> getMinMaxSessionUnselectedProducts(int sessionId, Integer siteId){
        return sessionDAO.getMinMaxSessionUnselectedProducts(sessionId,siteId);
    }

    @Override
    public List<Map<String, Object>> getExecutiveSummaryData(int sessionId) {
        return sessionDAO.getExecutiveSummaryData(sessionId);
    }

    @Override
    public List<Map<String, Object>> getCubicFeet(int sessionId) {
        return sessionDAO.getCubicFeet(sessionId);
    }

    public ActionResult requestFinalizeSession(int sessionId, RequestDatesDTO[] requestDatesArr, String messageText,
                                               User user) {
        return sessionDAO.requestFinalizeSession(sessionId, requestDatesArr, messageText, user);
    }

    @Override
    public ActionResult rejectFinalizeSession(int sessionId, String reasonText, int userId) {
        return sessionDAO.rejectFinalizeSession(sessionId, reasonText, userId);
    }

    @Override
    public SessionModificationInfoDTO wasSessionModified(int sessionId) {
        return sessionDAO.wasSessionModified(sessionId);
    }

    @Override
    public void updateSession(int sessionId) throws Exception {
        sessionDAO.updateSession(sessionId);
    }

    @Override
    public List<SessionTransmissionStatus> getSessionTransmissionStatus(Integer sessionId) {
        return sessionDAO.getSessionTransmissionStatus(sessionId);
    }

    @Override
    public List<FailedTransmission> getFailedTransmissions(User user) {
        return sessionDAO.getFailedTransmissions(user);
    }

    @Override
    public List<Integer> getExpiringSessions(User user) {
        return sessionDAO.getExpiringSessions(user);
    }

    @Override
    public ActionResultItem<BigDecimal> recreateSession(User user, Integer sessionId, String userAccessSites)
            throws Exception {
        return new ActionResultItem<>(sessionDAO.recreateSession(user, sessionId, userAccessSites));
    }

    @Override
    public ActionResult declineOrderReturns(User user, Integer sessionId, Integer siteId, Integer hierarchyId,
                                            Boolean declineOrder, Boolean declineReturn) throws PulseException {
        return sessionDAO.declineOrderReturns(user, sessionId, siteId, hierarchyId, declineOrder, declineReturn);
    }

    @Override
    public boolean revertDeclineOrderReturns(int sessionId) {
        return sessionDAO.revertDeclineOrderReturns(sessionId);
    }

    @Override
    public ActionResult createDeferredSessionImmediately(int sessionId) {
        sessionDAO.createDeferredSessionImmediately(sessionId);
        return new ActionResult(true);
    }

    @Override
    public SessionLimit getSessionlimits(User user) {
        return sessionDAO.getSessionlimits(user);
    }

    @Override
    public String getEasyLink(String key, String type) {
        return sessionDAO.getEasyLink(key, type);
    }

    @Override
    public List<SiteLimit> getSitelimits(Integer siteGroupObj, Integer[] sitesArray) {
        if (siteGroupObj != null) {
            sitesArray = sessionDAO.getGroupSites(siteGroupObj);
        }

        return sessionDAO.getSiteLimits(sitesArray);
    }

    @Override
    public ActionResult resendTransmissionMinmax(Integer transmissionId) {
        if (sessionDAO.resendTransmissionMinmax(transmissionId).isSuccess()) {
            // Sends Informatica an event that a session has been finalized
            informaticaServiceClient.startMinMaxWorkflowFinalize();
            return new ActionResult(true);
        } else {
            return new ActionResult(false);
        }
    }

    public ActionResult getMinMaxSafetyStock(){
        return sessionDAO.getMinMaxSafetyStock();
    }

    public ActionResult getMinMaxOrderCycle(){
        return sessionDAO.getMinMaxOrderCycle();
    }

    public ActionResult getMinMaxLeadTime(){
        return sessionDAO.getMinMaxLeadTime();
    }

    @Override
    public Boolean pulseDownTime ( ) {
        return sessionDAO.pulseDownTime();
    }

}