Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.service;

import com.spice.profitmandi.dao.entity.cs.RbmBreakLog;

import com.spice.profitmandi.dao.repository.cs.RbmBreakLogRepository;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

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

import org.springframework.stereotype.Service;

import org.springframework.transaction.PlatformTransactionManager;

import org.springframework.transaction.TransactionStatus;

import org.springframework.transaction.support.TransactionCallbackWithoutResult;

import org.springframework.transaction.support.TransactionTemplate;

import javax.annotation.PostConstruct;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.util.ArrayList;

import java.util.List;

import java.util.Map;

import java.util.concurrent.ConcurrentHashMap;

@Service

public class AgentLiveStatusService {

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

    // In-memory map to store agent status by authId

    private final Map<Integer, AgentStatus> agentStatusMap = new ConcurrentHashMap<>();

    // Caller ID (Knowlarity SR Number) to Auth ID mapping (loaded from sip_master)

    private final Map<String, Integer> callerIdToAuthIdMap = new ConcurrentHashMap<>();

    // SR Number to Auth ID mapping (loaded from sip_master)

    private final Map<String, Integer> srNumberToAuthIdMap = new ConcurrentHashMap<>();

    // Agent name to Auth ID mapping (fallback)

    private final Map<String, Integer> agentNameToAuthIdMap = new ConcurrentHashMap<>();

    @Autowired

    private SessionFactory sessionFactory;

    @Autowired

    private RbmBreakLogRepository rbmBreakLogRepository;

    @Autowired

    private PlatformTransactionManager transactionManager;

    private TransactionTemplate transactionTemplate;

    private String lastError = null;

    private int lastQueryCount = 0;

    /**

     * Load mapping from sip_master table on startup

     * caller_id in sip_master = SR Number on Knowlarity dashboard

     * sip_master has auth_id directly

     */

    @PostConstruct

    public void loadMappingFromDatabase() {

        this.transactionTemplate = new TransactionTemplate(transactionManager);

        try {

            Session session = sessionFactory.openSession();

            // Query to get caller_id, auth_user.id, first_name from sip_master

            // Join with auth_user to get correct auth_id used by rbm_call_target page

            String sql = "SELECT sm.caller_id, au.id, sm.first_name " +

                    "FROM auth.sip_master sm " +

                    "JOIN auth.auth_user au ON sm.email_id = au.email_id " +

                    "WHERE au.id IS NOT NULL";

            List<Object[]> results = session.createNativeQuery(sql).getResultList();

            lastQueryCount = results.size();

            for (Object[] row : results) {

                String callerId = row[0] != null ? row[0].toString().trim() : "";

                int authId = row[1] != null ? ((Number) row[1]).intValue() : 0;

                String firstName = row[2] != null ? row[2].toString().trim() : "";

                if (authId > 0) {

                    // Map by caller_id if available

                    if (!callerId.isEmpty()) {

                        callerIdToAuthIdMap.put(callerId, authId);

                    }

                    // Map by first_name for name-based matching

                    if (!firstName.isEmpty()) {

                        agentNameToAuthIdMap.put(firstName.toLowerCase(), authId);

                        System.out.println("Mapping: '" + firstName + "' -> authId=" + authId + " (caller_id=" + callerId + ")");

                    }

                }

            }

            session.close();

            System.out.println("Loaded " + callerIdToAuthIdMap.size() + " caller_id -> auth_id mappings from sip_master");

            System.out.println("Loaded " + agentNameToAuthIdMap.size() + " name -> auth_id mappings");

        } catch (Exception e) {

            lastError = e.getClass().getSimpleName() + ": " + e.getMessage();

            System.err.println("Error loading sip_master mapping: " + e.getMessage());

            e.printStackTrace();

        }

    }

    public String getLastError() {

        return lastError;

    }

    public int getLastQueryCount() {

        return lastQueryCount;

    }

    /**

     * Reload mapping from database (can be called via API)

     */

    public void reloadMapping() {

        callerIdToAuthIdMap.clear();

        srNumberToAuthIdMap.clear();

        agentNameToAuthIdMap.clear();

        lastError = null;

        lastQueryCount = 0;

        loadMappingFromDatabase();

    }

    public Integer getAuthIdByCallerId(String callerId) {

        return callerIdToAuthIdMap.get(callerId);

    }

    public void setSrNumberMapping(String srNumber, int authId) {

        srNumberToAuthIdMap.put(srNumber, authId);

    }

    public void setAgentNameMapping(String agentName, int authId) {

        agentNameToAuthIdMap.put(agentName.toLowerCase(), authId);

    }

