AudioSource.h

#pragma once
#include "AudioTools/CoreAudio/AudioBasic/Collections/Vector.h"
#include "AudioTools/CoreAudio/AudioBasic/Str.h"
#include "AudioTools/CoreAudio/AudioMetaData/AbstractMetaData.h"
 
namespace audio_tools {
 
class AudioSource {
 public:
  virtual bool begin() = 0;
 
  virtual Stream* nextStream(int offset) = 0;
 
  virtual Stream* previousStream(int offset) { return nextStream(-offset); };
 
  virtual Stream* selectStream(int index) {
    LOGE("Not Supported!");
    return nullptr;
  }
 
  virtual Stream* setIndex(int index) { return selectStream(index); }
 
  virtual int index() { return -1; }
 
  virtual Stream* selectStream(const char* path) = 0;
 
  virtual void setTimeoutAutoNext(int millisec) {
    timeout_auto_next_value = millisec;
  }
 
  virtual int timeoutAutoNext() { return timeout_auto_next_value; }
 
  // only the ICYStream supports this
  virtual bool setMetadataCallback(void (*fn)(MetaDataType info,
                                              const char* str, int len),
                                   ID3TypeSelection sel = SELECT_ICY) {
    return false;
  }
 
  virtual void setTimeout(int millisec) {};
 
  virtual bool isAutoNext() { return is_auto_next; }
 
  // Prevent automatic move to the next stream
  virtual void setAutoNext(bool flag) { is_auto_next = flag; }
 
  Stream* operator[](int idx) { return setIndex(idx); }
 
  virtual const char* toStr() { return nullptr; }
 
 protected:
  int timeout_auto_next_value = 500;
  bool is_auto_next = true;
};
 
class AudioSourceCallback : public AudioSource {
 public:
  AudioSourceCallback() {}
 
  AudioSourceCallback(Stream* (*nextStreamCallback)(int offset),
                      void (*onStartCallback)() = nullptr) {
    TRACED();
    this->onStartCallback = onStartCallback;
    this->nextStreamCallback = nextStreamCallback;
  }
 
  virtual bool begin() override {
    TRACED();
    if (onStartCallback != nullptr) onStartCallback();
    return true;
  };
 
  virtual Stream* nextStream(int offset) override {
    TRACED();
    return nextStreamCallback == nullptr ? nullptr : nextStreamCallback(offset);
  }
 
  virtual Stream* selectStream(int index) override {
    LOGI("selectStream: %d", index);
    if (indexStreamCallback == nullptr) {
      LOGI("setCallbackSelectStream not provided");
      if (index > 0) {
        begin();
        return nextStream(index);
      } else {
        // nextStream(0) will return the directory but we need a file
        return nextStream(1);
      }
    }
    return indexStreamCallback(index);
  }
  virtual Stream* selectStream(const char* path) override {
    this->path = path;
    return indexStreamCallback == nullptr ? nullptr : indexStreamCallback(-1);
  };
 
  void setCallbackOnStart(void (*callback)()) { onStartCallback = callback; }
 
  void setCallbackNextStream(Stream* (*callback)(int offset)) {
    nextStreamCallback = callback;
  }
 
  void setCallbackSelectStream(Stream* (*callback)(int idx)) {
    indexStreamCallback = callback;
  }
 
  virtual bool isAutoNext() override { return auto_next; }
 
  virtual void setAutoNext(bool a) { auto_next = a; }
 
  virtual const char* getPath() { return path; }
 
 protected:
  void (*onStartCallback)() = nullptr;
  bool auto_next = true;
  Stream* (*nextStreamCallback)(int offset) = nullptr;
  Stream* (*indexStreamCallback)(int index) = nullptr;
  const char* path = nullptr;
};
 
struct FileEntry {
  int path_index;  // Index into shared path registry
  Str name;
 
  FileEntry() : path_index(-1) {}
 
