source: gs3-extensions/atea-nlp-tools/trunk/src/koreromaori-proxy/src/main/java/org/atea/nlptools/koreromaoriinterface/services/ReoTuhituhiApiService.java@ 35240

package org.atea.nlptools.koreromaoriinterface.services;

import java.io.InputStream;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;

import com.google.gson.Gson;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.atea.nlptools.koreromaoriinterface.models.TranscriptionResult;

/**
 * Functions to interact with the Reo Tuhituhi API.
 */
public class ReoTuhituhiApiService
{
    private static final Logger logger = LogManager.getLogger(ReoTuhituhiApiService.class);

    private final ExecutorService threadPool;
    private final Gson jsonSerialiser;
    private final String apiEndpoint;
    private final String apiKey;

    public ReoTuhituhiApiService(Gson jsonSerialiser, String apiEndpoint, String apiKey)
    {
        this.jsonSerialiser = jsonSerialiser;
        this.apiEndpoint = apiEndpoint;
        this.apiKey = apiKey;

        threadPool = java.util.concurrent.Executors.newFixedThreadPool(3);
    }

    /**
     * Queries the Reo Tuhituhi API to transcribe the given audio files.
     * 
     * @param audioFileStreams The audio files to retrieve a transcription for.
     * @return A list of {@link TranscriptionResult} objects.
     * @throws Exception
     */
    public List<TranscriptionResult> GetTranscriptions(Iterable<InputStream> audioFileStreams)
        throws Exception
    {
        Queue<Future<TranscriptionResult>> apiCalls = new LinkedList<Future<TranscriptionResult>>();

        // Queue each transcription request up asynchronously
        for (InputStream audioStream : audioFileStreams)
        {
            //Callable<TranscriptionResult> transcriptionTask = getTranscriptionCallable(audioStream);
            //apiCalls.add(threadPool.submit(transcriptionTask));
            //logger.debug("Adding transcription task to thread pool.");
        }

        List<TranscriptionResult> apiResults = new ArrayList<TranscriptionResult>(apiCalls.size());
        
        for (InputStream audioStream : audioFileStreams)
        {
            apiResults.add(getTranscription(audioStream));
            logger.debug("API call has completed.");
        }

        // Wait on the result of each call
        // TODO: Implement proper timeout here
        // while (!apiCalls.isEmpty())
        // {
        //     apiResults.add(apiCalls.remove().get());
        //     logger.debug("API call has completed.");
        // }

        return apiResults;
    }

    private Callable<TranscriptionResult> getTranscriptionCallable(final InputStream audioStream)
    {
        return new Callable<TranscriptionResult>()
        {
            @Override
            public TranscriptionResult call() throws Exception
            {
                return getTranscription(audioStream);
            }
        };
    }

    private TranscriptionResult getTranscription(InputStream audioStream)
        throws Exception
    {
        String jsonResponse = HttpRequestService
            .post(apiEndpoint)
            .authorization("Basic " + apiKey)
            .send(audioStream)
            .body();

        logger.debug("Reo Tuhituhi API responded with a success status.");
        TranscriptionResult res = jsonSerialiser.fromJson(jsonResponse, TranscriptionResult.class);
        logger.debug("Reo Tuhituhi API response was succesfully deserialised.");
        return res;
    }
}