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

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 com.google.gson.JsonSyntaxException;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.atea.nlptools.koreromaoriinterface.exceptions.ReoTuhituhiException;
import org.atea.nlptools.koreromaoriinterface.models.AudioFilePart;
import org.atea.nlptools.koreromaoriinterface.models.TranscriptionResult;
import org.atea.nlptools.koreromaoriinterface.services.HttpRequestService.HttpRequestException;

/**
 * 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 audioFileParts The audio files to retrieve a transcription for.
     * @return A list of {@link TranscriptionResult} objects.
     * @throws HttpRequestException When the API call fails.
     * @throws JsonSyntaxException When the result cannot be parsed.
     */
    public List<AudioFilePart> getTranscriptions(Iterable<AudioFilePart> audioFileParts)
        throws HttpRequestException, JsonSyntaxException, Exception
    {
        Queue<Future<AudioFilePart>> apiCalls = new LinkedList<Future<AudioFilePart>>();

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

        List<AudioFilePart> apiResults = new ArrayList<AudioFilePart>(apiCalls.size());
        
        for (AudioFilePart part : audioFileParts)
        {
            TranscriptionResult res = getTranscription(part.dataStream);
            part.setTranscriptionResult(res);

            apiResults.add(part);
        }

        // 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;
    }

    /**
     * Calls the Reo Tuhituhi API to transcribe a wave audio file.
     * 
     * @param audioStream The wave audio stream.
     * @return A {@link TranscriptionResult} object.
     * @throws HttpRequestException Thrown when the API call fails.
     * @throws JsonSyntaxException Thrown when the result cannot be parsed.
     * @throws ReoTuhituhiException Thrown when the Reo Tuhituhi API returns an invalid response.
     */
    public TranscriptionResult getTranscription(InputStream audioStream)
        throws HttpRequestException, JsonSyntaxException, ReoTuhituhiException
    {
        HttpRequestService request = HttpRequestService
            .post(apiEndpoint)
            .authorization("Basic " + apiKey)
            .send(audioStream);

        // Check that the request returned an OK status
        if (!request.ok())
        {
            logger.error
            (
                "The Reo Tuhituhi API returned a non-OK status code {} with message {}",
                request.code(),
                request.message()
            );

            throw new ReoTuhituhiException(request.code(), request.message(), "Non-OK status code");
        }

        // Check that the content type is valid
        if (request.contentType() != "application/json")
        {
            logger.error
            (
                "The Reo Tuhituhi API returned an invalid content type {}. Provided content was {}",
                request.contentType(),
                request.body()
            );

            throw new ReoTuhituhiException(request.code(), request.message(), "Invalid content type: " + request.contentType());
        }

        TranscriptionResult res = jsonSerialiser.fromJson(request.body(), TranscriptionResult.class);

        return res;
    }

    private Callable<AudioFilePart> getTranscriptionCallable(final AudioFilePart part)
    {
        return new Callable<AudioFilePart>()
        {
            @Override
            public AudioFilePart call()
                throws Exception
            {
                TranscriptionResult res = getTranscription(part.dataStream);
                part.setTranscriptionResult(res);
                return part;
            }
        };
    }
}