  FileEntry(int pathIdx, const char* fileName) : path_index(pathIdx) {
    name.set(fileName);
  }
};
 
class PathNamesRegistry {
 public:
  virtual void addName(const char* nameWithPath) = 0;
};
 
class NamePrinter : public Print {
 public:
  NamePrinter(PathNamesRegistry& dataSource, const char* prefix = nullptr)
      : dataSource(dataSource), prefix(prefix) {}
  void setPrefix(const char* prefix) { this->prefix = prefix; }
  size_t write(uint8_t ch) override {
    if (ch == '\n' || ch == '\r') {
      // End of line - process the accumulated line
      if (line_buffer.length() > 0) {
        line_buffer.trim();
        if (prefix != nullptr) {
          // Prepend prefix if set
          Str name{prefix};
          name.add("/");
          name.add(line_buffer.c_str());
          LOGD("adding '%s'", name.c_str());
          dataSource.addName(name.c_str());
        } else {
          // Add line as is
          LOGD("adding '%s'", line_buffer.c_str());
          dataSource.addName(line_buffer.c_str());
        }
        line_buffer.clear(false);
      }
      return 1;
    } else {
      // Accumulate characters
      line_buffer.add((char)ch);
      return 1;
    }
  }
 
  size_t write(const uint8_t* buffer, size_t size) override {
    for (size_t i = 0; i < size; i++) {
      write(buffer[i]);
    }
    return size;
  }
 
  void flush() override {
    if (line_buffer.length() > 0) {
      dataSource.addName(line_buffer.c_str());
      line_buffer.clear();
    }
  }
 
 private:
  PathNamesRegistry& dataSource;
  Str line_buffer{200};  // Buffer to accumulate characters for each line
  const char* prefix = nullptr;
};
 
template <typename FileType>
class AudioSourceVector : public AudioSource, public PathNamesRegistry {
 public:
  typedef FileType* (*FileToStreamCallback)(const char* path,
                                            FileType& oldFile);
 
  AudioSourceVector() = default;
 
  AudioSourceVector(FileToStreamCallback callback)
      : nameToStreamCallback(callback) {}
 
  bool begin() override {
    TRACED();
    current_index = 0;
    current_stream = nullptr;
    return true;
  }
 
  virtual FileType* nextStream(int offset) override {
    TRACED();
    if (files.empty()) return nullptr;
 
    current_index += offset;
    // Wrap around if out of bounds
    if (current_index < 0) {
      current_index = files.size() - 1;
    } else if (current_index >= (int)files.size()) {
      current_index = 0;
    }
 
    return selectStream(current_index);
  }
 
  virtual FileType* selectStream(int index) override {
    TRACED();
    if (files.empty() || index < 0 || index >= (int)files.size()) {
      LOGE("Invalid index: %d (size: %d)", index, files.size());
      return nullptr;
    }
 
    current_index = index;
    Str fullPath = getFullPath(index);
    LOGI("selectStream: %d -> %s", index, fullPath.c_str());
 
    if (nameToStreamCallback) {
      current_stream = nameToStreamCallback(fullPath.c_str(), getCurrentFile());
      return current_stream;
    }
 
    LOGE("No file to stream callback set!");
    return nullptr;
  }
 
  virtual FileType* selectStream(const char* path) override {
    TRACED();
    if (path == nullptr) return nullptr;
 
    int idx = indexOf(path);
    if (idx >= 0) {
      return selectStream(idx);
    }
 
    LOGE("File not found: %s", path);
    return nullptr;
  }
 
  virtual int index() override { return current_index; }
 
  int indexOf(const char* path) {
    if (path == nullptr) return -1;
 
    // Find the file by path
    for (int i = 0; i < (int)files.size(); i++) {
      Str fullPath = getFullPath(i);
      if (fullPath.equals(path)) {
        return i;
      }
    }
    return -1;
  }
 
