//PROYECTO MAESTRO - VERSIÓN CON REGISTRO DE DESPLAZAMIENTO 74HC595
// --- LIBRERÍAS COMUNES ---
#include <Wire.h>
#include <SPI.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <ESP32Encoder.h>
#include <math.h>

// --- CONFIGURACIÓN DE PANTALLA OLED (I2C) ---
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_RESET -1
#define SCREEN_ADDRESS 0x3C
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

// --- CONFIGURACIÓN DE ENCODERS ---
#define VOL_CLK_PIN      12 
#define VOL_DT_PIN       13 
#define GAIN_CLK_PIN     17 //TX2
#define GAIN_DT_PIN      16 //RX2
#define HIGH_CLK_PIN     34 
#define HIGH_DT_PIN      35
#define MID_HIGH_CLK_PIN 32
#define MID_HIGH_DT_PIN  33
#define MID_LOW_CLK_PIN  25
#define MID_LOW_DT_PIN   26
#define LOW_CLK_PIN      27
#define LOW_DT_PIN       14 

// Pines VSPI: MOSI=23, SCK=18, (MISO=19 Este pin: MISO, no es usado por el MCP4231/503)
// --- CONFIGURACIÓN DEL REGISTRO DE DESPLAZAMIENTO 74HC595 PARA LOS PINES CS ---
// Estos 3 pines del ESP32 controlarán todas las señales CS.
#define SHIFT_REG_DATA_PIN  19   // Conectado al pin 14 (DS) del 74HC595
#define SHIFT_REG_LATCH_PIN 4   // Conectado al pin 12 (STCP) del 74HC595
#define SHIFT_REG_CLOCK_PIN 15  // Conectado al pin 11 (SHCP) del 74HC595

// Mapeo de cada potenciómetro a una salida (bit) del 74HC595
// Usamos los bits del 0 al 5 para las salidas Q0 a Q5.
const int VOL_CS_BIT      = 0; // Q0
const int GAIN_CS_BIT     = 1; // Q1
const int HIGH_CS_BIT     = 2; // Q2
const int MID_HIGH_CS_BIT = 3; // Q3
const int MID_LOW_CS_BIT  = 4; // Q4
const int LOW_CS_BIT      = 5; // Q5

// --- CONFIGURACIÓN DEL VÚMETRO ---
#define VOLTAGE_IN_L 36 // Canal Izquierdo (ADC1_CH0)
#define VOLTAGE_IN_R 39 // Canal Derecho (ADC1_CH3)
#define SAMPLES_AVG 64
#define ADC_MAX_VALUE 4095
#define ADC_REF_0DB 1106.0 // Valor ADC que corresponde a 0dB
#define DB_MIN -30.0
#define DB_MAX 11.4
#define PEAK_HOLD_MS 1500
#define PEAK_DECAY_RATE 0.35

// --- PARÁMETROS DE FUNCIONAMIENTO ---
#define DISPLAY_TIMEOUT_MS 3000 // 3 segundos para volver al vúmetro
const int POT_MAX_STEPS = 255;
#define ENCODER_STEPS_PER_DB 2

// Rangos de Decibelios (dB) para los controles
const int VOL_MIN = -80, VOL_MAX = 10;
const int GAIN_MIN = -20, GAIN_MAX = 20;
const int EQ_MIN = -15, EQ_MAX = 15;

// --- OBJETOS GLOBALES ---
ESP32Encoder encoderVol;
ESP32Encoder encoderGain;
ESP32Encoder encoderHigh;
ESP32Encoder encoderMidHigh;
ESP32Encoder encoderMidLow;
ESP32Encoder encoderLow;

// --- VARIABLES DE ESTADO GLOBALES ---
// Para los controles
int currentVolDB = 0;
int currentGainDB = 0;
int currentHighDB = 0;
int currentMidHighDB = 0;
int currentMidLowDB = 0;
int currentLowDB = 0;

// Para el vúmetro
double peakL = DB_MIN;
double peakR = DB_MIN;
unsigned long lastPeakTimeL = 0;
unsigned long lastPeakTimeR = 0;

// Para la gestión de la pantalla
enum DisplayMode { MODE_VUMETER, MODE_PARAM };
DisplayMode currentMode = MODE_VUMETER;
unsigned long lastInteractionTime = 0;

