#include "nodegraph.h"
#include <cstring>

// CurveNode evaluation
void CurveNode::evaluate(uint32_t tick) {
    //outputValue = getCurveValue(curveID, tick);
}

// ServoNode evaluation
void ServoNode::evaluate(uint32_t tick) {
    //setMotorPWM(motorID, inputValue);
}

// NodeGraph tick
void NodeGraph::tick(uint32_t currentTick) {
    // First pass: evaluate all nodes
    for (Node* node : nodes) {
        node->evaluate(currentTick);
    }

    // Optional: if you want to simulate wiring between nodes,
    // you could add a second pass here to propagate values
}

void loadNodeGraph(const uint8_t* packet, size_t length, NodeGraph& graph) {
    size_t offset = 0;

    // Read node count
    uint16_t nodeCount = packet[offset];
    offset += 1;

    // Parse nodes
    for (uint16_t i = 0; i < nodeCount; ++i) {
        if (offset + 6 > length) break; // safety check

        uint8_t type = packet[offset++];
        uint8_t id = packet[offset++];
        uint16_t x = packet[offset] | (packet[offset + 1] << 8); offset += 2;
        uint16_t y = packet[offset] | (packet[offset + 1] << 8); offset += 2;

        Node* node = nullptr;

        switch (type) {
            case TYPE_CURVENODE: { // CurveNode
                if (offset + 1 > length) break;
                uint8_t curveID = packet[offset++];
                auto* curve = new CurveNode();
                curve->id = id;
                curve->type = type;
                curve->x = x;
                curve->y = y;
                curve->curveID = curveID;
                node = curve;
                break;
            }
            case TYPE_SERVONODE: { // ServoNode
                if (offset + 1 > length) break;
                uint8_t motorID = packet[offset++];
                auto* servo = new ServoNode();
                servo->id = id;
                servo->type = type;
                servo->x = x;
                servo->y = y;
                servo->motorID = motorID;
                node = servo;
                break;
            }
            case TYPE_NOISENODE: { // NoiseNode
                if (offset + 17 > length) break;
                offset += 17; // skip for now
                break;
            }
            default:
                break;
        }

        if (node) {

            graph.nodes.push_back(node);
        }
    }

    // Parse connections
    if (offset + 2 > length) return;
    uint16_t connectionCount = packet[offset];
    offset += 1;

    for (uint16_t i = 0; i < connectionCount; ++i) {
        if (offset + 2 > length) break;
        uint8_t fromID = packet[offset++];
        uint8_t toID = packet[offset++];

       graph.connections.push_back({fromID, toID});
    }
}

String printNodeGraph(const NodeGraph& graph) {
  String output = "📦 NodeGraph Dump\n";

  output += "Nodes:\n";
  for (const Node* node : graph.nodes) {
    output += "  ID " + String(node->id);
    output += " | Type " + String(node->type);
    output += " | Pos (" + String(node->x) + ", " + String(node->y) + ")";

    switch (node->type) {
      case TYPE_CURVENODE: { // CurveNode
        const CurveNode* curve = static_cast<const CurveNode*>(node);
        output += " | CurveID " + String(curve->curveID);
        break;
      }
      case TYPE_SERVONODE: { // ServoNode
        const ServoNode* servo = static_cast<const ServoNode*>(node);
        output += " | MotorID " + String(servo->motorID);
        break;
      }
      // case 2: { // NoiseNode
      //   const NoiseNode* noise = static_cast<const NoiseNode*>(node);
      //   output += " | Noise a=" + String(noise->a, 2);
      //   output += " b=" + String(noise->b, 2);
      //   output += " c=" + String(noise->c, 2);
      //   output += " d=" + String(noise->d, 2);
      //   output += " seed=" + String(noise->seed);
      //   break;
      // }
    }

    output += "\n";
  }

  output += "Connections:\n";
  for (const auto& conn : graph.connections) {
    output += "  " + String(conn.fromID) + " → " + String(conn.toID) + "\n";
  }

  return output;
}