  void addName(const char* nameWithPath) override {
    TRACED();
    if (nameWithPath == nullptr) return;
    LOGI("addName: '%s'", nameWithPath);
 
    // Split path and name
    StrView nameWithPathStr(nameWithPath);
    int lastSlashPos = nameWithPathStr.lastIndexOf("/");
    int len = nameWithPathStr.length();
 
    Str pathStr;
    Str nameStr;
    if (lastSlashPos < 0) {
      // No path, just name
      pathStr.set("");
      nameStr.set(nameWithPath);
    } else {
      // Split into path and name
      pathStr.substring(nameWithPath, 0, lastSlashPos);
      nameStr.substring(nameWithPath, lastSlashPos + 1, len);
    }
 
    // Find or add path to registry
    int pathIndex = findOrAddPath(pathStr.c_str());
 
    // Create file entry with path index
    FileEntry entry{pathIndex, nameStr.c_str()};
    files.push_back(entry);
 
  }
 
  bool deleteName(const char* nameWithPath) {
    TRACED();
    if (nameWithPath == nullptr) return false;
    
    int idx = indexOf(nameWithPath);
    if (idx >= 0) {
      LOGI("deleteName: '%s' at index %d", nameWithPath, idx);
      return deleteIndex(idx);
    }
    
    LOGW("deleteName: File not found: '%s'", nameWithPath);
    return false;
  }
 
  bool deleteIndex(size_t idx) {
    TRACED();
    if (idx >= files.size()) {
      LOGW("deleteIndex: Invalid index: %d (size: %d)", (int)idx, files.size());
      return false;
    }
    
    LOGI("deleteIndex: Removing file at index %d", (int)idx);
    files.erase(files.begin() + idx);
    
    // Adjust current_index if necessary
    if (current_index >= (int)idx) {
      current_index--;
      if (current_index < 0 && !files.empty()) {
        current_index = 0;
      }
    }
    
    return true;
  }
 
  template <typename T, size_t N>
  void addNames(T (&nameArray)[N]) {
    for (size_t i = 0; i < N; i++) {
      addName(nameArray[i]);
    }
  }
 
  void clear() {
    files.clear();
    path_registry.clear();
    current_index = 0;
    current_stream = nullptr;
  }
 
  int size() { return files.size(); }
 
  bool isEmpty() { return files.empty(); }
 
  void setNameToStreamCallback(FileToStreamCallback callback) {
    nameToStreamCallback = callback;
  }
 
  FileType& getCurrentFile() {
    if (current_stream) {
      return *current_stream;
    }
    static FileType empty;
    return empty;
  }
 
  virtual const char* toStr() override {
    if (current_index >= 0 && current_index < (int)files.size()) {
      current_path = getFullPath(current_index);
      return current_path.c_str();
    }
    return nullptr;
  }
 
  const char* name(int index) { return getFullPath(index).c_str(); }
 
 protected:
  Vector<FileEntry> files;    // List of all files
  Vector<Str> path_registry;  // Shared registry of unique paths
  int current_index = 0;
  FileType* current_stream = nullptr;
  FileToStreamCallback nameToStreamCallback = nullptr;
  Str current_path;  // Cache for toStr() method
 
  int findOrAddPath(const char* path) {
    if (path == nullptr) path = "";
 
    // Search for existing path
    for (int i = 0; i < (int)path_registry.size(); i++) {
      if (strcmp(path_registry[i].c_str(), path) == 0) {
        return i;  // Found existing path
      }
    }
 
    // Path not found, add new one
    Str newPath;
    newPath.set(path);
    path_registry.push_back(newPath);
    return path_registry.size() - 1;
  }
 
  FileEntry& getFileEntry(int index) const { return files[index]; }
 
  Str getFullPath(int index) {
    if (index < 0 || index >= (int)files.size()) {
      return Str();
    }
 
    FileEntry& entry = getFileEntry(index);
 
    // Get path
    Str result;
    if (entry.path_index >= 0 && entry.path_index < (int)path_registry.size()) {
      result = path_registry[entry.path_index].c_str();
    }
    // delimite with /
    if (!result.endsWith("/") && !entry.name.startsWith("/")) {
      result.add("/");
    }
    // add name
    result.add(entry.name.c_str());
 
    return result;
  }
 
