#include <pipewire/pipewire.h>
#include <vector>
#include <string>
#include <iostream>
#include <cmath> // For std::sin, std::cos, etc. if needed for processing

// Forward declaration for the PipewireProcessor class
class PipewireProcessor;

/**
 * @brief Configuration options for the PipewireProcessor.
 */
struct PipewireProcessorConfig {
    std::string ClientName;
    std::string NodeName;
    pw_direction_t PortDirection; // e.g., PW_DIRECTION_INPUT, PW_DIRECTION_OUTPUT
    int SampleRate;
    int Channels;
    uint32_t BufferSize; // In frames
};

/**
 * @brief C++ class to encapsulate PipeWire audio processing.
 */
class PipewireProcessor {
public:
    PipewireProcessor();
    ~PipewireProcessor();

    bool Initialize(const PipewireProcessorConfig& config);
    void Run();
    void Stop();

private:
    // PipeWire related members
    pw_loop* MainLoop;
    pw_context* Context;
    pw_core* Core;
    pw_filter* Filter;
    PipewireProcessorConfig Config;

    // Buffers for audio data
    std::vector<float> InputBuffer;
    std::vector<float> OutputBuffer;

    // Static callback function for PipeWire process events
    static void ProcessCallback(void* userdata, struct pw_buffer* buffer);

    // Member function to handle audio processing
    void ProcessAudio(struct pw_buffer* buffer);

    // Private helper for error handling
    void HandleError(const std::string& message);
};

// --- Implementation ---

PipewireProcessor::PipewireProcessor()
    : MainLoop(nullptr), Context(nullptr), Core(nullptr), Filter(nullptr) {
    pw_init(nullptr, nullptr);
}

PipewireProcessor::~PipewireProcessor() {
    Stop(); // Ensure all PipeWire resources are released
    if (Context) {
        pw_context_destroy(Context);
    }
    if (MainLoop) {
        pw_loop_destroy(MainLoop);
    }
    pw_deinit();
}

bool PipewireProcessor::Initialize(const PipewireProcessorConfig& config) {
    Config = config;

    MainLoop = pw_loop_new(nullptr);
    if (!MainLoop) {
        HandleError("Failed to create PipeWire main loop.");
        return false;
    }

    Context = pw_context_new(MainLoop, nullptr);
    if (!Context) {
        HandleError("Failed to create PipeWire context.");
        return false;
    }

    Core = pw_context_connect(Context, nullptr, 0);
    if (!Core) {
        HandleError("Failed to connect to PipeWire core.");
        return false;
    }

    // Configure the filter
    std::string node_name = Config.NodeName;
    std::string client_name = Config.ClientName;

    const char* filter_properties_str =
        "node.name = \"" + node_name + "\"\n"
        "client.name = \"" + client_name + "\"";

    pw_properties* props = pw_properties_new_string(filter_properties_str);
    if (!props) {
        HandleError("Failed to create filter properties.");
        return false;
    }

    pw_filter_callbacks filter_cbs = {
        .version = PW_VERSION_FILTER_CALLBACKS,
        .process = ProcessCallback,
    };

    Filter = pw_filter_new(Core, PW_FILTER_FLAG_RT_PROCESS, props,
                           PW_KEY_NODE_NAME, node_name.c_str(),
                           nullptr); // Additional properties can be added here
    if (!Filter) {
        HandleError("Failed to create PipeWire filter.");
        pw_properties_free(props);
        return false;
    }

    // Bind this object instance to the userdata of the filter
    pw_filter_set_userdata(Filter, this);
    pw_filter_set_callbacks(Filter, &filter_cbs);

    // Configure ports
    pw_port_info port_info;
    port_info.direction = Config.PortDirection;
    port_info.n_buffers = 0; // Let PipeWire decide
    port_info.flags = PW_PORT_FLAG_MAP_BUFFERS;

    pw_properties* port_props = pw_properties_new(nullptr, nullptr);
    if (!port_props) {
        HandleError("Failed to create port properties.");
        return false;
    }
    pw_properties_setf(port_props, PW_KEY_MEDIA_TYPE, "Audio");
    pw_properties_setf(port_props, PW_KEY_MEDIA_SUBTYPE, "Raw");
    pw_properties_setf(port_props, PW_KEY_AUDIO_FORMAT, "F32"); // Float 32-bit
    pw_properties_setf(port_props, PW_KEY_AUDIO_RATE, "%d", Config.SampleRate);
    pw_properties_setf(port_props, PW_KEY_AUDIO_CHANNELS, "%d", Config.Channels);
    pw_properties_setf(port_props, PW_KEY_NODE_LATENCY, "%d/%d", Config.BufferSize, Config.SampleRate);


    if (pw_filter_add_port(Filter, Config.PortDirection, PW_FILTER_PORT_FLAG_MAP_BUFFERS, port_props) == nullptr) {
        HandleError("Failed to add port to filter.");
        pw_properties_free(port_props);
        return false;
    }

    InputBuffer.resize(Config.BufferSize * Config.Channels);
    OutputBuffer.resize(Config.BufferSize * Config.Channels);

    if (pw_filter_activate(Filter, PW_FILTER_FLAG_RT_PROCESS, 0, nullptr) < 0) {
        HandleError("Failed to activate filter.");
        return false;
    }

    return true;
}

