#include "FS.h"
#include "SPIFFS.h"
 
#define FORMAT_SPIFFS_IF_FAILED true
 
void setup() {
  Serial.begin(115200);
  
  // 初始化SPIFFS
  if(!SPIFFS.begin(FORMAT_SPIFFS_IF_FAILED)){
    Serial.println("SPIFFS挂载失败");
    return;
  }
  
  // 获取文件系统信息
  Serial.printf("总空间: %d bytes\n", SPIFFS.totalBytes());
  Serial.printf("已用空间: %d bytes\n", SPIFFS.usedBytes());
  
  // 文件操作示例
  writeFile(SPIFFS, "/config.txt", "device_id=12345");
  readFile(SPIFFS, "/config.txt");
}
 
// 写入文件函数
void writeFile(fs::FS &fs, const char *path, const char *message) {
  File file = fs.open(path, FILE_WRITE);
  if(file.print(message)) {
    Serial.println("文件写入成功");
  }
  file.close();
}
 
// 读取文件函数  
void readFile(fs::FS &fs, const char *path) {
  File file = fs.open(path);
  while(file.available()) {
    Serial.write(file.read());
  }
  file.close();
}

#include <LittleFS.h>
 
void setup() {
  Serial.begin(115200);
  
  // LittleFS初始化
  if(!LittleFS.begin(true)){
    Serial.println("LittleFS挂载失败");
    return;
  }
  
  // 创建多级目录
  createDirRecursive("/system/config/network");
  
  // 原子写入操作
  atomicWrite("/system/config/network/wifi.txt", "ssid=MyWiFi\npassword=123456");
  
  // 文件系统信息
  printFSInfo();
}
 
// 递归创建目录
void createDirRecursive(const char *path) {
  char *pathCopy = strdup(path);
  char *ptr = strchr(pathCopy, '/');
  
  while(ptr != NULL) {
    *ptr = '\0';
    if(!LittleFS.exists(pathCopy)) {
      LittleFS.mkdir(pathCopy);
    }
    *ptr = '/';
    ptr = strchr(ptr + 1, '/');
  }
  free(pathCopy);
}
 
// 原子写入（避免数据损坏）
void atomicWrite(const char *path, const char *content) {
  String tempPath = String(path) + ".tmp";
  
  File tempFile = LittleFS.open(tempPath.c_str(), FILE_WRITE);
  tempFile.print(content);
  tempFile.close();
  
  // 原子重命名
  LittleFS.rename(tempPath.c_str(), path);
}

// 使用缓冲区优化大文件操作
void optimizedFileCopy(const char *src, const char *dst) {
  const size_t bufferSize = 4096;  // 4KB缓冲区
  uint8_t buffer[bufferSize];
  
  File source = LittleFS.open(src, FILE_READ);
  File destination = LittleFS.open(dst, FILE_WRITE);
  
  while(source.available()) {
    size_t bytesRead = source.read(buffer, bufferSize);
    destination.write(buffer, bytesRead);
  }
  
  source.close();
  destination.close();
}
 
// 批量文件操作
void batchFileOperations() {
  // 使用事务性操作提高性能
  LittleFS.beginTransaction();
  
  for(int i = 0; i < 100; i++) {
    String filename = "/data/sensor_" + String(i) + ".txt";
    writeFile(LittleFS, filename.c_str(), "sensor data");
  }
  
  LittleFS.endTransaction();
}

#include "SD.h"
#include "SPI.h"
 
#define SD_CS 13
 
void setup() {
  Serial.begin(115200);
  
  // SD卡初始化
  if(!SD.begin(SD_CS)){
    Serial.println("SD卡挂载失败");
    return;
  }
  
  uint8_t cardType = SD.cardType();
  if(cardType == CARD_NONE){
    Serial.println("未检测到SD卡");
    return;
  }
  
  Serial.print("SD卡类型: ");
  switch(cardType){
    case CARD_MMC: Serial.println("MMC"); break;
    case CARD_SD: Serial.println("SDSC"); break;
    case CARD_SDHC: Serial.println("SDHC"); break;
    default: Serial.println("未知"); break;
  }
  
  // 获取容量信息
  uint64_t cardSize = SD.cardSize() / (1024 * 1024);
  Serial.printf("SD卡大小: %lluMB\n", cardSize);
}
 
// 大数据文件处理
void processLargeData() {
  File dataFile = SD.open("/sensor_data.csv", FILE_APPEND);
  
  // 写入CSV格式数据
  dataFile.print("timestamp,temperature,humidity\n");
  for(int i = 0; i < 1000; i++) {
    dataFile.printf("%lu,%.2f,%.2f\n", 
                   millis(), 
                   random(200, 300) / 10.0, 
                   random(300, 800) / 10.0);
  }
  
  dataFile.close();
}

class DeviceConfig {
private:
  const char* configPath = "/config/device.json";
  
public:
  bool saveConfig(const String& jsonConfig) {
    if(!LittleFS.begin(true)) return false;
    
    // 确保配置目录存在
    if(!LittleFS.exists("/config")) {
      LittleFS.mkdir("/config");
    }
    
    // 原子写入配置
    atomicWrite(configPath, jsonConfig.c_str());
    LittleFS.end();
    return true;
  }
  
  String loadConfig() {
    if(!LittleFS.begin(false)) return "";
    
    if(LittleFS.exists(configPath)) {
      File configFile = LittleFS.open(configPath, FILE_READ);
      String content = configFile.readString();
      configFile.close();
      LittleFS.end();
      return content;
    }
    
    LittleFS.end();
    return "";
  }
};

class DataLogger {
private:
  fs::FS* filesystem;
  const char* logBasePath = "/logs";
  
public:
  DataLogger(fs::FS& fs) : filesystem(&fs) {}
  
  bool logSensorData(const String& sensorName, float value) {
    String dateStr = getDateString();
    String filePath = String(logBasePath) + "/" + dateStr + "/" + sensorName + ".csv";
    
    // 创建日期目录
    String datePath = String(logBasePath) + "/" + dateStr;
    if(!filesystem->exists(datePath.c_str())) {
      filesystem->mkdir(datePath.c_str());
    }
    
    // 写入数据
    File logFile = filesystem->open(filePath.c_str(), FILE_APPEND);
    if(logFile) {
      logFile.printf("%lu,%.2f\n", millis(), value);
      logFile.close();
      return true;
    }
    return false;
  }
};