Exporter.h

#pragma once

#include "AppState.h"
#include <stdio.h>
#include <lame.h>
#include <juce_audio_basics/juce_audio_basics.h>

class Exporter 
{
public:
    enum class ExportFormat {
        WAV,
        MP3,
        FLAC,
        OGG
    };

    Exporter() {
        // Initialize encoders if needed
    }

    // Main export function that delegates to specific format exporters
    bool exportBuffer(const float* leftChannel, const float* rightChannel, int bufferSize, 
                     double sampleRate, const juce::String& applicationName, ExportFormat format, juce::String& recordingsLocation) {
        
        // Create a unique filename based on current time
        auto now = juce::Time::getCurrentTime();
        auto formattedDate = now.formatted("%Y-%m-%d_%H-%M-%S");
        juce::String formatExtension = getFormatExtension(format);
        
        juce::String filename = formattedDate;
        if (applicationName.isNotEmpty())
            filename += "_" + applicationName;
            
        filename += formatExtension;
        
        juce::File directory;
        
        if (recordingsLocation.isEmpty()) {
            directory = juce::File::getSpecialLocation(juce::File::userDesktopDirectory);
        } else {
            directory = juce::File(recordingsLocation);
            
            // Make sure the directory exists and is writable
            if (!directory.exists() || !directory.isDirectory() || !directory.hasWriteAccess()) {
                std::cout << "Warning: Recordings location is not accessible, falling back to desktop" << std::endl;
                directory = juce::File::getSpecialLocation(juce::File::userDesktopDirectory);
            }
        }
        
        auto file = directory.getChildFile(filename);
        
        std::cout << "Exporting to: " << file.getFullPathName() << std::endl;
        
        // Create AudioBuffer from the input channels
        juce::AudioBuffer<float> buffer;
        buffer.setSize(2, bufferSize, false, true, true);
        
        for (int i = 0; i < bufferSize; i++) {
            buffer.setSample(0, i, leftChannel[i]);
            buffer.setSample(1, i, rightChannel[i]);
        }
        
        bool success = false;
        
        switch (format) {
            case ExportFormat::WAV:
                success = exportAsWav(buffer, file, sampleRate);
                break;
                
            case ExportFormat::FLAC:
                success = exportAsFlac(buffer, file, sampleRate);
                break;
                
            case ExportFormat::MP3:
                success = exportAsMp3(buffer, file, sampleRate);
                break;
                
            case ExportFormat::OGG:
                success = exportAsOgg(buffer, file, sampleRate);
                break;
        }
        
        if (success) {
            // Initiate drag-and-drop of the exported file
            return juce::DragAndDropContainer::performExternalDragDropOfFiles({file.getFullPathName()}, false, nullptr);
        }
        
        // Clean up failed export
        if (file.existsAsFile()) {
            file.deleteFile();
        }
        
        return false;
    }

private:    
    juce::String getFormatExtension(ExportFormat format) {
        switch (format) {
            case ExportFormat::WAV: return ".wav";
            case ExportFormat::FLAC: return ".flac";
            case ExportFormat::MP3: return ".mp3";
            case ExportFormat::OGG: return ".ogg";
            default: return ".wav";
        }
    }

    bool exportAsWav(juce::AudioBuffer<float>& buffer, juce::File& file, double sampleRate) {
        juce::WavAudioFormat wavFormat;
        juce::FileOutputStream* fileStream = new juce::FileOutputStream(file);
        
        if (fileStream->failedToOpen()) {
            delete fileStream;
            return false;
        }

        fileStream->setPosition(0);
        fileStream->truncate();
        
        std::unique_ptr<juce::AudioFormatWriter> writer(wavFormat.createWriterFor(
            fileStream, sampleRate, buffer.getNumChannels(), 32, {}, 0));
            
        if (writer == nullptr) {
            delete fileStream;
            return false;
        }
        
        writer->writeFromAudioSampleBuffer(buffer, 0, buffer.getNumSamples());
        fileStream->flush();
        
        return true;
    }
    
    bool exportAsFlac(juce::AudioBuffer<float>& buffer, juce::File& file, double sampleRate) {
        juce::FlacAudioFormat flacFormat;
        juce::FileOutputStream* fileStream = new juce::FileOutputStream(file);
        
        if (fileStream->failedToOpen()) {
            delete fileStream;
            return false;
        }

        fileStream->setPosition(0);
        fileStream->truncate();
        
        std::unique_ptr<juce::AudioFormatWriter> writer(flacFormat.createWriterFor(
            fileStream, sampleRate, buffer.getNumChannels(), 16, {}, 0));
            
        if (writer == nullptr) {
            delete fileStream;
            return false;
        }
        
        writer->writeFromAudioSampleBuffer(buffer, 0, buffer.getNumSamples());
        fileStream->flush();
        
        return true;
    }
    
    bool exportAsMp3(juce::AudioBuffer<float>& buffer, juce::File& file, double sampleRate) {
        // parameters
        int quality = 2; /* 2=high  5 = medium  7=low */ 
        int mode = 1; //   mode = 0,1,2,3 = stereo, jstereo, dual channel (not supported), mono

        lame_global_flags *lameFlags = lame_init();

        lame_set_num_channels(lameFlags, buffer.getNumChannels());
        lame_set_in_samplerate(lameFlags, sampleRate);
        lame_set_brate(lameFlags, 320);
        lame_set_mode(lameFlags, (MPEG_mode)mode);
        lame_set_quality(lameFlags, quality);

        auto ret_code = lame_init_params(lameFlags);

        if (ret_code < 0) {
            printf("Error (ret_code): %d\n", ret_code);
            return false;
        }

        int mp3buf_size = 1.1 * buffer.getNumSamples() + 7200;
        unsigned char* mp3buf = new unsigned char[mp3buf_size];

        auto err = lame_encode_buffer_ieee_float(lameFlags, buffer.getReadPointer(0), buffer.getReadPointer(1), buffer.getNumSamples(), mp3buf, mp3buf_size);

        if (err < 0) {
            printf("Error (err): %d\n", err);
            return false;
        }

        lame_encode_flush(lameFlags, mp3buf, mp3buf_size);
        
        FILE* mp3 = fopen(file.getFullPathName().toRawUTF8(), "wb");

        lame_mp3_tags_fid(lameFlags, mp3);

        fwrite(mp3buf, 1, mp3buf_size, mp3);

        lame_close(lameFlags);
        fclose(mp3);

        delete[] mp3buf;

        return true;
    }
    
    bool exportAsOgg(juce::AudioBuffer<float>& buffer, juce::File& file, double sampleRate) {
        juce::OggVorbisAudioFormat oggFormat;
        juce::FileOutputStream* fileStream = new juce::FileOutputStream(file);
        
        if (fileStream->failedToOpen()) {
            delete fileStream;
            return false;
        }

        fileStream->setPosition(0);
        fileStream->truncate();
        
        std::unique_ptr<juce::AudioFormatWriter> writer(oggFormat.createWriterFor(
            fileStream, sampleRate, buffer.getNumChannels(), 0, {}, 0));
            
        if (writer == nullptr) {
            delete fileStream;
            return false;
        }
        
        writer->writeFromAudioSampleBuffer(buffer, 0, buffer.getNumSamples());
        fileStream->flush();
        
        return true;
    }
};