// Variable para el estado del registro de desplazamiento
byte shiftRegisterState = 0b11111111; // Inicia con todos los CS en HIGH (inactivos)

// --- PROTOTIPOS DE FUNCIONES ---
void updateShiftRegister();
void writeToPot(int csBit, byte address, byte value);
void setPotValue(int csBit, int dbValue, int dbMin, int dbMax);
void actualizarPantallaParametro(const char *paramName, int currentValue, int minValue, int maxValue);
void drawVUMeterBar(int x_start, int y_start, double dbValue, double peakDbValue);
void actualizarVUMeter();


// =====================================================================================
// ===                                   SETUP                                     ===
// =====================================================================================
void setup() {
  //Serial.begin(115200);
  
  // --- Inicialización de Buses ---
  SPI.begin();
  Wire.begin(); 

  // --- Inicialización de Pines del Registro de Desplazamiento ---
  pinMode(SHIFT_REG_DATA_PIN, OUTPUT);
  pinMode(SHIFT_REG_LATCH_PIN, OUTPUT);
  pinMode(SHIFT_REG_CLOCK_PIN, OUTPUT);

  // Asegurarse de que todos los CS estén desactivados (HIGH) al iniciar
  shiftRegisterState = 0xFF; // 0b11111111
  updateShiftRegister();

  // --- Inicialización de Encoders ---
  encoderVol.attachHalfQuad(VOL_DT_PIN, VOL_CLK_PIN);
  encoderVol.setCount(VOL_MIN * ENCODER_STEPS_PER_DB);
  currentVolDB = VOL_MIN;

  encoderGain.attachHalfQuad(GAIN_DT_PIN, GAIN_CLK_PIN);
  encoderGain.setCount(0 * ENCODER_STEPS_PER_DB);
  
  encoderHigh.attachHalfQuad(HIGH_DT_PIN, HIGH_CLK_PIN);
  encoderHigh.setCount(0 * ENCODER_STEPS_PER_DB);

  encoderMidHigh.attachHalfQuad(MID_HIGH_DT_PIN, MID_HIGH_CLK_PIN);
  encoderMidHigh.setCount(0 * ENCODER_STEPS_PER_DB);

  encoderMidLow.attachHalfQuad(MID_LOW_DT_PIN, MID_LOW_CLK_PIN);
  encoderMidLow.setCount(0 * ENCODER_STEPS_PER_DB);
  
  encoderLow.attachHalfQuad(LOW_DT_PIN, LOW_CLK_PIN);
  encoderLow.setCount(0 * ENCODER_STEPS_PER_DB);

  // --- Configurar estado inicial de los potenciómetros usando los bits del 74HC595 ---
  setPotValue(VOL_CS_BIT, currentVolDB, VOL_MIN, VOL_MAX);
  setPotValue(GAIN_CS_BIT, currentGainDB, GAIN_MIN, GAIN_MAX);
  setPotValue(HIGH_CS_BIT, currentHighDB, EQ_MIN, EQ_MAX);
  setPotValue(MID_HIGH_CS_BIT, currentMidHighDB, EQ_MIN, EQ_MAX);
  setPotValue(MID_LOW_CS_BIT, currentMidLowDB, EQ_MIN, EQ_MAX);
  setPotValue(LOW_CS_BIT, currentLowDB, EQ_MIN, EQ_MAX);
  
  // --- Inicialización de la pantalla OLED ---
  display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS);
  display.clearDisplay();
  display.setTextSize(2);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(15, 24);
  display.println("PATRO DJ");
  display.display();
  delay(1500);

  // Iniciar temporizador para la gestión de pantalla
  lastInteractionTime = millis();
  currentMode = MODE_VUMETER; 
}


