#include "FED4.h"

#define SHARPMEM_BIT_WRITECMD (0x01) // 0x80 if writing, 0x00 if reading
#define SHARPMEM_BIT_VCOM (0x02)     // ROM_IN pin state
#define SHARPMEM_BIT_CLEAR (0x04)    // CL pin state

#ifndef _swap_int16_t
#define _swap_int16_t(a, b) \
    {                       \
        int16_t t = a;      \
        a = b;              \
        b = t;              \
    }
#endif

// Add these lookup tables at the top of the file
static const uint8_t PROGMEM set[] = {1, 2, 4, 8, 16, 32, 64, 128},
                             clr[] = {(uint8_t)~1, (uint8_t)~2, (uint8_t)~4,
                                      (uint8_t)~8, (uint8_t)~16, (uint8_t)~32,
                                      (uint8_t)~64, (uint8_t)~128};

void FED4::updateDisplay() {
  setFont(&FreeSans9pt7b);
  setTextSize(1);
  setTextColor(DISPLAY_BLACK);

  // Check if this is ActivityMonitor program
  if (program == "ActivityMonitor") {
    displayActivityMonitor();
  } else {
    displayTask();
    displayMouseId();

    // draw line to split on screen text 
    //drawLine(0,59,168,59, DISPLAY_BLACK);  
    drawLine(0,60,168,60, DISPLAY_BLACK);  

    // draw screen elements
    displayEnvironmental();
    displayBattery();
    displaySDCardStatus();
    displayCounters();
    displayIndicators();
    displayDateTime();
  }
  refresh();
}

void FED4::displayActivityMonitor() {
  // Use the same layout as normal FED4 display but replace counters and indicators
  displayTask();
  displayMouseId();

  // draw line to split on screen text 
  drawLine(0,59,168,59, DISPLAY_BLACK);  
  drawLine(0,60,168,60, DISPLAY_BLACK);  

  // draw screen elements (same as normal display)
  displayEnvironmental();
  displayBattery();
  displaySDCardStatus();
  
  // Replace displayCounters() with activity information
  displayActivityCounters();

  displayDateTime();
}

void FED4::displayActivityCounters() {
  setFont(&FreeSans9pt7b);
  setTextSize(1);
  setTextColor(DISPLAY_BLACK);
  
  // Clear all counter value areas with one white rectangle (same as displayCounters)
  fillRect(90, 68, 50, 78, DISPLAY_WHITE);  // Clear area for all counter values
  
  setCursor(6, 80);
  print("Activity ");
  setCursor(90, 80);
  print(motionCount);
  
  setCursor(6, 100);
  print("Activity% ");
  setCursor(90, 100);
  
  // Display motion percentage (calculated in real-time by motion() and pollSensors())
  printf("%.1f", motionPercentage);
  
  setCursor(6, 120);
  print("Seconds");
  setCursor(90, 120);

  // Initialize pollSensorsTimer if it hasn't been set yet
  if (pollSensorsTimer == 0) {
    pollSensorsTimer = millis();
  }

  //print elapsed seconds since pollSensorsTimer was reset
  print((millis() - pollSensorsTimer) / 1000);
  
  setCursor(6, 140);
  print("Uptime(h)");
  setCursor(90, 140);
  // Calculate total uptime in hours with 2 decimal places
  float uptimeHours = millis() / 1000.0 / 3600.0;
  printf("%.2f", uptimeHours);
}

void FED4::displayTask() {
  setFont(&FreeSans9pt7b);
  setTextSize(1);
  setTextColor(DISPLAY_BLACK);
  
  if (program == "SequenceLearning") {
    // Display sequence information
    setCursor(6, 35);
    print("Seq:");
    
    // Clear area for sequence display
    fillRect(40, 35, 120, 30, DISPLAY_WHITE);
    
    if (currentSequence.length() > 0) {
      setCursor(50, 35);
      
      // Display each character in the sequence (show entire required sequence)
      for (int i = 0; i < currentSequence.length(); i++) {
        char c = currentSequence[i];
        
        // Show the entire required sequence for the current level
        if (i < currentSequenceLevel) {
          // Required sequence items - all with black background, white text
          fillRect(43 + (i * 12), 20, 19, 19, DISPLAY_BLACK);
          setTextColor(DISPLAY_WHITE);
        } else {
          // Future level items - white background, black text
          fillRect(43 + (i * 12), 20, 19, 19, DISPLAY_WHITE);
          setTextColor(DISPLAY_BLACK);
        }
        
        setCursor(45 + (i * 12), 35);
        print(c);
      }
    }
  } else {
    // Display regular program name (limited to first 8 characters)
    setCursor(6, 35);
    print("Task: ");
    fillRect(50, 20, 110, 20, DISPLAY_WHITE); // Clear area for task name
    String shortProgram = program;
    if (shortProgram.length() > 8) {
      shortProgram = shortProgram.substring(0, 8);
    }
    print(shortProgram);
  }
}

