#include <stdio.h>
#include <string.h>
#include "esp_vfs_fat.h"
#include "driver/sdmmc_host.h"
#include "sdmmc_cmd.h"

#define MOUNT_PATH "/sdcard"   // Diretório montado na FAT

// Configuração dos pines SPI para a SD Card (ajuste conforme seu hardware)
const sdmmc_slot_t slot = SDMMC_SLOT_1;
const int miso = 2;           // Altere conforme sua configuração
const int mosi = 3;           // Altere conforme sua configuração
const int sclk = 4;           // Altere conforme sua configuração
const int cs   = 5;           // Altere conforme sua configuração

void app_main(void)
{
    // Configurar os pines SPI para a SD Card (ajuste conforme seu hardware)
    sdmmc_general_config_t cfg = {
        .miso = &sdio_host.miso,
        .mosi = &sdio_host.mosi,
        .sclk = &sdio_host.sclk,
        .cs   = &sdio_host.cs
    };
    
    // Configurações específicas do seu hardware (ajuste aqui)
    cfg.flags |= SDMMC_SCLK_SRC_EXTERNAL;
    cfg.tuner.gpio = -1;       // Não usar se tiver capacitor externo
    sdmmc_slot_config_t slot_cfg = {
        .flags = SDMMC_SLOT_UTILITY_POWER_ON,   // Descomente se precisar de utility power
        .host = slot,
        .pin_num_miso = miso,
        .pin_num_mosi = mosi,
        .pin_num_sclk = sclk,
        .gpio_cs = cs          // Altere conforme sua configuração
    };

    // Montar o cartão SD no sistema de arquivos FATFS
    const char* partition_label = "sdcard";
    sdmmc_card_t* card;
    esp_err_t ret = ESP_FAIL;

    // Configurar o host SPI para a SD Card (ajuste os pines conforme seu hardware)
    sdmmc_host_init(&cfg);
    
    // Inicializar o slot
    ret = sdmmc_slot_config(host, &slot_cfg);

    if (ret != ESP_OK) {
        printf("Erro ao configurar o slot: %d\n", ret);
        return;
    }

    // Buscar a SD Card na linha SPI
    card = NULL;
    ret = sdmmc_cid_init(slot, &card);  // Usando CID para inicialização simples
    
    if (ret != ESP_OK || card == NULL) {
        printf("Erro ao encontrar o cartão: %d\n", ret);
        return;
    }

    // Montar a partição
    ret = esp_vfs_fat_mount_path(partition_label, MOUNT_PATH);

    if (ret != ESP_OK) {
        printf("Erro ao montar o sistema de arquivos: %d\n", ret);
        return;
    }

    // Exemplo de escrita e leitura de um arquivo
    const char* filename = "dados.txt";  // Nome do arquivo
    
    // Escrevendo dados no arquivo
    FILE *file = fopen("/sdcard/dados.txt", "w+");
    if (file == NULL) {
        printf("Erro ao abrir o arquivo para escrita.\n");
        goto unmount_and_exit;
    }

    const char* text_to_write = "Hello SD Card!";
    size_t bytes_written = fwrite(text_to_write, sizeof(char), strlen(text_to_write)+1, file);
    
    if (bytes_written == 0) {
        printf("Erro ao escrever no arquivo.\n");
    } else {
        printf("Escrito %d caracteres no arquivo.\n", (int)bytes_written);
    }

    fclose(file);

    // Lendo o arquivo
    char buffer[50];
    file = fopen("/sdcard/dados.txt", "r");
    if (file == NULL) {
        printf("Erro ao abrir o arquivo para leitura.\n");
        goto unmount_and_exit;
    }

    size_t bytes_read = fread(buffer, sizeof(char), sizeof(buffer)-1, file);
    
    if (bytes_read == 0) {
        printf("Nenhum dado foi lido do arquivo.\n");
    } else {
        buffer[bytes_read] = '\0'; // Garantir terminação de string
        printf("Conteúdo do arquivo:\n%s\n", buffer);
    }

    fclose(file);

unmount_and_exit:
    // Desmontar o cartão SD antes do desligamento
    esp_vfs_unmount(MOUNT_PATH);
    
    if (card != NULL) {
        sdmmc_card_free(host, card);  // Libera a estrutura da SD Card
    }
}


/*
**Passos importantes para configuração:**

1. **Menuconfig Setup:**
   - Acesse o menuconfig do projeto (`idf.py menuconfig`)
   - Configure os pines corretamente na seção `Component "SPIFFS Example"` > `Configuration`:
     ```
     CONFIG_EXAMPLE_MOSI_GPIO=<GPIO do MOSI>
     CONFIG_EXAMPLE_MISO_GPIO=<GPIO do MISO>
     CONFIG_EXAMPLE_CLK_GPIO=<GPIO do SCLK>
     CONFIG_EXAMPLE_CS_GPIO=<GPIO do CS>
     ```

2. **Hardware Considerações:**
   - Verifique que sua placa tem os pines SPI configurados (MOSI, MISO, SCLK) e o chip select liberado
   - Para ESP32/ESP8266:
     - ESP32 usa SPI1 (GPIOs 4 para MOSI/MISO/SCLK padrão)
     - ESP8266 pode usar diferentes pines

3. **Compilação:**
   - Certifique-se de incluir a biblioteca `sdmmc` no menuconfig
   ```
   CONFIG_SPIRAM_SUPPORT=y   # Se estiver usando SRAM externa
   CONFIG_SDMMC_USE_STATIC=y # Para evitar conflito com os pines configurados
   ```

4. **Funcionalidades:**
   - Montagem automática do sistema de arquivos FATFS na inicialização
   - Escrita e leitura de texto simples em um arquivo
   - Verificação básica de erros

**Notas importantes:**

- Ajuste os pines no código conforme sua configuração real (linhas 14-17)
- Adicione tratamento de erro mais detalhado conforme necessário
- Para ESP8266, use a biblioteca `sdmmc` específica do framework
- Arquivos são armazenados na raiz da partição FATFS montada

**Requisitos:**
```bash
idf.py set-project-properties --idf-version 4.0+ --board-name esp32devkitc
```

Este exemplo mostra como:
1. Configurar os pines de comunicação SPI com a SD Card
2. Montar o sistema de arquivos FATFS na memória externa
3. Realizar operações básicas de escrita e leitura de texto

Lembre-se de adaptar as configurações para seu hardware específico, especialmente os números GPIOs e eventuais ajustes no tempo de inicialização da SD Card (como 
uso de capacitor externo).

*/