// =====================================================================================
// ===                                 MAIN LOOP                                   ===
// =====================================================================================
void loop() {
  bool interaction = false; 

  // --- 1. LEER ENCODERS Y ACTUALIZAR PARÁMETROS ---
  long newVol = encoderVol.getCount() / ENCODER_STEPS_PER_DB;
  if (newVol > VOL_MAX) { newVol = VOL_MAX; encoderVol.setCount(newVol * ENCODER_STEPS_PER_DB); }
  if (newVol < VOL_MIN) { newVol = VOL_MIN; encoderVol.setCount(newVol * ENCODER_STEPS_PER_DB); }
  if (newVol != currentVolDB) {
    currentVolDB = newVol;
    actualizarPantallaParametro("VOLUMEN", currentVolDB, VOL_MIN, VOL_MAX);
    setPotValue(VOL_CS_BIT, currentVolDB, VOL_MIN, VOL_MAX);
    interaction = true;
  }

  long newGain = encoderGain.getCount() / ENCODER_STEPS_PER_DB;
  if (newGain > GAIN_MAX) { newGain = GAIN_MAX; encoderGain.setCount(newGain * ENCODER_STEPS_PER_DB); }
  if (newGain < GAIN_MIN) { newGain = GAIN_MIN; encoderGain.setCount(newGain * ENCODER_STEPS_PER_DB); }
  if (newGain != currentGainDB) {
    currentGainDB = newGain;
    actualizarPantallaParametro("GAIN", currentGainDB, GAIN_MIN, GAIN_MAX);
    setPotValue(GAIN_CS_BIT, currentGainDB, GAIN_MIN, GAIN_MAX);
    interaction = true;
  }

  long newHigh = encoderHigh.getCount() / ENCODER_STEPS_PER_DB;
  if (newHigh > EQ_MAX) { newHigh = EQ_MAX; encoderHigh.setCount(newHigh * ENCODER_STEPS_PER_DB); }
  if (newHigh < EQ_MIN) { newHigh = EQ_MIN; encoderHigh.setCount(newHigh * ENCODER_STEPS_PER_DB); }
  if (newHigh != currentHighDB) {
    currentHighDB = newHigh;
    actualizarPantallaParametro("HIGH", currentHighDB, EQ_MIN, EQ_MAX);
    setPotValue(HIGH_CS_BIT, currentHighDB, EQ_MIN, EQ_MAX);
    interaction = true;
  }
  
  long newMidHigh = encoderMidHigh.getCount() / ENCODER_STEPS_PER_DB;
  if (newMidHigh > EQ_MAX) { newMidHigh = EQ_MAX; encoderMidHigh.setCount(newMidHigh * ENCODER_STEPS_PER_DB); }
  if (newMidHigh < EQ_MIN) { newMidHigh = EQ_MIN; encoderMidHigh.setCount(newMidHigh * ENCODER_STEPS_PER_DB); }
  if (newMidHigh != currentMidHighDB) {
    currentMidHighDB = newMidHigh;
    actualizarPantallaParametro("MID HIGH", currentMidHighDB, EQ_MIN, EQ_MAX);
    setPotValue(MID_HIGH_CS_BIT, currentMidHighDB, EQ_MIN, EQ_MAX);
    interaction = true;
  }
  
  long newMidLow = encoderMidLow.getCount() / ENCODER_STEPS_PER_DB;
  if (newMidLow > EQ_MAX) { newMidLow = EQ_MAX; encoderMidLow.setCount(newMidLow * ENCODER_STEPS_PER_DB); }
  if (newMidLow < EQ_MIN) { newMidLow = EQ_MIN; encoderMidLow.setCount(newMidLow * ENCODER_STEPS_PER_DB); }
  if (newMidLow != currentMidLowDB) {
    currentMidLowDB = newMidLow;
    actualizarPantallaParametro("MID LOW", currentMidLowDB, EQ_MIN, EQ_MAX);
    setPotValue(MID_LOW_CS_BIT, currentMidLowDB, EQ_MIN, EQ_MAX);
    interaction = true;
  }

  long newLow = encoderLow.getCount() / ENCODER_STEPS_PER_DB;
  if (newLow > EQ_MAX) { newLow = EQ_MAX; encoderLow.setCount(newLow * ENCODER_STEPS_PER_DB); }
  if (newLow < EQ_MIN) { newLow = EQ_MIN; encoderLow.setCount(newLow * ENCODER_STEPS_PER_DB); }
  if (newLow != currentLowDB) {
    currentLowDB = newLow;
    actualizarPantallaParametro("LOW", currentLowDB, EQ_MIN, EQ_MAX);
    setPotValue(LOW_CS_BIT, currentLowDB, EQ_MIN, EQ_MAX);
    interaction = true;
  }
  
  // --- 2. GESTIONAR EL MODO DE LA PANTALLA ---
  if (interaction) {
    lastInteractionTime = millis();
    currentMode = MODE_PARAM;
  } else {
    if (currentMode == MODE_PARAM && (millis() - lastInteractionTime > DISPLAY_TIMEOUT_MS)) {
      currentMode = MODE_VUMETER;
    }
  }

  // --- 3. DIBUJAR EN PANTALLA SEGÚN EL MODO ---
  if (currentMode == MODE_VUMETER) {
    actualizarVUMeter();
    delay(50); 
  } else {
    delay(20); 
  }
}