void FED4::displayMouseId() {
  setFont(&FreeSans9pt7b);
  setTextSize(1);
  setTextColor(DISPLAY_BLACK);
  
  if (!sdCardAvailable) {
    // Show SD card error instead of MouseID
    setCursor(6, 54);
    fillRect(6, 41, 120, 16, DISPLAY_WHITE); // Clear area for mouse ID and label
    print("SD Card error!");
  } else {
    // Show normal MouseID
    setCursor(6, 54);
    print("MouseID: ");
    char idStr[6];  
    int mouseIdNum = mouseId.toInt();
    if (mouseIdNum == 0 && mouseId[0] != '0') {
      // Handle invalid conversion - just display the original string truncated to 4 chars
      snprintf(idStr, sizeof(idStr), "%.4s", mouseId.c_str());
    } else {
      snprintf(idStr, sizeof(idStr), "%04d", mouseIdNum % 10000);
    }
    fillRect(82, 41, 80, 16, DISPLAY_WHITE); // Clear area for mouse ID
    print(idStr);
  }
}

void FED4::displaySex(){
  setFont(&FreeSans9pt7b);
  setTextSize(1);
  setTextColor(DISPLAY_BLACK);
  setCursor(6, 71);
  print("Sex: ");
  fillRect(48, 58, 110, 16, DISPLAY_WHITE); // Clear area for sex name
  print(sex);
}

void FED4::displayStrain(){
  setFont(&FreeSans9pt7b);
  setTextSize(1);
  setTextColor(DISPLAY_BLACK);
  setCursor(6, 89);
  print("Strain: ");
  fillRect(60, 76, 160, 16, DISPLAY_WHITE); // Clear area for strain name
  print(strain);
}

void FED4::displayAge(){
  setFont(&FreeSans9pt7b);
  setTextSize(1);
  setTextColor(DISPLAY_BLACK);
  setCursor(6, 107);
  print("Age:");
  fillRect(42, 94, 160, 16, DISPLAY_WHITE); // Clear area for age name
  print(age);
  print(" months");
}

void FED4::displayEnvironmental(){
  //try to make text inverse white on black
  fillRect (0, 0, 144, 17, DISPLAY_BLACK);
  
  setFont(&Org_01);
  setTextSize(2);
  setTextColor(DISPLAY_WHITE);

  setCursor(5, 9);
  print((int)temperature); 
  drawCircle(30, 3, 2, DISPLAY_WHITE); 
  drawCircle(31, 3, 2, DISPLAY_WHITE); 
  setCursor(35, 9);
  print("C");
  
  // Add speaker muted icon if audio is silenced
  if (audioSilenced) {
    setCursor(55, 9);
    print("X"); // X means no audio
  }
}

void FED4::displayBattery(){
  //battery graphic
  fillRect (80, 1, 18, 10, DISPLAY_WHITE); //body
  fillRect (82, 3, 14, 6, DISPLAY_BLACK); //body
  
  fillRect (99, 3, 2, 6, DISPLAY_WHITE);   //terminal

  fillRect (82, 2, (int)((cellVoltage)/7), 8, DISPLAY_WHITE);  //fill

  //battery text
  setFont(&Org_01);
  setTextSize(2);
  setTextColor(DISPLAY_WHITE);
  
  setCursor(105, 9);
  print(cellVoltage, 1);
  print("V");
}

void FED4::displaySDCardStatus() {

}