    public Integer getAuthIdBySrNumber(String srNumber) {

        return srNumberToAuthIdMap.get(srNumber);

    }

    public Integer getAuthIdByAgentName(String agentName) {

        // Try exact match

        Integer authId = agentNameToAuthIdMap.get(agentName.toLowerCase());

        if (authId != null) return authId;

        // Try partial match

        for (Map.Entry<String, Integer> entry : agentNameToAuthIdMap.entrySet()) {

            if (agentName.toLowerCase().contains(entry.getKey()) || entry.getKey().contains(agentName.toLowerCase())) {

                return entry.getValue();

            }

        }

        return null;

    }

    public Map<String, Integer> getSrNumberMapping() {

        return srNumberToAuthIdMap;

    }

    public Map<String, Integer> getAgentNameMapping() {

        return agentNameToAuthIdMap;

    }

    public Map<String, Integer> getCallerIdMapping() {

        return callerIdToAuthIdMap;

    }

    public void clearMappings() {

        srNumberToAuthIdMap.clear();

        agentNameToAuthIdMap.clear();

    }

    public void updateStatus(int authId, String srNumber, String agentName, String agentStatus, String timeInStatus, String customerNumber) {

        // Get previous status to detect change

        AgentStatus previousStatus = agentStatusMap.get(authId);

        // Check if status has changed

        if (previousStatus != null && previousStatus.getAgentStatus() != null) {

            String prevStatusStr = previousStatus.getAgentStatus();

            String newStatusStr = agentStatus != null ? agentStatus : "";

            // If status changed, save the previous status duration to RbmBreakLog

            if (!prevStatusStr.equalsIgnoreCase(newStatusStr)) {

                // Only track Available and Break statuses

                if (isTrackableStatus(prevStatusStr)) {

                    String prevTimeInStatus = previousStatus.getTimeInStatus();

                    int durationSeconds = parseTimeInStatusToSeconds(prevTimeInStatus);

                    // Calculate the START TIME when agent entered this status

                    // startTime = now - duration

                    LocalDateTime statusStartTime = LocalDateTime.now().minusSeconds(durationSeconds);

                    LOGGER.info("Status changed for {} (authId={}): '{}' -> '{}', started at: {}, duration: {} ({}s)",

                            agentName, authId, prevStatusStr, newStatusStr, statusStartTime, prevTimeInStatus, durationSeconds);

                    // Save to RbmBreakLog with START TIME

                    saveStatusDuration(authId, agentName, srNumber, prevStatusStr, prevTimeInStatus, durationSeconds, statusStartTime);

                }

            }

        }

        // Update current status

        AgentStatus status = new AgentStatus(authId, srNumber, agentName, agentStatus, timeInStatus, customerNumber);

        agentStatusMap.put(authId, status);

    }

    /**

     * Check if status should be tracked (Only Available and Break)

     */

    private boolean isTrackableStatus(String status) {

        if (status == null || status.isEmpty()) return false;

        String lower = status.toLowerCase();

        return lower.contains("available") || lower.contains("break");

    }

    /**

     * Parse timeInStatus string (e.g., "00:05:30" or "5m 30s") to seconds

     */

    private int parseTimeInStatusToSeconds(String timeInStatus) {

        if (timeInStatus == null || timeInStatus.isEmpty()) return 0;

        try {

            // Format: HH:mm:ss or H:mm:ss

            if (timeInStatus.contains(":")) {

                String[] parts = timeInStatus.split(":");

                if (parts.length == 3) {

                    int hours = Integer.parseInt(parts[0].trim());

                    int minutes = Integer.parseInt(parts[1].trim());

                    int seconds = Integer.parseInt(parts[2].trim());

                    return hours * 3600 + minutes * 60 + seconds;

                } else if (parts.length == 2) {

                    int minutes = Integer.parseInt(parts[0].trim());

                    int seconds = Integer.parseInt(parts[1].trim());

                    return minutes * 60 + seconds;

                }

            }

            // Format: "5m 30s" or "1h 5m 30s"

            int totalSeconds = 0;

            String lower = timeInStatus.toLowerCase();

            if (lower.contains("h")) {

                String hourPart = lower.split("h")[0].trim();

                totalSeconds += Integer.parseInt(hourPart.replaceAll("[^0-9]", "")) * 3600;

            }

            if (lower.contains("m")) {

                String minPart = lower.contains("h") ? lower.split("h")[1].split("m")[0] : lower.split("m")[0];

                totalSeconds += Integer.parseInt(minPart.trim().replaceAll("[^0-9]", "")) * 60;

            }

            if (lower.contains("s") && !lower.contains("h") && !lower.contains("m")) {

                totalSeconds += Integer.parseInt(lower.replaceAll("[^0-9]", ""));

            } else if (lower.contains("s")) {

                String secPart = lower.split("m")[1].split("s")[0];

                totalSeconds += Integer.parseInt(secPart.trim().replaceAll("[^0-9]", ""));

            }

            return totalSeconds;

        } catch (Exception e) {

            LOGGER.warn("Could not parse timeInStatus: {}", timeInStatus);

            return 0;

        }

    }