  const char* getPath(int pathIndex) {
    if (pathIndex >= 0 && pathIndex < (int)path_registry.size()) {
      return path_registry[pathIndex].c_str();
    }
    return "";
  }
};
 
template <typename FileType>
class AudioSourceArray : public AudioSource {
 public:
  typedef FileType* (*FileToStreamCallback)(const char* path, FileType& file);
 
  AudioSourceArray() = default;
 
  template <size_t N>
  AudioSourceArray(const char* (&nameArray)[N], FileToStreamCallback callback)
      : file_array(nameArray), array_size(N), nameToStreamCallback(callback) {}
 
  AudioSourceArray(const char* const* nameArray, size_t size,
                   FileToStreamCallback callback)
      : file_array(nameArray),
        array_size(size),
        nameToStreamCallback(callback) {}
 
  virtual bool begin() override {
    TRACED();
    current_index = 0;
    current_stream = nullptr;
    return true;
  }
 
  virtual FileType* nextStream(int offset) override {
    TRACED();
    if (array_size == 0) return nullptr;
 
    current_index += offset;
    // Wrap around if out of bounds
    if (current_index < 0) {
      current_index = array_size - 1;
    } else if (current_index >= (int)array_size) {
      current_index = 0;
    }
 
    return selectStream(current_index);
  }
 
  virtual FileType* selectStream(int index) override {
    TRACED();
    if (array_size == 0 || index < 0 || index >= (int)array_size) {
      LOGE("Invalid index: %d (size: %d)", index, array_size);
      return nullptr;
    }
 
    current_index = index;
    const char* filePath = file_array[index];
    LOGI("selectStream: %d -> %s", index, filePath);
 
    if (nameToStreamCallback && filePath) {
      current_stream = nameToStreamCallback(filePath, getCurrentFile());
      return current_stream;
    }
 
    LOGE("No file to stream callback set or invalid file path!");
    return nullptr;
  }
 
  virtual FileType* selectStream(const char* path) override {
    TRACED();
    if (path == nullptr) return nullptr;
 
    int idx = indexOf(path);
    if (idx >= 0) {
      return selectStream(idx);
    }
 
    LOGE("File not found: %s", path);
    return nullptr;
  }
 
  virtual int index() override { return current_index; }
 
  int indexOf(const char* path) {
    if (path == nullptr) return -1;
 
    // Find the file by path
    for (int i = 0; i < (int)array_size; i++) {
      const char* filePath = file_array[i];
      if (filePath && StrView(path).equals(filePath)) {
        return i;
      }
    }
    return -1;
  }
 
  template <size_t N>
  void setArray(const char* (&nameArray)[N]) {
    file_array = nameArray;
    array_size = N;
    current_index = 0;
  }
 
  void setArray(const char* const* nameArray, size_t size) {
    file_array = nameArray;
    array_size = size;
    current_index = 0;
  }
 
  int size() const { return array_size; }
 
  bool isEmpty() const { return array_size == 0; }
 
  void setNameToStreamCallback(FileToStreamCallback callback) {
    nameToStreamCallback = callback;
  }
 
  FileType& getCurrentFile() {
    if (current_stream) {
      return *current_stream;
    }
    static FileType empty;
    return empty;
  }
 
  const char* getFilePath(int index) const {
    if (index >= 0 && index < (int)array_size && file_array) {
      return file_array[index];
    }
    return nullptr;
  }
 
  virtual const char* toStr() override {
    if (current_index >= 0 && current_index < (int)array_size && file_array) {
      return file_array[current_index];
    }
    return nullptr;
  }
 
  const char* name(int index) { return getFilePath(index); }
 
 protected:
  const char* const* file_array = nullptr;  // Pointer to array of const char*
  size_t array_size = 0;
  int current_index = 0;
  FileType* current_stream = nullptr;
  FileToStreamCallback nameToStreamCallback = nullptr;
};
 
}  // namespace audio_tools