void FED4::displayCounters()
{
  setFont(&FreeSans9pt7b);
  setTextSize(1);
  setTextColor(DISPLAY_BLACK);
  
  // Clear all counter value areas with one white rectangle
  fillRect(90, 68, 50, 78, DISPLAY_WHITE);  // Clear area for all counter values
  
  setCursor(30, 80);
  print("Left: ");
  setCursor(90, 80);
  print(leftCount);
  setCursor(30, 100);
  print("Center: ");
  setCursor(90, 100);
  print(centerCount);
  setCursor(30, 120);
  print("Right:  ");
  setCursor(90, 120);
  print(rightCount);
  setCursor(30, 140);
  print("Pellets:");
  setCursor(90, 140);
  print(pelletCount);
}

void FED4::displayIndicators(){
  //TODO: add indicators for when touch flags are set

  //Left 
  fillCircle(17, 75, 5, DISPLAY_WHITE); 
  drawCircle(17, 75, 5, DISPLAY_BLACK);
  if (leftTouch) {
    fillCircle(17, 75, 5, DISPLAY_BLACK); 
  }

  //Center
  fillCircle(17, 95, 5, DISPLAY_WHITE); 
  drawCircle(17, 95, 5, DISPLAY_BLACK);
  if (centerTouch) {
    fillCircle(17, 95, 5, DISPLAY_BLACK); 
  }

  //Right
  fillCircle(17, 115, 5, DISPLAY_WHITE);
  drawCircle(17, 115, 5, DISPLAY_BLACK);
  if (rightTouch) { 
    fillCircle(17, 115, 5, DISPLAY_BLACK); 
  }

  //Pellets 
  fillCircle(17, 135, 5, DISPLAY_WHITE);
  drawCircle(17, 135, 5, DISPLAY_BLACK);
  if (pelletPresent) {
    fillCircle(17, 135, 5, DISPLAY_BLACK); 
  }
}

void FED4::displayDateTime() {
  setFont(&Org_01);
  setTextSize(2);
  setTextColor(DISPLAY_WHITE);

  // Print date and time at bottom of the screen
  fillRect(0, 146, 144, 22, DISPLAY_BLACK);
  DateTime current = rtc.now();
  
  // Buffer for formatting time
  char timeStr[6];  // HH:MM\0
  char dateStr[9];  // MM.DD.YY\0
  
  // Format date string
  snprintf(dateStr, sizeof(dateStr), "%02d.%02d.%02d", 
           current.month(), 
           current.day(), 
           current.year() - 2000);
           
  // Format time string
  snprintf(timeStr, sizeof(timeStr), "%02d:%02d", 
           current.hour(), 
           current.minute());

  // Display formatted strings
  setCursor(5, 160);
  print(dateStr);
  
  setCursor(94, 160);
  print(timeStr);
}

// Displays a low battery warning with an icon and message
void FED4::displayLowBatteryWarning() {
    clearDisplay();
    setFont(&FreeSans9pt7b);
    setTextSize(1);
    setTextColor(DISPLAY_BLACK);
    
    // Draw battery outline (x=40, y=40, width=60, height=30)
    int bx = 40, by = 40, bw = 60, bh = 30;
    drawRect(bx, by, bw, bh, DISPLAY_BLACK); // Battery body
    fillRect(bx + bw, by + 8, 6, 14, DISPLAY_BLACK); // Battery terminal
    
    // Draw empty battery (just outline, no fill)
    // Draw exclamation mark inside battery
    int ex = bx + bw/2 - 2;
    int ey = by + 6;
    fillRect(ex, ey, 4, 12, DISPLAY_BLACK); // vertical bar
    fillRect(ex, ey + 16, 4, 4, DISPLAY_BLACK); // dot
    
    // Draw warning text
    setCursor(10, by + bh + 30);
    print("LOW BATTERY");
    setCursor(12, by + bh + 50);
    print("Please charge!");
    refresh();
}

/**
 * Initializes the Sharp Memory Display
 * 
 * @return bool - true if initialization successful, false if buffer allocation fails
 * 
 * This function:
 * - Sets up the display CS pin and SPI bit order
 * - Allocates display buffer memory
 * - Sends initial clear command to display
 * - Configures default display settings (rotation, font, text properties)
 * - Performs initial refresh
 */
