// JUCE AudioProcessorGraph 的基本结构
class AudioProcessorGraph : public AudioProcessor {
public:
    struct NodeID {
        uint32 uid;  // 唯一标识符
    };

    struct Node {
        std::unique_ptr<AudioProcessor> processor;
        NodeID nodeID;
        AudioBuffer<float> audioBuffer;  // 每个节点的独立缓冲区
    };

    struct Connection {
        NodeID sourceNodeID;
        int sourceChannelIndex;
        NodeID destNodeID;
        int destChannelIndex;
        float gain = 1.0f;  // 连接增益控制
    };

private:
    std::vector<std::unique_ptr<Node>> nodes;
    std::vector<Connection> connections;
    std::vector<NodeID> renderingOrder;  // 拓扑排序后的执行顺序
};

// 拓扑排序的核心实现
class TopologicalSorter {
public:
    std::vector<NodeID> sortNodes(const std::vector<Node*>& nodes,
                                  const std::vector<Connection>& connections) {
        // 1. 计算每个节点的入度
        std::unordered_map<NodeID, int> inDegree;
        for (const auto& node : nodes) {
            inDegree[node->nodeID] = 0;
        }

        for (const auto& conn : connections) {
            inDegree[conn.destNodeID]++;
        }

        // 2. 找到所有入度为0的节点
        std::queue<NodeID> zeroInDegreeQueue;
        for (const auto& [nodeID, degree] : inDegree) {
            if (degree == 0) {
                zeroInDegreeQueue.push(nodeID);
            }
        }

        // 3. Kahn算法主循环
        std::vector<NodeID> sortedOrder;
        while (!zeroInDegreeQueue.empty()) {
            NodeID currentNode = zeroInDegreeQueue.front();
            zeroInDegreeQueue.pop();
            sortedOrder.push_back(currentNode);

            // 移除当前节点的所有输出边
            for (const auto& conn : connections) {
                if (conn.sourceNodeID == currentNode) {
                    inDegree[conn.destNodeID]--;
                    if (inDegree[conn.destNodeID] == 0) {
                        zeroInDegreeQueue.push(conn.destNodeID);
                    }
                }
            }
        }

        // 4. 检查是否存在环路
        if (sortedOrder.size() != nodes.size()) {
            throw std::runtime_error("Cycle detected in audio graph!");
        }

        return sortedOrder;
    }
};

// 智能缓冲区管理的核心实现
class AudioBufferManager {
private:
    std::vector<AudioBuffer<float>> bufferPool;  // 缓冲区池
    std::vector<bool> bufferInUse;               // 使用状态

public:
    AudioBuffer<float>* acquireBuffer(int numChannels, int numSamples) {
        // 寻找可重用的缓冲区
        for (size_t i = 0; i < bufferPool.size(); ++i) {
            if (!bufferInUse[i] &&
                bufferPool[i].getNumChannels() >= numChannels &&
                bufferPool[i].getNumSamples() >= numSamples) {

                bufferInUse[i] = true;
                bufferPool[i].setSize(numChannels, numSamples, false, false, true);
                return &bufferPool[i];
            }
        }

        // 创建新缓冲区
        bufferPool.emplace_back(numChannels, numSamples);
        bufferInUse.push_back(true);
        return &bufferPool.back();
    }

    void releaseBuffer(AudioBuffer<float>* buffer) {
        for (size_t i = 0; i < bufferPool.size(); ++i) {
            if (&bufferPool[i] == buffer) {
                bufferInUse[i] = false;
                break;
            }
        }
    }
};

// 多输入混音的实现
void processNodeWithMultipleInputs(Node* node,
                                   const std::vector<AudioBuffer<float>*>& inputs) {
    auto* nodeBuffer = node->getAudioBuffer();

    if (!inputs.empty()) {
        // 第一个输入：直接复制
        nodeBuffer->copyFrom(0, 0, *inputs[0], 0, 0, nodeBuffer->getNumSamples());

        // 后续输入：累加混音
        for (size_t i = 1; i < inputs.size(); ++i) {
            nodeBuffer->addFrom(0, 0, *inputs[i], 0, 0, nodeBuffer->getNumSamples());
        }
    }

    // 处理节点
    node->processor->processBlock(*nodeBuffer, midiBuffer);
}