void PipewireProcessor::Run() {
    if (MainLoop) {
        std::cout << "PipeWire audio loop running..." << std::endl;
        pw_loop_run(MainLoop);
    }
}

void PipewireProcessor::Stop() {
    if (Filter) {
        pw_filter_deactivate(Filter);
        pw_filter_destroy(Filter);
        Filter = nullptr;
    }
    if (Core) {
        pw_core_disconnect(Core);
        Core = nullptr;
    }
    if (MainLoop) {
        pw_loop_quit(MainLoop);
    }
}

void PipewireProcessor::ProcessCallback(void* userdata, struct pw_buffer* buffer) {
    PipewireProcessor* self = static_cast<PipewireProcessor*>(userdata);
    self->ProcessAudio(buffer);
}

void PipewireProcessor::ProcessAudio(struct pw_buffer* buffer) {
    if (!buffer || buffer->n_datas == 0) {
        std::cerr << "Warning: Received empty buffer." << std::endl;
        return;
    }

    struct pw_data* input_data = &buffer->datas[0]; // Assuming one input port
    struct pw_data* output_data = &buffer->datas[0]; // Assuming one output port (in-place processing)

    // Check if it's an output-only port or input-only port scenario
    if (Config.PortDirection == PW_DIRECTION_OUTPUT) {
        // Output-only port: write data to the output buffer
        float* out = static_cast<float*>(output_data->data);
        size_t n_frames = output_data->maxsize / (Config.Channels * sizeof(float));

        // Ensure buffer size is not exceeded
        n_frames = std::min(n_frames, static_cast<size_t>(Config.BufferSize));
        output_data->chunksize = n_frames * Config.Channels * sizeof(float);

        // Example processing: generate a sine wave
        static double phase = 0.0;
        double freq = 440.0; // Hz
        double phase_increment = (2.0 * M_PI * freq) / Config.SampleRate;

        for (size_t i = 0; i < n_frames * Config.Channels; ++i) {
            if (i % Config.Channels == 0) { // Only increment phase for the first channel of each frame
                out[i] = static_cast<float>(0.5 * std::sin(phase)); // Left channel
                if (Config.Channels > 1) {
                    out[i+1] = static_cast<float>(0.5 * std::cos(phase)); // Right channel (example)
                }
                phase += phase_increment;
                if (phase >= 2.0 * M_PI) {
                    phase -= 2.0 * M_PI;
                }
            } else if (Config.Channels > 1 && i % Config.Channels == 1) {
                // Already handled in the i % Config.Channels == 0 case if processing stereo
            } else {
                // For more than 2 channels, fill with silence or replicate
                out[i] = 0.0f;
            }
        }
    } else if (Config.PortDirection == PW_DIRECTION_INPUT) {
        // Input-only port: read data from the input buffer
        const float* in = static_cast<const float*>(input_data->data);
        size_t n_frames = input_data->chunksize / (Config.Channels * sizeof(float));

        // Process incoming audio data (e.g., print RMS, analyze, etc.)
        double sum_sq = 0.0;
        for (size_t i = 0; i < n_frames * Config.Channels; ++i) {
            sum_sq += in[i] * in[i];
        }
        // double rms = std::sqrt(sum_sq / (n_frames * Config.Channels));
        // std::cout << "RMS: " << rms << std::endl;
    } else {
        // Bi-directional port (input and output are effectively the same buffer)
        // Read from input_data->data and write to output_data->data
        // For in-place processing, you can directly modify input_data->data
        float* audio_data = static_cast<float*>(input_data->data);
        size_t n_frames = input_data->chunksize / (Config.Channels * sizeof(float));

        // Example: simple gain reduction
        for (size_t i = 0; i < n_frames * Config.Channels; ++i) {
            audio_data[i] *= 0.8f; // Reduce gain by 20%
        }
        output_data->chunksize = input_data->chunksize; // Output size matches input size
    }
}

void PipewireProcessor::HandleError(const std::string& message) {
    std::cerr << "PipeWire Error: " << message << std::endl;
}

// --- Example Usage ---

int main() {
    PipewireProcessorConfig config;
    config.ClientName = "MyPipewireClient";
    config.NodeName = "MyAudioProcessor";
    config.PortDirection = PW_DIRECTION_OUTPUT; // Or PW_DIRECTION_INPUT, or for in-place processing set up input and output ports
    config.SampleRate = 48000;
    config.Channels = 2; // Stereo
    config.BufferSize = 1024; // Frames

    PipewireProcessor processor;
    if (!processor.Initialize(config)) {
        std::cerr << "Failed to initialize PipeWire processor." << std::endl;
        return 1;
    }

    processor.Run();

    // The Run() method is blocking. To stop it, you would typically use a signal handler
    // or run it in a separate thread and call processor.Stop() from another thread.
    // For this example, it will run indefinitely until manually terminated.

    // Example of how to stop after a delay (for testing purposes, not for production)
    // #include <chrono>
    // #include <thread>
    // std::this_thread::sleep_for(std::chrono::seconds(10));
    // processor.Stop();

    return 0;
}