bool FED4::initializeDisplay()
{
    pinMode(DISPLAY_CS, OUTPUT);
    digitalWrite(DISPLAY_CS, LOW); // Display inactive = LOW
    SPI.setBitOrder(LSBFIRST);

    // Initialize the display buffer
    if (displayBuffer)
    {
        free(displayBuffer);
        displayBuffer = nullptr;
    }
    uint16_t bufferSize = (DISPLAY_WIDTH * DISPLAY_HEIGHT) / 8;
    displayBuffer = (uint8_t *)malloc(bufferSize);
    if (!displayBuffer)
    {
        Serial.println("Failed to allocate display buffer");
        return false;
    }
    memset(displayBuffer, 0xff, bufferSize);

    vcom = false;

    // Initialize display with a clear command
    SPI.setBitOrder(LSBFIRST);
    digitalWrite(DISPLAY_CS, HIGH); // Select display

    uint8_t cmd = SHARPMEM_BIT_WRITECMD | SHARPMEM_BIT_CLEAR;
    if (vcom)
        cmd |= SHARPMEM_BIT_VCOM;
    vcom = !vcom;

    SPI.transfer(cmd);
    SPI.transfer(0x00); // Required trailing byte

    digitalWrite(DISPLAY_CS, LOW); // Deselect display

    delay(1); // Give display time to process clear command

    setRotation(2);
    setFont(&FreeSans9pt7b);
    setTextSize(1);
    setTextColor(DISPLAY_BLACK);
    setTextWrap(false);

    refresh(); // Initial refresh to ensure display is ready
    return true;
}

void FED4::sendDisplayCommand(uint8_t cmd)
{
    SPI.setBitOrder(LSBFIRST);
    digitalWrite(DISPLAY_CS, HIGH); // Select display (active HIGH)

    // Toggle VCOM
    cmd |= SHARPMEM_BIT_WRITECMD;
    if (vcom)
    {
        cmd |= SHARPMEM_BIT_VCOM;
    }
    vcom = !vcom;

    SPI.transfer(cmd);

    digitalWrite(DISPLAY_CS, LOW); // Deselect display
}

void FED4::clearDisplay()
{
    sendDisplayCommand(SHARPMEM_BIT_CLEAR);
    delay(1); // Wait for the clear to complete
    memset(displayBuffer, 0xff, (DISPLAY_WIDTH * DISPLAY_HEIGHT) / 8);
}

void FED4::refresh()
{
    uint16_t i, currentline;

    SPI.setBitOrder(LSBFIRST);
    digitalWrite(DISPLAY_CS, HIGH);

    uint8_t cmd = SHARPMEM_BIT_WRITECMD;
    if (vcom)
    {
        cmd |= SHARPMEM_BIT_VCOM;
    }
    vcom = !vcom;

    SPI.transfer(cmd);

    uint8_t bytes_per_line = DISPLAY_WIDTH / 8;
    uint16_t totalbytes = (DISPLAY_WIDTH * DISPLAY_HEIGHT) / 8;

    // Use static buffer to avoid stack allocation on every call
    static uint8_t lineBuffer[22]; // Maximum size needed: bytes_per_line + 2 = 18 + 2 = 20, rounded up to 22

    // Send all lines
    for (i = 0; i < totalbytes; i += bytes_per_line)
    {
        // Send address byte (line number)
        currentline = ((i + 1) / (DISPLAY_WIDTH / 8)) + 1;
        lineBuffer[0] = currentline;

        // Copy display data for this line
        memcpy(lineBuffer + 1, displayBuffer + i, bytes_per_line);

        // Add end of line marker
        lineBuffer[bytes_per_line + 1] = 0x00;

        // Send the entire line at once
        for (uint8_t j = 0; j < bytes_per_line + 2; j++)
        {
            SPI.transfer(lineBuffer[j]);
        }
    }

    SPI.transfer(0x00);

    digitalWrite(DISPLAY_CS, LOW);
}

void FED4::drawPixel(int16_t x, int16_t y, uint16_t color)
{
    if ((x < 0) || (x >= DISPLAY_WIDTH) || (y < 0) || (y >= DISPLAY_HEIGHT))
        return;

    switch (rotation)
    {
    case 1:
        _swap_int16_t(x, y);
        x = DISPLAY_WIDTH - 1 - x;
        break;
    case 2:
        x = DISPLAY_WIDTH - 1 - x;
        y = DISPLAY_HEIGHT - 1 - y;
        break;
    case 3:
        _swap_int16_t(x, y);
        y = DISPLAY_HEIGHT - 1 - y;
        break;
    }

    if (color)
    {
        displayBuffer[(y * DISPLAY_WIDTH + x) / 8] |= pgm_read_byte(&set[x & 7]);
    }
    else
    {
        displayBuffer[(y * DISPLAY_WIDTH + x) / 8] &= pgm_read_byte(&clr[x & 7]);
    }
}

