#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// Defina os pinos para os motores de passo
const int dirPinX = 8;  // Pino de direção para motor X
const int stepPinX = 9; // Pino de passo para motor X

const int dirPinY = 10; // Pino de direção para motor Y
const int stepPinY = 11; // Pino de passo para motor Y

// Defina os pinos dos LDRs
const int ldrTop = A0;    // LDR superior
const int ldrBottom = A1; // LDR inferior
const int ldrLeft = A2;   // LDR esquerdo
const int ldrRight = A3;  // LDR direito

// Defina uma sensibilidade para a diferença de luz entre os LDRs
const int threshold = 50;  // Ajuste conforme necessário
const int darkThreshold = 100;  // Limiar para detectar entardecer

// Defina a quantidade de passos por movimento
const int stepsPerMove = 10;  // Ajuste conforme necessário

// Inicializa o display I2C (endereço 0x27 é comum, mas verifique seu display)
LiquidCrystal_I2C lcd(0x27, 16, 4);

// Variáveis para armazenar a posição atual dos motores
int currentPosX = 0;
int currentPosY = 0;
const int initialPosX = 0;  // Posição inicial do eixo X
const int initialPosY = 0;  // Posição inicial do eixo Y

// Variável de controle para verificar se o sistema está no modo de entardecer
bool isDark = false;

void setup() {
  // Defina os pinos dos motores como saída
  pinMode(dirPinX, OUTPUT);
  pinMode(stepPinX, OUTPUT);
  pinMode(dirPinY, OUTPUT);
  pinMode(stepPinY, OUTPUT);

  // Inicializa o display com 16 colunas e 4 linhas
  lcd.begin(16, 4);
  lcd.backlight(); // Liga a luz de fundo do display

  // Exibe uma mensagem inicial
  lcd.setCursor(0, 0);
  lcd.print("LDR Valores:");
}

void loop() {
  // Leia os valores dos LDRs
  int topValue = analogRead(ldrTop);
  int bottomValue = analogRead(ldrBottom);
  int leftValue = analogRead(ldrLeft);
  int rightValue = analogRead(ldrRight);

  // Atualiza o display com os valores dos LDRs
  lcd.setCursor(0, 1);
  lcd.print("T:");
  lcd.print(topValue);
  lcd.print(" B:");
  lcd.print(bottomValue);

  lcd.setCursor(0, 2);
  lcd.print("L:");
  lcd.print(leftValue);
  lcd.print(" R:");
  lcd.print(rightValue);

  // Verifica se o ambiente está escuro (entardecer)
  if (topValue < darkThreshold && bottomValue < darkThreshold &&
      leftValue < darkThreshold && rightValue < darkThreshold) {

    // Se ainda não estivermos no modo escuro, voltar rapidamente para a posição inicial
    if (!isDark) {
      returnToInitialPosition();
      isDark = true;  // Muda o estado para modo escuro
    }
  } else {
    // Se o ambiente não estiver escuro (amanhecer ou dia), movimentar os motores
    isDark = false;  // Sair do modo escuro

    // Controle do eixo Y (vertical)
    int verticalDiff = topValue - bottomValue;
    if (abs(verticalDiff) > threshold) {
      if (verticalDiff > 0) {
        // Mover para cima (topo tem mais luz)
        moveStepper(stepPinY, dirPinY, HIGH, stepsPerMove);
        currentPosY += stepsPerMove;
      } else {
        // Mover para baixo (baixo tem mais luz)
        moveStepper(stepPinY, dirPinY, LOW, stepsPerMove);
        currentPosY -= stepsPerMove;
      }
    }

    // Controle do eixo X (horizontal)
    int horizontalDiff = leftValue - rightValue;
    if (abs(horizontalDiff) > threshold) {
      if (horizontalDiff > 0) {
        // Mover para a esquerda (esquerda tem mais luz)
        moveStepper(stepPinX, dirPinX, HIGH, stepsPerMove);
        currentPosX += stepsPerMove;
      } else {
        // Mover para a direita (direita tem mais luz)
        moveStepper(stepPinX, dirPinX, LOW, stepsPerMove);
        currentPosX -= stepsPerMove;
      }
    }
  }

  // Pequena pausa para evitar movimentação muito rápida
  delay(100);
}

// Função para mover o motor de passo
void moveStepper(int stepPin, int dirPin, int dir, int steps) {
  // Define a direção
  digitalWrite(dirPin, dir);

  // Dá os passos
  for (int i = 0; i < steps; i++) {
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(500);  // Ajuste conforme a velocidade desejada
    digitalWrite(stepPin, LOW);
    delayMicroseconds(500);
  }
}

// Função para retornar os motores para a posição inicial (início do movimento)
void returnToInitialPosition() {
  // Mover o eixo X de volta à posição inicial
  if (currentPosX > initialPosX) {
    moveStepper(stepPinX, dirPinX, LOW, currentPosX - initialPosX);  // Movimenta de volta ao início
  } else if (currentPosX < initialPosX) {
    moveStepper(stepPinX, dirPinX, HIGH, initialPosX - currentPosX);
  }
  currentPosX = initialPosX;  // Atualiza a posição atual

  // Mover o eixo Y de volta à posição inicial
  if (currentPosY > initialPosY) {
    moveStepper(stepPinY, dirPinY, LOW, currentPosY - initialPosY);  // Movimenta de volta ao início
  } else if (currentPosY < initialPosY) {
    moveStepper(stepPinY, dirPinY, HIGH, initialPosY - currentPosY);
  }
  currentPosY = initialPosY;  // Atualiza a posição atual
}