// 无锁双缓冲图管理器
class LockFreeGraphManager {
private:
    struct GraphData {
        std::vector<std::unique_ptr<Node>> nodes;
        std::vector<Connection> connections;
        std::vector<NodeID> renderingOrder;
        std::atomic<int> refCount{0};  // 引用计数
    };

    std::atomic<GraphData*> activeGraph{nullptr};
    std::atomic<GraphData*> modifyingGraph{nullptr};

public:
    // 音频线程：获取当前图进行处理
    class GraphReader {
        GraphData* graph;
    public:
        GraphReader(LockFreeGraphManager& manager) {
            graph = manager.activeGraph.load();
            if (graph) {
                graph->refCount.fetch_add(1);  // 增加引用计数
            }
        }

        ~GraphReader() {
            if (graph) {
                graph->refCount.fetch_sub(1);  // 减少引用计数
            }
        }

        const std::vector<NodeID>& getRenderingOrder() const {
            return graph ? graph->renderingOrder : emptyOrder;
        }
    };

    // UI线程：修改图结构
    void modifyGraph(std::function<void(GraphData&)> modifier) {
        // 1. 获取修改用的图
        GraphData* modGraph = modifyingGraph.load();
        if (!modGraph) {
            modGraph = new GraphData();
            modifyingGraph.store(modGraph);
        }

        // 2. 复制当前活动图的状态
        GraphData* currentActive = activeGraph.load();
        if (currentActive) {
            *modGraph = *currentActive;  // 深拷贝
        }

        // 3. 应用修改
        modifier(*modGraph);

        // 4. 重新计算拓扑排序
        modGraph->renderingOrder = calculateTopologicalOrder(
            modGraph->nodes, modGraph->connections);

        // 5. 原子切换 - 这是唯一的同步点
        GraphData* oldActive = activeGraph.exchange(modGraph);
        modifyingGraph.store(oldActive);

        // 6. 等待旧图不再被使用，然后可以安全修改
        if (oldActive) {
            while (oldActive->refCount.load() > 0) {
                std::this_thread::yield();  // 等待音频线程释放引用
            }
        }
    }
};

// 使用示例
void processAudioBlock(AudioBuffer<float>& buffer) {
    GraphReader reader(graphManager);  // 获取当前图的只读访问

    for (NodeID nodeID : reader.getRenderingOrder()) {
        Node* node = findNode(nodeID);
        if (node) {
            node->processor->processBlock(buffer, midiBuffer);
        }
    }
}  // reader析构时自动释放引用

// 自动延迟补偿算法
class LatencyCompensator {
private:
    struct NodeLatencyInfo {
        int intrinsicLatency;    // 插件本身的延迟
        int downstreamLatency;   // 到输出端的最大延迟
        int compensationDelay;   // 需要添加的补偿延迟
    };