// =====================================================================================
// ===                          FUNCIONES DE LA CONTROLADORA                        ===
// =====================================================================================

// Envía el estado actual al registro de desplazamiento 74HC595
void updateShiftRegister() {
  digitalWrite(SHIFT_REG_LATCH_PIN, LOW); // Prepara el registro para recibir datos
  shiftOut(SHIFT_REG_DATA_PIN, SHIFT_REG_CLOCK_PIN, MSBFIRST, shiftRegisterState);
  digitalWrite(SHIFT_REG_LATCH_PIN, HIGH); // Aplica los datos a las salidas (Q0-Q7)
}

// Envía un comando de escritura a un potenciómetro, controlando el CS vía 74HC595
void writeToPot(int csBit, byte address, byte value) {
  SPI.beginTransaction(SPISettings(1000000, MSBFIRST, SPI_MODE0));

  // 1. Activar el CS correspondiente (poner el bit a 0)
  bitClear(shiftRegisterState, csBit);
  updateShiftRegister();

  // 2. Enviar datos por SPI
  SPI.transfer(address);
  SPI.transfer(value);

  // 3. Desactivar todos los CS (poner todos los bits a 1)
  shiftRegisterState = 0xFF; // 0b11111111
  updateShiftRegister();

  SPI.endTransaction();
}

// Convierte dB a valor de potenciómetro y lo envía
void setPotValue(int csBit, int dbValue, int dbMin, int dbMax) {
  long potStep = map(dbValue, dbMin, dbMax, POT_MAX_STEPS, 0); 
  potStep = constrain(potStep, 0, POT_MAX_STEPS);
  
  writeToPot(csBit, 0x00, (byte)potStep); // Dirección Wiper 0
  writeToPot(csBit, 0x10, (byte)potStep); // Dirección Wiper 1
}

// Dibuja la pantalla de ajuste de un parámetro (sin cambios)
void actualizarPantallaParametro(const char *paramName, int currentValue, int minValue, int maxValue) {
  display.clearDisplay();

  // 1. Dibuja el nombre y el valor numérico
  display.setTextSize(2);
  display.setTextColor(SSD1306_WHITE);
  int16_t x1, y1;
  uint16_t w, h;
  display.getTextBounds(paramName, 0, 0, &x1, &y1, &w, &h);
  display.setCursor((SCREEN_WIDTH - w) / 2, 2);
  display.println(paramName);

  char dbStr[10];
  sprintf(dbStr, "%+d dB", currentValue); 
  display.getTextBounds(dbStr, 0, 0, &x1, &y1, &w, &h);
  display.setCursor((SCREEN_WIDTH - w) / 2, 20);
  display.print(dbStr);

  // 2. Dibuja la barra de progreso
  int barWidth = map(currentValue, minValue, maxValue, 0, SCREEN_WIDTH);
  display.drawRect(0, 42, SCREEN_WIDTH, 16, SSD1306_WHITE);

  if (minValue < 0 && maxValue > 0) {
    int zeroPoint = map(0, minValue, maxValue, 0, SCREEN_WIDTH);
    display.drawFastVLine(zeroPoint, 40, 20, SSD1306_WHITE); 
    if (barWidth > zeroPoint) {
      display.fillRect(zeroPoint, 42, barWidth - zeroPoint, 16, SSD1306_WHITE);
    } else {
      display.fillRect(barWidth, 42, zeroPoint - barWidth, 16, SSD1306_WHITE);
    }
  } else { 
    display.fillRect(0, 42, barWidth, 16, SSD1306_WHITE);
  }

  // 3. Muestra todo en la pantalla
  display.display();
}