void FED4::startupAnimation(){
  setTextSize(5);
  setFont(&Org_01);
  setTextColor(DISPLAY_BLACK);

  const char* text = "FED4";  // Text to animate
  int textWidth = 28;         // Approximate width of each character in pixels
  int textX = 144;   // Start position off the screen (right side)
  int mouseX = 0;
  int centerX = (144 - strlen(text) * textWidth) / 2; // Center X position
  int textY = 60;        // Vertical height of the text

  while (textX > centerX) {
    // Clear only the buffer (not hardware) to prevent flickering
    // Avoid clearDisplay() which sends hardware commands - just clear buffer directly
    memset(displayBuffer, 0xff, (DISPLAY_WIDTH * DISPLAY_HEIGHT) / 8);

    //draw FED4
    fillRect(100, 92, 32, 20, DISPLAY_BLACK);    //FED4
    fillRect(112, 82, 16, 8, DISPLAY_BLACK);     //hopper
    fillCircle(108, 98, 3, DISPLAY_WHITE);       //poke 1
    fillCircle(124, 98, 3, DISPLAY_WHITE);       //poke 2
    fillCircle(116, 104, 2, DISPLAY_WHITE);       //poke 3

    // Draw the text sliding in from the right (single render to reduce flickering)
    setCursor(textX, textY);
    print(text);

    // Move the text to the left
    textX -= 2;  // Adjust the speed by changing this value
    mouseX += 1; // Adjust the speed of the mouse

    fillRoundRect (mouseX + 25, 92, 15, 10, 7, DISPLAY_BLACK);    //head
    fillRoundRect (mouseX + 22, 90, 8, 5, 3, DISPLAY_BLACK);      //ear
    fillRoundRect (mouseX + 30, 94, 1, 1, 1, DISPLAY_WHITE);      //eye

    //movement of the mouse
    if ((mouseX  / 10) % 2 == 0) {
      fillRoundRect (mouseX, 94, 32, 17, 10, DISPLAY_BLACK);      //body
      drawFastHLine(mouseX  - 8, 95, 18, DISPLAY_BLACK);           //tail
      drawFastHLine(mouseX  - 8, 96, 18, DISPLAY_BLACK);
      drawFastHLine(mouseX  - 14, 94, 8, DISPLAY_BLACK);
      drawFastHLine(mouseX  - 14, 95, 8, DISPLAY_BLACK);
      fillRoundRect (mouseX  + 22, 109, 8, 4, 3, DISPLAY_BLACK);    //front foot
      fillRoundRect (mouseX  , 107, 8, 6, 3, DISPLAY_BLACK);        //back foot
    }
    else {
      fillRoundRect (mouseX + 2, 92, 30, 17, 10, DISPLAY_BLACK);  //body
      drawFastHLine(mouseX - 6, 101, 18, DISPLAY_BLACK);            //tail
      drawFastHLine(mouseX - 6, 100, 18, DISPLAY_BLACK);
      drawFastHLine(mouseX - 12, 102, 8, DISPLAY_BLACK);
      drawFastHLine(mouseX - 12, 101, 8, DISPLAY_BLACK);
      fillRoundRect (mouseX  + 15, 109, 8, 4, 3, DISPLAY_BLACK);    //foot
      fillRoundRect (mouseX + 8, 107, 8, 6, 3, DISPLAY_BLACK);      //back foot
    }
    // Update the display
    refresh();
    delay(10);   // Increased delay to reduce flickering (was 1ms, now 10ms)
  }

  // Display the text in the center and hold
  setCursor(textX, textY);
  print(text);
  refresh();
  setTextSize(1);
}

void FED4::displayAudio() {
  setCursor(6, 125);
  print("Audio: ");
  print(audioSilenced ? "Off" : "On");
}

// Display initialization status message below startup animation
void FED4::displayInitStatus(const char* message) {
  setFont(&FreeSans9pt7b);
  setTextSize(1);
  setTextColor(DISPLAY_BLACK);
  
  // Clear area for status message (below FED4 logo, around y=100-130)
  fillRect(0, 125, 144, 100, DISPLAY_WHITE);
  
  // Display the initialization message
  setCursor(6, 135);
  print("Initializing: ");
  setCursor(6, 158);
  print(message);
  
  refresh();
}