    std::unordered_map<NodeID, NodeLatencyInfo> latencyMap;

public:
    void calculateLatencyCompensation(const std::vector<Node*>& nodes,
                                      const std::vector<Connection>& connections) {
        // 1. 收集每个节点的固有延迟
        for (const auto& node : nodes) {
            latencyMap[node->nodeID].intrinsicLatency =
                node->processor->getLatencySamples();
        }

        // 2. 计算每个节点到输出的最大延迟路径
        calculateDownstreamLatency(nodes, connections);

        // 3. 计算补偿延迟
        int maxTotalLatency = 0;
        for (const auto& [nodeID, info] : latencyMap) {
            int totalLatency = info.intrinsicLatency + info.downstreamLatency;
            maxTotalLatency = std::max(maxTotalLatency, totalLatency);
        }

        for (auto& [nodeID, info] : latencyMap) {
            int totalLatency = info.intrinsicLatency + info.downstreamLatency;
            info.compensationDelay = maxTotalLatency - totalLatency;
        }

        // 4. 应用延迟补偿
        applyLatencyCompensation(nodes);
    }

private:
    void calculateDownstreamLatency(const std::vector<Node*>& nodes,
                                    const std::vector<Connection>& connections) {
        // 使用拓扑排序的逆序来计算下游延迟
        auto reverseOrder = getTopologicalOrder(nodes, connections);
        std::reverse(reverseOrder.begin(), reverseOrder.end());

        for (NodeID nodeID : reverseOrder) {
            int maxDownstreamLatency = 0;

            // 找到所有输出连接
            for (const auto& conn : connections) {
                if (conn.sourceNodeID == nodeID) {
                    NodeID destNodeID = conn.destNodeID;
                    int destTotalLatency = latencyMap[destNodeID].intrinsicLatency +
                                           latencyMap[destNodeID].downstreamLatency;
                    maxDownstreamLatency = std::max(maxDownstreamLatency, destTotalLatency);
                }
            }

            latencyMap[nodeID].downstreamLatency = maxDownstreamLatency;
        }
    }

    void applyLatencyCompensation(const std::vector<Node*>& nodes) {
        for (const auto& node : nodes) {
            int compensationDelay = latencyMap[node->nodeID].compensationDelay;
            if (compensationDelay > 0) {
                // 为节点添加延迟缓冲区
                node->setLatencyCompensation(compensationDelay);
            }
        }
    }
};

// 延迟缓冲区的实现
class DelayBuffer {
private:
    AudioBuffer<float> delayBuffer;
    int writePosition = 0;
    int delaySamples;

public:
    DelayBuffer(int numChannels, int maxDelaySamples)
        : delayBuffer(numChannels, maxDelaySamples), delaySamples(0) {}

    void setDelay(int samples) {
        delaySamples = std::min(samples, delayBuffer.getNumSamples());
    }

    void processBlock(AudioBuffer<float>& buffer) {
        if (delaySamples == 0) return;

        int numSamples = buffer.getNumSamples();
        int bufferSize = delayBuffer.getNumSamples();

        for (int channel = 0; channel < buffer.getNumChannels(); ++channel) {
            auto* channelData = buffer.getWritePointer(channel);
            auto* delayData = delayBuffer.getWritePointer(channel);

            for (int i = 0; i < numSamples; ++i) {
                // 读取延迟后的样本
                int readPos = (writePosition - delaySamples + bufferSize) % bufferSize;
                float delayedSample = delayData[readPos];

                // 写入新样本
                delayData[writePosition] = channelData[i];

                // 输出延迟后的样本
                channelData[i] = delayedSample;

                writePosition = (writePosition + 1) % bufferSize;
            }
        }
    }
};

// SIMD优化的音频混音实现
class SIMDOptimizedMixer {
public:
    // 传统的标量实现
    static void mixAudioScalar(float* dest, const float* src, int numSamples, float gain) {
        for (int i = 0; i < numSamples; ++i) {
            dest[i] += src[i] * gain;
        }
    }

    // SIMD优化的向量实现
    static void mixAudioSIMD(float* dest, const float* src, int numSamples, float gain) {
        // 使用JUCE的FloatVectorOperations进行SIMD优化
        juce::FloatVectorOperations::addWithMultiply(dest, src, gain, numSamples);

        // 内部实现类似于：
        #ifdef JUCE_USE_SSE_INTRINSICS
        const __m128 gainVector = _mm_set1_ps(gain);
        int vectorizedSamples = numSamples & ~3;  // 4的倍数

        for (int i = 0; i < vectorizedSamples; i += 4) {
            __m128 srcVector = _mm_load_ps(&src[i]);
            __m128 destVector = _mm_load_ps(&dest[i]);
            __m128 result = _mm_add_ps(destVector, _mm_mul_ps(srcVector, gainVector));
            _mm_store_ps(&dest[i], result);
        }

        // 处理剩余的样本
        for (int i = vectorizedSamples; i < numSamples; ++i) {
            dest[i] += src[i] * gain;
        }
        #endif
    }
};

