const speech = require('@google-cloud/speech');
const portAudio = require('naudiodon');
// const rs = fs.createReadStream('rawAudio.wav');

// Creates a client
const client = new speech.SpeechClient();

const encoding = 'LINEAR16';
const sampleRateHertz = 16000;
const languageCode = 'en-US';

const audioContainer = {
    input: '',
    buffers: []
}

const config = {
  encoding: encoding,
  sampleRateHertz: sampleRateHertz,
  languageCode: languageCode,
};

/**
 * Note that transcription is limited to 60 seconds audio.
 * Use a GCS file for audio longer than 1 minute.
 */
async function transcribeSpeech (audio) {
  const request = {
    config: config,
    audio: audio,
  };

  // Detects speech in the audio file. This creates a recognition job that you
  // can wait for now, or get its result later.
  const [operation] = await client.longRunningRecognize(request);

  // Get a Promise representation of the final result of the job
  const [response] = await operation.promise();

  const transcription = response.results
    .map(result => result.alternatives[0].transcript)
    .join('\n');
  console.log(`Transcription: ${transcription}`);
}

let record = true;

// Create an instance of AudioIO with inOptions (defaults are as below), which will return a ReadableStream
const ia = new portAudio.AudioIO({
  inOptions: {
    channelCount: 1,
    sampleFormat: 16,
    sampleRate: 16000,
    deviceId: -1,
    closeOnError: false,
  },
});
ia.setEncoding('base64');
ia.start();
ia.on('data', (chunk) => {
    if (record) {
        console.log('recording data')
        audioContainer.input += chunk;
        // audioContainer.buffers.push(Buffer.from(chunk, 'base64'));
    } else {
        if (audioContainer.input.length) audioContainer.input = "";
    }
});

const ao = new portAudio.AudioIO({
    outOptions: {
        sampleFormat: 16,
        channelCount: 1,
        sampleRate: 16000,
        deviceId: -1,
        closeOnError: false,
    }
});
ao.start();

let counter = 0;
const tests = [];

function testCallback() {
    tests.forEach(t => console.log(t))
    console.log(tests[0])
    play(tests[0])
}

function play(bufArray) {
    let i = 0;
    // format buffers into half their size to account for writable highwaterMark.
    const audio = bufSplit(bufArray);
    // call this fuction after last audio chunk has been written.
    const callback = () => {
        // TODO: clear portAudio writable buffer on write end.
        console.log('Finished writing test number %d', counter)
        if (counter === 3) {
            console.log('finished test writing!')
        }
    }
    write();
    // iterate through audio array and write buffers to portAudio writable.
    function write() {
        let ok = true;
        do {
            if (i === audio.length - 1) {
                // write last chunk.
                ao.write(audio[i], null, callback);
            } else {
                // check for backpreassure.
                ok = ao.write(audio[i], null);
            }
            i++;
        } while (i < audio.length && ok);

        if (i < audio.length) {
            // Had to stop early!
            // Write some more once it drains.
            ao.once('drain', write);
        }
    }
}

// utility function used by play func
function bufSplit(input){
    const result = [];
    input.forEach((b) => {
        // split buffer into two.
        result.push(b.slice(0, b.length / 2), b.slice(b.length / 2, b.length));
    });
    return result;
}

async function test() {
    transcribeSpeech({
        content: Buffer.from(audioContainer.input, 'base64')
    });
    tests.push(audioContainer.buffers)
    counter++;
    console.log('audio string length:', audioContainer.input.length)
    console.log('buffers written: ', audioContainer.buffers.length)
}

setTimeout(async () => {
    record = false;
    test()
}, 3000);

setTimeout(() => {
    record = true;
}, 6000)

setTimeout(async () => {
    record = false;
    test();
}, 9000);

setTimeout(() => {
    record = true;
}, 11000)

setTimeout(async () => {
    record = false;
    test();
}, 14000);

setTimeout(async () => {
    ia.quit();
    // testCallback()
    return;
}, 16000);