// midi/midi_transport.cpp
#include "midi/midi_transport.h"
#include "esp_log.h"
#include "tusb.h"
#include "class/midi/midi.h"

static const char* TAG = "midi_transport";

UsbMidiTransport::UsbMidiTransport() : event_queue(nullptr), initialized(false) {
}

UsbMidiTransport::~UsbMidiTransport() {
    if (event_queue != NULL) {
        vQueueDelete(event_queue);
    }
}

bool UsbMidiTransport::begin() {
    // Create event queue
    event_queue = xQueueCreate(32, sizeof(MidiEvent));
    if (event_queue == NULL) {
        ESP_LOGE(TAG, "Failed to create event queue");
        return false;
    }
    
    // Initialize TinyUSB MIDI
    tusb_init();
    
    // Configure USB device descriptors
    tusb_device_set_string(1, "Loopy Foot Controller");
    
    // Register MIDI callback
    tuh_midi_set_cb(usb_midi_callback);
    
    initialized = true;
    ESP_LOGI(TAG, "USB MIDI transport initialized");
    return true;
}

void UsbMidiTransport::task() {
    if (!initialized) return;
    
    // Process USB MIDI events
    while (tuh_uart_read_available()) {
        uint8_t buffer[128];
        uint32_t bytes_read = tuh_midi_read_packet(buffer, sizeof(buffer));
        
        if (bytes_read > 0) {
            MidiEvent event;
            parse_midi_packet(buffer, bytes_read, event);
            
            // Log incoming event
            log_incoming("USB", event);
            
            // Send to event queue
            if (xQueueSend(event_queue, &event, portMAX_DELAY) != pdPASS) {
                ESP_LOGW(TAG, "Failed to queue MIDI event");
            }
        }
    }
}

void usb_midi_callback(const uint8_t* event, uint32_t size) {
    // This callback is called by TinyUSB when MIDI data is received
    // For now, we'll implement a simple version
    // In a full implementation, this would parse the MIDI packet
    
    MidiEvent midi_event;
    // TODO: Implement actual MIDI parsing based on event type
    // For Phase 1, we'll handle basic Note On/Off messages
}

void UsbMidiTransport::log_incoming(const char* source, const MidiEvent& event) {
    const char* type_str;
    switch (event.type) {
        case MidiEvent::NOTE_ON: type_str = "NOTE_ON"; break;
        case MidiEvent::NOTE_OFF: type_str = "NOTE_OFF"; break;
        case MidiEvent::CONTROL_CHANGE: type_str = "CONTROL_CHANGE"; break;
        default: type_str = "UNKNOWN"; break;
    }
    
    ESP_LOGI(TAG, "MIDI IN: %s Channel: %d Type: %s Note: %d Velocity: %d",
             source, event.channel, type_str, event.data1, event.data2);
}

void UsbMidiTransport::parse_midi_packet(const uint8_t* buffer, uint32_t size, MidiEvent& event) {
    // Simple MIDI parser for basic messages
    // This is a simplified version for Phase 1
    
    if (size < 2) return;
    
    uint8_t status = buffer[0];
    uint8_t type = status & 0xF0;  // Message type
    uint8_t channel = status & 0x0F;  // Channel (0-15, but MIDI uses 1-16)
    
    event.channel = channel + 1;  // Convert to 1-16 range
    
    switch (type) {
        case 0x90:  // Note On
            event.type = MidiEvent::NOTE_ON;
            event.data1 = buffer[1];
            event.data2 = buffer[2];
            break;
        
        case 0x80:  // Note Off
            event.type = MidiEvent::NOTE_OFF;
            event.data1 = buffer[1];
            event.data2 = buffer[2];
            break;
        
        case 0xB0:  // Control Change
            event.type = MidiEvent::CONTROL_CHANGE;
            event.data1 = buffer[1];
            event.data2 = buffer[2];
            break;
            
        default:
            // Unknown message type - ignore for now
            return;
    }
}