Subversion Repositories SmartDukaan

package com.spice.profitmandi.service.lms;

import com.spice.profitmandi.dao.entity.user.LeadCall;

import com.spice.profitmandi.dao.repository.dtr.LeadCallRepository;

import com.spice.profitmandi.service.storage.ObjectStoreService;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

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

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

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

import java.util.List;

/**

 * Finds call recordings the provider has announced but we have not stored yet, and hands each to

 * {@link RecordingArchiveWorker}. Owning the audio ourselves is what makes the 24-month retention in

 * SOP §17 our promise to keep rather than the vendor's, and what keeps playback working after a

 * provider switch.

 *

 * <p>Deliberately a sweep rather than work done straight off the recording webhook: the webhook fires

 * the moment the call ends, but the provider needs a moment before the file is actually fetchable,

 * and a webhook has to ACK immediately regardless. The sweep doubles as the retry — the work list is

 * simply "rows with a recording handle and no archived document", so nothing is lost across a restart.

 *

 * <p>This class holds no {@code @Scheduled} annotation on purpose. It lives in {@code profitmandi-dao},

 * which is loaded by the fofo WAR, profitmandi-web and profitmandi-cron alike; scheduling it here

 * would run the same sweep in every one of them. The trigger belongs to whichever app owns the job.

 */

@Service

public class RecordingArchiveService {

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

    @Autowired

    private LeadCallRepository leadCallRepository;

    @Autowired

    private ObjectStoreService objectStoreService;

    @Autowired

    private LmsDialerProvider dialerProvider;

    @Autowired

    private RecordingArchiveWorker recordingArchiveWorker;

    @Value("${lms.recording.archive.enabled:true}")

    private boolean enabled;

    @Value("${lms.recording.archive.batch.size:25}")

    private int batchSize;

    /**

     * How far back to look for recordings. MUST track the provider's own retention — Vonage keeps a

     * recording for 30 days, and a shorter window here silently makes recoverable audio

     * unrecoverable after any pause in the sweep.

     */

    @Value("${lms.recording.provider.retention.days:30}")

    private int providerRetentionDays;

    /** Give up after this many failed fetches so a dead row cannot occupy a batch slot forever. */

    @Value("${lms.recording.archive.max.attempts:5}")

    private int maxAttempts;

    /**

     * Log recordings the sweep will never pick up again.

     *

     * <p>The pending query excludes rows past the provider's retention window or over the attempt

     * ceiling — necessary, or one dead row starves every batch behind it. But an exclusion that

     * happens silently is how you discover during an audit that a month of audio is missing, so the

     * dropped rows are named here.

     */

    private void reportAbandoned() {

        try {

            List<LeadCall> abandoned =

                    leadCallRepository.selectAbandonedRecordings(50, providerRetentionDays, maxAttempts);

            if (abandoned == null || abandoned.isEmpty()) {

                return;

            }

            StringBuilder ids = new StringBuilder();

            for (LeadCall call : abandoned) {

                if (ids.length() > 0) {

                    ids.append(", ");

                }

                ids.append(call.getId());

            }

            LOGGER.error("{} call recording(s) will NOT be archived — past the {}-day provider window "

                            + "or over {} failed attempts. Call ids: {}",

                    abandoned.size(), providerRetentionDays, maxAttempts, ids);

        } catch (Exception e) {

            LOGGER.warn("Could not report abandoned recordings", e);

        }

    }

    /**

     * Ask the vendor for the recording of each recently answered call and stamp the handle on the row.

     *

     * <p>Runs before {@link #sweep()} and is what makes recordings exist at all for a server-placed

     * provider: those place the call over REST and receive no recording webhook, so without this step

     * {@code recording_uuid} stays null forever and the archival sweep — which selects on that column

     * — never sees a single call.

     *

     * <p>Deliberately not done at hang-up: the vendor needs a moment to finalise the file, and a call

     * that has just ended usually is not in the recording list yet. Being a sweep makes the retry free.

     *

     * @return how many recordings were newly linked

     */

    @Transactional

    public int linkSweep() {

        if (!enabled || !dialerProvider.isConfigured()) {

            return 0;

        }

        List<LeadCall> pending = leadCallRepository.selectPendingRecordingLink(batchSize, providerRetentionDays);

        if (pending == null || pending.isEmpty()) {

            return 0;

        }

        int linked = 0;

        for (LeadCall call : pending) {

            try {

                LmsDialerProvider.RecordingRef ref = dialerProvider.findRecording(call);

                if (ref == null || ref.id == null) {

                    // Normal: not recorded, or not finalised yet. The next sweep asks again.

                    continue;

                }

                call.setRecordingUuid(ref.id);

                if (ref.durationSeconds > 0) {

                    call.setRecordingDuration(ref.durationSeconds);

                }

                leadCallRepository.persist(call);

                linked++;

                LOGGER.info("Linked recording {} to call {} (vendor call {})",

                        ref.id, call.getId(), call.getProviderCallUuid());

            } catch (Exception e) {

                // One bad row must not stop the batch — the rest still get linked.

                LOGGER.warn("Could not link a recording for call {}", call.getId(), e);

            }

        }

        return linked;

    }

    /**

     * Queue every pending recording for archival.

     *

     * @return how many were queued; 0 when disabled, unconfigured, or nothing is waiting

     */

    @Transactional

    public int sweep() {

        if (!enabled) {

            return 0;

        }

        if (!objectStoreService.isEnabled() || !dialerProvider.isConfigured()) {

            LOGGER.debug("Recording archive skipped — object store or dialer not configured");

            return 0;

        }

        List<LeadCall> pending = leadCallRepository.selectPendingRecordingArchive(batchSize, providerRetentionDays, maxAttempts);

        if (pending == null || pending.isEmpty()) {

            return 0;

        }

        LOGGER.info("Queueing {} call recording(s) for archival", pending.size());

        reportAbandoned();

        for (LeadCall call : pending) {

            // Through the injected worker, never this.archiveOne — a self-call would bypass the

            // proxy and lose both @Async and @Transactional.

            recordingArchiveWorker.archiveOne(call.getId());

        }

        return pending.size();

    }

}