// 缓存友好的节点数据结构设计
struct CacheFriendlyNode {
    // 热数据：频繁访问的数据放在前面
    NodeID nodeID;                           // 4 bytes
    AudioProcessor* processor;               // 8 bytes
    AudioBuffer<float>* audioBuffer;         // 8 bytes
    std::atomic<bool> isEnabled;             // 1 byte
    float gain;                              // 4 bytes
    // 总计：25 bytes，适合单个缓存行

    // 冷数据：不常访问的数据放在后面
    std::string displayName;                 // 很少访问
    juce::Colour nodeColour;                 // UI相关
    std::vector<std::string> parameterNames; // 调试用

    // 内存对齐优化
    alignas(16) float simdBuffer[4];         // 16字节对齐，SIMD友好
};

// 数据局部性优化的图处理
class CacheOptimizedGraph {
private:
    // 将相关数据放在连续内存中
    std::vector<CacheFriendlyNode> nodes;    // 连续存储
    std::vector<Connection> connections;      // 连续存储
    std::vector<NodeID> renderingOrder;      // 连续存储

public:
    void processAudioBlock(AudioBuffer<float>& buffer) {
        // 按拓扑顺序处理，利用空间局部性
        for (NodeID nodeID : renderingOrder) {
            // 二分查找或哈希表查找节点
            auto& node = findNode(nodeID);

            // 预取下一个节点的数据到缓存
            if (auto nextNodeID = getNextNode(nodeID)) {
                __builtin_prefetch(&findNode(nextNodeID), 0, 3);
            }

            // 处理当前节点
            node.processor->processBlock(buffer, midiBuffer);
        }
    }
};

// 内存对齐的音频缓冲区
class AlignedAudioBuffer {
private:
    // 16字节对齐，适合SSE/AVX指令
    alignas(16) std::vector<float> data;
    int numChannels;
    int numSamples;

public:
    AlignedAudioBuffer(int channels, int samples)
        : numChannels(channels), numSamples(samples) {
        // 确保总大小是16的倍数
        int totalSize = channels * samples;
        int alignedSize = (totalSize + 15) & ~15;
        data.resize(alignedSize);
    }

    float* getWritePointer(int channel) {
        // 返回对齐的指针
        return data.data() + channel * numSamples;
    }

    // 验证对齐
    bool isAligned() const {
        return (reinterpret_cast<uintptr_t>(data.data()) % 16) == 0;
    }
};

class TestAudioProcessor : public juce::AudioPluginInstance {
    float gain = 1.0f;
    std::atomic<int> processCallCount{0};

public:
    void processBlock(juce::AudioBuffer<float>& buffer, juce::MidiBuffer&) override {
        processCallCount++;
        buffer.applyGain(gain);  // 简单的增益处理
    }

    // 测试辅助方法
    void setGain(float newGain) { gain = newGain; }
    int getProcessCallCount() const { return processCallCount; }
};

// 不要暴露过多细节
GraphManagerHandle graphManager_create(...);
PluginManagerHandle pluginManager_create(...);
void graphManager_connectNodes(GraphManagerHandle, NodeID, NodeID);

// 设计一个统一的、高层的API
typedef void* WindsynthEngineHandle;

WindsynthEngineHandle engine_create();
void engine_destroy(WindsynthEngineHandle handle);

// 任务驱动的函数
bool engine_loadAudioFile(WindsynthEngineHandle handle, const char* filePath);
void engine_play(WindsynthEngineHandle handle);
void engine_stop(WindsynthEngineHandle handle);

NodeID engine_addPlugin(WindsynthEngineHandle handle, const char* pluginIdentifier);
bool engine_removePlugin(WindsynthEngineHandle handle, NodeID nodeID);
// ... 其他高层函数