// =====================================================================================
// ===                            FUNCIONES DEL VÚMETRO                           ===
// =====================================================================================
// (Esta sección no necesita cambios, se mantiene idéntica a la original)

void drawVUMeterBar(int x_start, int y_start, double dbValue, double peakDbValue) {
  #define BAR_LENGTH 100
  #define BAR_HEIGHT 20
  #define SEGMENT_WIDTH 3
  #define SEGMENT_SPACING 1
  
  int totalSegments = BAR_LENGTH / (SEGMENT_WIDTH + SEGMENT_SPACING);
  
  display.drawRect(x_start - 1, y_start - 1, BAR_LENGTH + 2, BAR_HEIGHT + 2, SSD1306_WHITE);

  int activeSegments = map(dbValue, DB_MIN, DB_MAX, 0, totalSegments);
  activeSegments = constrain(activeSegments, 0, totalSegments);
  for (int i = 0; i < activeSegments; i++) {
    int xPos = x_start + (i * (SEGMENT_WIDTH + SEGMENT_SPACING));
    display.fillRect(xPos, y_start, SEGMENT_WIDTH, BAR_HEIGHT, SSD1306_WHITE);
  }

  int peakSegment = map(peakDbValue, DB_MIN, DB_MAX, 0, totalSegments);
  peakSegment = constrain(peakSegment, 0, totalSegments);
  int peakXPos = x_start + (peakSegment * (SEGMENT_WIDTH + SEGMENT_SPACING));
  if (peakXPos < x_start + BAR_LENGTH) {
    display.fillRect(peakXPos, y_start, SEGMENT_WIDTH, BAR_HEIGHT, SSD1306_WHITE);
  }
}

void actualizarVUMeter() {
  unsigned long totalL = 0;
  unsigned long totalR = 0;
  for (int i = 0; i < SAMPLES_AVG; i++) {
    totalL += analogRead(VOLTAGE_IN_L);
    totalR += analogRead(VOLTAGE_IN_R);
  }
  double dbL = (totalL == 0) ? DB_MIN : 20 * log10((double)(totalL / SAMPLES_AVG) / ADC_REF_0DB);
  double dbR = (totalR == 0) ? DB_MIN : 20 * log10((double)(totalR / SAMPLES_AVG) / ADC_REF_0DB);

  unsigned long currentTime = millis();
  if (dbL >= peakL) {
    peakL = dbL;
    lastPeakTimeL = currentTime;
  } else if (currentTime - lastPeakTimeL > PEAK_HOLD_MS) {
    peakL -= PEAK_DECAY_RATE;
    if (peakL < dbL) peakL = dbL;
    if (peakL < DB_MIN) peakL = DB_MIN;
  }
  if (dbR >= peakR) {
    peakR = dbR;
    lastPeakTimeR = currentTime;
  } else if (currentTime - lastPeakTimeR > PEAK_HOLD_MS) {
    peakR -= PEAK_DECAY_RATE;
    if (peakR < dbR) peakR = dbR;
    if (peakR < DB_MIN) peakR = DB_MIN;
  }

  display.clearDisplay();
  int label_x = 9;
  int bar_x_start = 26;
  
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);

  drawVUMeterBar(bar_x_start, 4, dbL, peakL); 
  display.setCursor(1, 12);
  int roundedDbL = round(dbL); 
  if (roundedDbL > 0) display.print("+");
  display.print(roundedDbL);
  display.setCursor(label_x, 3);
  display.print("L");
  display.setCursor(6, 20);
  display.print("dB");
  
  drawVUMeterBar(bar_x_start, 39, dbR, peakR);
  display.setCursor(1, 47);
  int roundedDbR = round(dbR); 
  if (roundedDbR > 0) display.print("+");
  display.print(roundedDbR); 
  display.setCursor(label_x, 37);
  display.print("R");
  display.setCursor(6, 55);
  display.print("dB");
  
  display.setCursor(30, 28);
  display.print("PATRO DJ");
  
  display.display();
}