    /**

     * Save status duration to RbmBreakLog

     * Uses UPSERT logic: If record exists within time window, update duration; otherwise create new

     *

     * @param statusStartTime - the time when agent ENTERED this status (start time)

     */

    private void saveStatusDuration(int authId, String agentName, String srNumber, String status,

                                    String durationDisplay, int durationSeconds, LocalDateTime statusStartTime) {

        try {

            transactionTemplate.execute(new TransactionCallbackWithoutResult() {

                @Override

                protected void doInTransactionWithoutResult(TransactionStatus txStatus) {

                    LocalDate logDate = statusStartTime.toLocalDate();

                    // Check if existing record within 5 minute window

                    RbmBreakLog existing = rbmBreakLogRepository.findByAuthIdStatusAndLogTimeWindow(

                            authId, status, statusStartTime, 5);

                    if (existing != null) {

                        // Update existing record with latest duration

                        LOGGER.info("Updating existing break log id={}: agent={}, status={}, duration {}s -> {}s",

                                existing.getId(), agentName, status, existing.getDurationSeconds(), durationSeconds);

                        rbmBreakLogRepository.updateDuration(existing.getId(), durationSeconds, durationDisplay);

                    } else {

                        // Create new record

                        LOGGER.info("Creating new break log: agent={}, status={}, startTime={}, duration={}s ({})",

                                agentName, status, statusStartTime, durationSeconds, durationDisplay);

                        RbmBreakLog breakLog = new RbmBreakLog(

                                authId,

                                agentName,

                                srNumber,

                                status,

                                statusStartTime,

                                durationSeconds,

                                durationDisplay,

                                logDate

                        );

                        rbmBreakLogRepository.persist(breakLog);

                    }

                }

            });

        } catch (Exception e) {

            LOGGER.error("Error saving status duration for {}: {}", agentName, e.getMessage());

        }

    }

    public AgentStatus getStatusByAuthId(int authId) {

        return agentStatusMap.get(authId);

    }

    public Map<Integer, AgentStatus> getAllStatusMap() {

        return agentStatusMap;

    }

    public List<AgentStatus> getAllStatuses() {

        return new ArrayList<>(agentStatusMap.values());

    }

    public void clearAll() {

        agentStatusMap.clear();

    }

    // Inner class to hold agent status

    public static class AgentStatus {

        private int authId;

        private String srNumber;

        private String agentName;

        private String agentStatus;

        private String timeInStatus;

        private String customerNumber;

        private LocalDateTime lastUpdated;

        public AgentStatus() {

        }

        public AgentStatus(int authId, String srNumber, String agentName, String agentStatus, String timeInStatus, String customerNumber) {

            this.authId = authId;

            this.srNumber = srNumber;

            this.agentName = agentName;

            this.agentStatus = agentStatus;

            this.timeInStatus = timeInStatus;

            this.customerNumber = customerNumber;

            this.lastUpdated = LocalDateTime.now();

        }

        public int getAuthId() {

            return authId;

        }

        public void setAuthId(int authId) {

            this.authId = authId;

        }

        public String getSrNumber() {

            return srNumber;

        }

        public void setSrNumber(String srNumber) {

            this.srNumber = srNumber;

        }

        public String getAgentName() {

            return agentName;

        }

        public void setAgentName(String agentName) {

            this.agentName = agentName;

        }

        public String getAgentStatus() {

            return agentStatus;

        }

        public void setAgentStatus(String agentStatus) {

            this.agentStatus = agentStatus;

        }

        public String getTimeInStatus() {

            return timeInStatus;

        }

        public void setTimeInStatus(String timeInStatus) {

            this.timeInStatus = timeInStatus;

        }

        public String getCustomerNumber() {

            return customerNumber;

        }

        public void setCustomerNumber(String customerNumber) {

            this.customerNumber = customerNumber;

        }

        public LocalDateTime getLastUpdated() {

            return lastUpdated;

        }

        public void setLastUpdated(LocalDateTime lastUpdated) {

            this.lastUpdated = lastUpdated;

        }

    }

}