From 8adc8662fe156d556b1e6bdebae3ea3c5cbaac72 Mon Sep 17 00:00:00 2001
From: Steva0 <michele.stevanin@gmail.com>
Date: Mon, 19 May 2025 17:14:36 +0200
Subject: [PATCH 01/16] Aggiunto tutti i gli operatori==

---
 .gitignore                    |  2 +
 src/Media/Album.cpp           | 10 +++++
 src/Media/Album.h             |  1 +
 src/Media/AudioBook.cpp       |  9 ++++-
 src/Media/AudioBook.h         |  2 +-
 src/Media/Ebook.cpp           | 11 ++++--
 src/Media/Ebook.h             |  2 +-
 src/Media/Media.cpp           |  7 ++++
 src/Media/Media.h             |  2 +
 src/Media/Movie.cpp           |  8 ++++
 src/Media/Movie.h             |  1 +
 src/Media/Novel.cpp           | 11 ++++--
 src/Media/Novel.h             |  2 +-
 src/Media/Series.cpp          |  8 ++++
 src/Media/Series.h            |  1 +
 src/Memory/MediaContainer.cpp | 71 +++++++++++++++++++++++++++++++++++
 src/Memory/MediaContainer.h   | 61 ++++++++++++++++++++++++------
 17 files changed, 187 insertions(+), 22 deletions(-)
 create mode 100644 src/Memory/MediaContainer.cpp

diff --git a/.gitignore b/.gitignore
index 771d7a4..bdb5fa1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,6 +9,8 @@
 *.so.*
 *.dll
 *.dylib
+build
+checks.json
 
 # Qt-es
 object_script.*.Release
diff --git a/src/Media/Album.cpp b/src/Media/Album.cpp
index d20ecf3..4f3453c 100644
--- a/src/Media/Album.cpp
+++ b/src/Media/Album.cpp
@@ -16,4 +16,14 @@ const std::vector<std::string> &Album::getBandMembers() const {
   return band_members_;
 }
 const std::vector<std::string> &Album::getSongs() const { return songs_; }
+bool Album::operator==(const Media &other) const {
+  const Album *other_album = dynamic_cast<const Album *>(&other);
+  if (other_album) {
+    return Media::operator==(*other_album) && band_ == other_album->band_ &&
+           band_members_ == other_album->band_members_ &&
+           songs_ == other_album->songs_;
+  }
+  return false;
+}
+
 }  // namespace media
diff --git a/src/Media/Album.h b/src/Media/Album.h
index 99c802e..3839490 100644
--- a/src/Media/Album.h
+++ b/src/Media/Album.h
@@ -18,6 +18,7 @@ class Album : public Media {
   const std::string &getBand() const;
   const std::vector<std::string> &getBandMembers() const;
   const std::vector<std::string> &getSongs() const;
+  bool operator==(const Media &other) const override;
 };
 }  // namespace media
 #endif
diff --git a/src/Media/AudioBook.cpp b/src/Media/AudioBook.cpp
index b1aa6af..4a85455 100644
--- a/src/Media/AudioBook.cpp
+++ b/src/Media/AudioBook.cpp
@@ -12,8 +12,13 @@ AudioBook::AudioBook(const std::string& title, int publicationYear, const std::s
       narrator_(narrator), streamingService_(streamingService) {}
 
 
-void AudioBook::accept(IConstMediaVisitor& v) const {
-    v.visit(*this);
+bool AudioBook::operator==(const Media& other) const {
+    const AudioBook* otherAudioBook = dynamic_cast<const AudioBook*>(&other);
+    if (otherAudioBook) {
+        return Novel::operator==(*otherAudioBook) && narrator_ == otherAudioBook->narrator_ &&
+               streamingService_ == otherAudioBook->streamingService_;
+    }
+    return false;
 }
 
 std::string AudioBook::getNarrator() const {
diff --git a/src/Media/AudioBook.h b/src/Media/AudioBook.h
index ecb7c60..4b0bc09 100644
--- a/src/Media/AudioBook.h
+++ b/src/Media/AudioBook.h
@@ -17,7 +17,7 @@ class AudioBook : public Novel {
               unsigned int duration, const std::string& series, const std::string& isbn,
               const std::string& narrator, const std::string& streamingService);
 
-    void accept(IConstMediaVisitor& v) const override;
+    bool operator==(const Media& other) const override;
 
     std::string getNarrator() const;
     std::string getStreamingService() const;
diff --git a/src/Media/Ebook.cpp b/src/Media/Ebook.cpp
index 9a26700..c12bf2a 100644
--- a/src/Media/Ebook.cpp
+++ b/src/Media/Ebook.cpp
@@ -11,9 +11,14 @@ Ebook::Ebook(const std::string& title, int publicationYear, const std::string& l
             author, publisher, pages, series, isbn),
       fileSizeBytes_(fileSizeBytes), drm_(drm) {}
 
-void Ebook::accept(IConstMediaVisitor& v) const {
-    v.visit(*this);
-}
+bool Ebook::operator==(const Media& other) const {
+    const Ebook* otherEbook = dynamic_cast<const Ebook*>(&other);
+    if (otherEbook) {
+        return Novel::operator==(*otherEbook) && fileSizeBytes_ == otherEbook->fileSizeBytes_ &&
+               drm_ == otherEbook->drm_;
+    }
+    return false;
+}   
 
 unsigned int Ebook::getFileSizeBytes() const {
     return fileSizeBytes_;
diff --git a/src/Media/Ebook.h b/src/Media/Ebook.h
index 367f85b..7035703 100644
--- a/src/Media/Ebook.h
+++ b/src/Media/Ebook.h
@@ -17,7 +17,7 @@ class Ebook : public Novel {
           unsigned int pages, const std::string& series, const std::string& isbn,
           unsigned int fileSizeBytes, bool drm);
 
-    void accept(IConstMediaVisitor& v) const override;
+    bool operator==(const Media& other) const override;
 
     unsigned int getFileSizeBytes() const;
     bool hasDrm() const;
diff --git a/src/Media/Media.cpp b/src/Media/Media.cpp
index fbad213..9d732e6 100644
--- a/src/Media/Media.cpp
+++ b/src/Media/Media.cpp
@@ -14,6 +14,13 @@ Media::Media(const std::string &title, int release, const std::string &language,
 
 void Media::accept(IConstMediaVisitor &v) const {}
 
+bool Media::operator==(const Media &other) const {
+  return title_ == other.title_ && release_ == other.release_ &&
+         language_ == other.language_ && favourite_ == other.favourite_ &&
+         genres_ == other.genres_ && img_path_ == other.img_path_ &&
+         notes_ == other.notes_;
+}
+
 bool Media::open() {
   notes_ = "";
   std::cout<< "Media::open()" << std::endl;  
diff --git a/src/Media/Media.h b/src/Media/Media.h
index 2eb83c4..d743fe4 100644
--- a/src/Media/Media.h
+++ b/src/Media/Media.h
@@ -25,6 +25,8 @@ class Media : IMedia{
   
  public:
 
+  virtual bool operator==(const Media &other) const;
+  
   void accept(IConstMediaVisitor &) const override;
   bool open() override;
 
diff --git a/src/Media/Movie.cpp b/src/Media/Movie.cpp
index 1e7a3a1..026eb63 100644
--- a/src/Media/Movie.cpp
+++ b/src/Media/Movie.cpp
@@ -10,6 +10,14 @@ Movie::Movie(const std::string &title, int release, const std::string &language,
       cast_(cast),
       length_(length),
       universe_(universe) {}
+bool Movie::operator==(const Media &other) const {
+    const Movie *otherMovie = dynamic_cast<const Movie *>(&other);
+    if (otherMovie) {
+        return Media::operator==(*otherMovie) && cast_ == otherMovie->cast_ &&
+               length_ == otherMovie->length_ && universe_ == otherMovie->universe_;
+    }
+    return false;
+}
 const std::vector<std::string> &Movie::getCast() const { return cast_; }
 unsigned int Movie::getLength() const { return length_; }
 const std::string &Movie::getUniverse() const { return universe_; }
diff --git a/src/Media/Movie.h b/src/Media/Movie.h
index 9f23113..0c736dc 100644
--- a/src/Media/Movie.h
+++ b/src/Media/Movie.h
@@ -19,6 +19,7 @@ class Movie : public Media {
         const std::string &img_path, const std::string &notes,
         const std::vector<std::string> &cast, unsigned int length,
         const std::string &universe);
+  bool operator==(const Media &other) const override;
   const std::vector<std::string> &getCast() const;
   unsigned int getLength() const;
   const std::string &getUniverse() const;
diff --git a/src/Media/Novel.cpp b/src/Media/Novel.cpp
index 2f21c7e..4c827d2 100644
--- a/src/Media/Novel.cpp
+++ b/src/Media/Novel.cpp
@@ -9,9 +9,14 @@ Novel::Novel(const std::string& title, int publicationYear, const std::string& l
     : Media(title, publicationYear, language, favorite, genres, imagePath, notes),
       author_(author), publisher_(publisher), pages_(pages), series_(series), isbn_(isbn) {}
 
-// Visitor
-void Novel::accept(IConstMediaVisitor& v) const {
-    v.visit(*this);
+bool Novel::operator==(const Media& other) const {
+    const Novel* otherNovel = dynamic_cast<const Novel*>(&other);
+    if (otherNovel) {
+        return Media::operator==(*otherNovel) && author_ == otherNovel->author_ &&
+               publisher_ == otherNovel->publisher_ && pages_ == otherNovel->pages_ &&
+               series_ == otherNovel->series_ && isbn_ == otherNovel->isbn_;
+    }
+    return false;
 }
 
 // Getters
diff --git a/src/Media/Novel.h b/src/Media/Novel.h
index 8462a61..a736000 100644
--- a/src/Media/Novel.h
+++ b/src/Media/Novel.h
@@ -19,7 +19,7 @@ class Novel : public Media {
           const std::string& author, const std::string& publisher,
           unsigned int pages, const std::string& series, const std::string& isbn);
 
-    void accept(IConstMediaVisitor& v) const override;
+    bool operator==(const Media& other) const override;
 
     // Getters
     std::string getAuthor() const;
diff --git a/src/Media/Series.cpp b/src/Media/Series.cpp
index fb6c2a5..4004f93 100644
--- a/src/Media/Series.cpp
+++ b/src/Media/Series.cpp
@@ -13,6 +13,14 @@ Series::Series(const std::string &title, int release,
       episodes_(episodes),
       seasons_(seasons),
       ended_(ended) {}
+bool Series::operator==(const Media &other) const {
+    const Series *otherSeries = dynamic_cast<const Series *>(&other);
+    if (otherSeries) {
+        return Movie::operator==(*otherSeries) && episodes_ == otherSeries->episodes_ &&
+               seasons_ == otherSeries->seasons_ && ended_ == otherSeries->ended_;
+    }
+    return false;
+}
 unsigned int Series::getEpisodes() const { return episodes_; }
 unsigned int Series::getSeasons() const { return seasons_; }
 bool Series::isEnded() const { return ended_; }
diff --git a/src/Media/Series.h b/src/Media/Series.h
index 91b96b0..036086f 100644
--- a/src/Media/Series.h
+++ b/src/Media/Series.h
@@ -16,6 +16,7 @@ class Series : public Movie {
          const std::vector<std::string> &cast, unsigned int length,
          const std::string &universe, unsigned int episodes,
          unsigned int seasons, bool ended);
+  bool operator==(const Media &other) const override;
   unsigned int getEpisodes() const;
   unsigned int getSeasons() const;
   bool isEnded() const;
diff --git a/src/Memory/MediaContainer.cpp b/src/Memory/MediaContainer.cpp
new file mode 100644
index 0000000..4fcd3aa
--- /dev/null
+++ b/src/Memory/MediaContainer.cpp
@@ -0,0 +1,71 @@
+#include "MediaContainer.h"
+namespace memory {
+
+void MediaContainer::addMedia(const std::shared_ptr<media::Media>& media) {
+    if (!media) return;
+
+    data_[static_cast<size_t>(MediaType::All)].push_back(media);
+
+    MediaType type = determineType(media);
+    if (type != MediaType::All) {
+        data_[static_cast<size_t>(type)].push_back(media);
+    }
+}
+
+void MediaContainer::removeMedia(const std::shared_ptr<media::Media>& media) {
+    if (!media) return;
+
+    for (auto& vec : data_) {
+        vec.erase(std::remove_if(vec.begin(), vec.end(),
+            [&](const std::shared_ptr<media::Media>& m) {
+                return typeid(*m) == typeid(*media) && *m == *media;
+            }), vec.end());
+    }
+}
+
+void MediaContainer::clear() {
+    for (auto& vec : data_) {
+        vec.clear();
+    }
+}
+
+std::vector<std::shared_ptr<media::Media>> MediaContainer::filterByTitle(const std::string& title) const {
+    return filter([&](const media::Media& m) {
+        return m.getTitle() == title;
+    });
+}
+
+std::vector<std::shared_ptr<media::Media>> MediaContainer::filterByYear(int year) const {
+    return filter([&](const media::Media& m) {
+        return m.getRelease() == year;
+    });
+}
+
+std::vector<std::shared_ptr<media::Media>> MediaContainer::getAll() const {
+    return data_[static_cast<size_t>(MediaType::All)];
+}
+
+std::vector<std::shared_ptr<media::Media>> MediaContainer::getByType(MediaType type) const {
+    return data_[static_cast<size_t>(type)];
+}
+
+std::vector<std::shared_ptr<media::Media>> MediaContainer::filter(std::function<bool(const media::Media&)> predicate) const {
+    std::vector<std::shared_ptr<media::Media>> result;
+    for (const auto& media : data_[static_cast<size_t>(MediaType::All)]) {
+        if (predicate(*media)) {
+            result.push_back(media);
+        }
+    }
+    return result;
+}
+
+MediaType MediaContainer::determineType(const std::shared_ptr<media::Media>& media) const {
+    if (std::dynamic_pointer_cast<media::Series>(media)) return MediaType::Series;
+    if (std::dynamic_pointer_cast<media::Movie>(media)) return MediaType::Movie;
+    if (std::dynamic_pointer_cast<media::AudioBook>(media)) return MediaType::AudioBook;
+    if (std::dynamic_pointer_cast<media::Ebook>(media)) return MediaType::EBook;
+    if (std::dynamic_pointer_cast<media::Novel>(media)) return MediaType::Novel;
+    if (std::dynamic_pointer_cast<media::Album>(media)) return MediaType::Album;
+    return MediaType::All;
+}
+}
\ No newline at end of file
diff --git a/src/Memory/MediaContainer.h b/src/Memory/MediaContainer.h
index cc24df4..72a17c5 100644
--- a/src/Memory/MediaContainer.h
+++ b/src/Memory/MediaContainer.h
@@ -1,14 +1,53 @@
-#ifndef MEMORY_MEDIA_CONTAINER_H
-#define MEMORY_MEDIA_CONTAINER_H
-#include "../Media/Media.h"
+#ifndef MEMORY_MEDIACONTAINER_H
+#define MEMORY_MEDIACONTAINER_H
+
+#include <array>
+#include <vector>
+#include <memory>
+#include <string>
+#include <algorithm>
+#include <functional>
+
+#include "Media.h"
+#include "Novel.h"
+#include "Album.h"
+#include "Movie.h"
+#include "Ebook.h"
+#include "AudioBook.h"
+#include "Series.h"
+
+namespace memory{
+
+enum class MediaType {
+    All = 0,
+    Novel,
+    Album,
+    Movie,
+    EBook,
+    AudioBook,
+    Series,
+    Count // serve per la dimensione dell’array
+};
 
-namespace memory {
 class MediaContainer {
- public:
-  MediaContainer() = default;
-  int addMedia(media::Media *);
-  int removeMedia(media::Media *);
-  std::vector<media::Media *> filter(media::Media *);
+private:
+    std::array<std::vector<std::shared_ptr<media::Media>>, static_cast<size_t>(MediaType::Count)> data_;
+
+    MediaType determineType(const std::shared_ptr<media::Media>& media) const;
+
+public:
+    void addMedia(const std::shared_ptr<media::Media>& media);
+    void removeMedia(const std::shared_ptr<media::Media>& media);
+    void clear();
+
+    std::vector<std::shared_ptr<media::Media>> filterByTitle(const std::string& title) const;
+    std::vector<std::shared_ptr<media::Media>> filterByYear(int year) const;
+
+    std::vector<std::shared_ptr<media::Media>> getAll() const;
+    std::vector<std::shared_ptr<media::Media>> getByType(MediaType type) const;
+    
+    // Combinazioni di filtri
+    std::vector<std::shared_ptr<media::Media>> filter(std::function<bool(const media::Media&)> predicate) const;
 };
-}  // namespace memory
-#endif
+}
+#endif // MEMORY_MEDIACONTAINER_H

From dc603fc45f36c73c6d7c6fc4e7303933bc296309 Mon Sep 17 00:00:00 2001
From: Steva0 <michele.stevanin@gmail.com>
Date: Tue, 20 May 2025 11:53:35 +0200
Subject: [PATCH 02/16] Aggiunto metodo Filter per la classe Media

---
 src/Media/Media.cpp           | 56 +++++++++++++++++++++++++++++++++++
 src/Media/Media.h             | 13 +++++---
 src/Memory/MediaContainer.cpp | 30 +++++--------------
 src/Memory/MediaContainer.h   |  9 ++----
 src/StringUtils.h             | 20 +++++++++++++
 src/main.cpp                  | 54 ++++++++++++++++++++++++++++++++-
 6 files changed, 149 insertions(+), 33 deletions(-)
 create mode 100644 src/StringUtils.h

diff --git a/src/Media/Media.cpp b/src/Media/Media.cpp
index 9d732e6..2fcdcae 100644
--- a/src/Media/Media.cpp
+++ b/src/Media/Media.cpp
@@ -1,4 +1,8 @@
 #include "Media.h"
+#include <limits>
+#include <cctype>
+#include <locale>
+#include <algorithm>
 
 namespace media {
 Media::Media(const std::string &title, int release, const std::string &language,
@@ -27,6 +31,58 @@ bool Media::open() {
   return false;
 }
 
+std::vector<std::shared_ptr<Media>> Media::filter(const std::vector<std::shared_ptr<Media>>& input) const {
+    std::vector<std::shared_ptr<Media>> result;
+
+    for (const auto& mediaPtr : input) {
+        if (!mediaPtr) continue;
+
+        const Media& media = *mediaPtr;
+        bool match = true;
+
+        // Title (substring, case-insensitive)
+        if (!getTitle().empty() && !stringContainsIgnoreCase(media.getTitle(), getTitle()))
+            match = false;
+
+        // Release (confronto stretto)
+        if (getRelease() != std::numeric_limits<int>::min() &&
+            media.getRelease() != getRelease())
+            match = false;
+
+        // Language (substring, case-insensitive)
+        if (!getLanguage().empty() && media.getLanguage() != getLanguage())
+            match = false;
+
+        // Favourite (confronto booleano)
+        if (isFavourite() && media.isFavourite() != isFavourite())
+            match = false;
+
+        // Generi (match parziale case-insensitive su ogni genere richiesto)
+        if (!getGenres().empty()) {
+            const auto& mediaGenres = media.getGenres();
+            for (const auto& genreFilter : getGenres()) {
+                bool found = false;
+                for (const auto& g : mediaGenres) {
+                    if (stringContainsIgnoreCase(g, genreFilter)) {
+                        found = true;
+                        break;
+                    }
+                }
+                if (!found) {
+                    match = false;
+                    break;
+                }
+            }
+        }
+
+        if (match)
+            result.push_back(mediaPtr);
+    }
+
+    return result;
+}
+
+
 const std::string &Media::getTitle() const { return title_; }
 int Media::getRelease() const { return release_; }
 const std::string &Media::getLanguage() const { return language_; };
diff --git a/src/Media/Media.h b/src/Media/Media.h
index d743fe4..dd06409 100644
--- a/src/Media/Media.h
+++ b/src/Media/Media.h
@@ -3,9 +3,12 @@
 #include <string>
 #include <vector>
 #include <iostream>
+#include <memory>
+#include <limits>
 
 #include "IMedia.h"
 #include "IConstMediaVisitor.h"
+#include "StringUtils.h"
 
 namespace media {
 class Media : IMedia{
@@ -19,9 +22,9 @@ class Media : IMedia{
   std::string notes_;
 
   protected:
-  Media(const std::string &title, int release, const std::string &language,
-        bool favourite, const std::vector<std::string> &genres,
-        const std::string &img_path, const std::string &notes);
+  Media(const std::string &title = "", int release = std::numeric_limits<int>::min(), const std::string &language = "",
+        bool favourite = false, const std::vector<std::string> &genres = {},
+        const std::string &img_path = "", const std::string &notes = "");
   
  public:
 
@@ -40,6 +43,8 @@ class Media : IMedia{
   const std::vector<std::string> &getGenres() const;
   const std::string &getImgPath() const;
   const std::string &getNotes() const;
-};
+
+  virtual std::vector<std::shared_ptr<Media>> filter(const std::vector<std::shared_ptr<Media>> &media) const;
+}; 
 }  // namespace media
 #endif
diff --git a/src/Memory/MediaContainer.cpp b/src/Memory/MediaContainer.cpp
index 4fcd3aa..f7ff5df 100644
--- a/src/Memory/MediaContainer.cpp
+++ b/src/Memory/MediaContainer.cpp
@@ -29,18 +29,6 @@ void MediaContainer::clear() {
     }
 }
 
-std::vector<std::shared_ptr<media::Media>> MediaContainer::filterByTitle(const std::string& title) const {
-    return filter([&](const media::Media& m) {
-        return m.getTitle() == title;
-    });
-}
-
-std::vector<std::shared_ptr<media::Media>> MediaContainer::filterByYear(int year) const {
-    return filter([&](const media::Media& m) {
-        return m.getRelease() == year;
-    });
-}
-
 std::vector<std::shared_ptr<media::Media>> MediaContainer::getAll() const {
     return data_[static_cast<size_t>(MediaType::All)];
 }
@@ -49,16 +37,6 @@ std::vector<std::shared_ptr<media::Media>> MediaContainer::getByType(MediaType t
     return data_[static_cast<size_t>(type)];
 }
 
-std::vector<std::shared_ptr<media::Media>> MediaContainer::filter(std::function<bool(const media::Media&)> predicate) const {
-    std::vector<std::shared_ptr<media::Media>> result;
-    for (const auto& media : data_[static_cast<size_t>(MediaType::All)]) {
-        if (predicate(*media)) {
-            result.push_back(media);
-        }
-    }
-    return result;
-}
-
 MediaType MediaContainer::determineType(const std::shared_ptr<media::Media>& media) const {
     if (std::dynamic_pointer_cast<media::Series>(media)) return MediaType::Series;
     if (std::dynamic_pointer_cast<media::Movie>(media)) return MediaType::Movie;
@@ -68,4 +46,12 @@ MediaType MediaContainer::determineType(const std::shared_ptr<media::Media>& med
     if (std::dynamic_pointer_cast<media::Album>(media)) return MediaType::Album;
     return MediaType::All;
 }
+
+std::vector<std::shared_ptr<media::Media>> MediaContainer::filter(const std::shared_ptr<media::Media>& media) const{
+    auto allMedia = getAll();
+    return media->filter(allMedia);
+}
+
+
+
 }
\ No newline at end of file
diff --git a/src/Memory/MediaContainer.h b/src/Memory/MediaContainer.h
index 72a17c5..e38dea8 100644
--- a/src/Memory/MediaContainer.h
+++ b/src/Memory/MediaContainer.h
@@ -40,14 +40,11 @@ class MediaContainer {
     void removeMedia(const std::shared_ptr<media::Media>& media);
     void clear();
 
-    std::vector<std::shared_ptr<media::Media>> filterByTitle(const std::string& title) const;
-    std::vector<std::shared_ptr<media::Media>> filterByYear(int year) const;
-
     std::vector<std::shared_ptr<media::Media>> getAll() const;
     std::vector<std::shared_ptr<media::Media>> getByType(MediaType type) const;
-    
-    // Combinazioni di filtri
-    std::vector<std::shared_ptr<media::Media>> filter(std::function<bool(const media::Media&)> predicate) const;
+
+    //Sezione filtri
+    std::vector<std::shared_ptr<media::Media>> filter(const std::shared_ptr<media::Media>& media) const;
 };
 }
 #endif // MEMORY_MEDIACONTAINER_H
diff --git a/src/StringUtils.h b/src/StringUtils.h
new file mode 100644
index 0000000..5be116a
--- /dev/null
+++ b/src/StringUtils.h
@@ -0,0 +1,20 @@
+#ifndef STRINGUTILS_H
+#define STRINGUTILS_H
+
+#include <string>
+#include <algorithm>
+#include <cctype>
+
+namespace media {
+inline std::string toLowerCase(const std::string& str) {
+    std::string lower = str;
+    std::transform(lower.begin(), lower.end(), lower.begin(),
+                   [](unsigned char c){ return std::tolower(c); });
+    return lower;
+}
+
+inline bool stringContainsIgnoreCase(const std::string& text, const std::string& pattern) {
+    return toLowerCase(text).find(toLowerCase(pattern)) != std::string::npos;
+}
+}
+#endif // STRINGUTILS_H
diff --git a/src/main.cpp b/src/main.cpp
index 76e8197..57bbbbb 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1 +1,53 @@
-int main() { return 0; }
+#include <iostream>
+#include <memory>
+#include <vector>
+#include <limits>
+#include "Media.h"  // Include il tuo header
+
+int main() {
+    // Crea alcuni media
+    auto media1 = std::make_shared<media::Media>(
+        "House of Cards",
+        2013,
+        "English",
+        std::vector<std::string>{"Drama", "Politics"},
+        true
+    );
+
+    auto media2 = std::make_shared<media::Media>(
+        "The Crown",
+        2016,
+        "English",
+        std::vector<std::string>{"History", "Drama"},
+        false
+    );
+
+    auto media3 = std::make_shared<media::Media>(
+        "Breaking Bad",
+        2008,
+        "English",
+        std::vector<std::string>{"Crime", "Thriller"},
+        false
+    );
+
+    // Inserisci i media in un vettore
+    std::vector<std::shared_ptr<media::Media>> inputList = {media1, media2, media3};
+
+    // Crea un oggetto Media come filtro
+    auto filterMedia = std::make_shared<media::Media>(
+        "Ho",
+        std::numeric_limits<int>::min(), 
+        "dra"
+    );
+    
+    // Filtra
+    std::vector<std::shared_ptr<media::Media>> filtered = filterMedia->filter(inputList);
+
+    // Stampa i risultati
+    std::cout << "Media che passano il filtro:\n";
+    for (const auto& m : filtered) {
+        std::cout << "- " << m->getTitle() << "\n";
+    }
+
+    return 0;
+}

From 6f4fbc38f72e8a725f7ba19161498e7ebc532c34 Mon Sep 17 00:00:00 2001
From: Steva0 <michele.stevanin@gmail.com>
Date: Tue, 20 May 2025 11:59:49 +0200
Subject: [PATCH 03/16] Aggiunta interfaccia metodi filtra

---
 src/Memory/MediaContainer.h | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/Memory/MediaContainer.h b/src/Memory/MediaContainer.h
index e38dea8..62db178 100644
--- a/src/Memory/MediaContainer.h
+++ b/src/Memory/MediaContainer.h
@@ -45,6 +45,13 @@ class MediaContainer {
 
     //Sezione filtri
     std::vector<std::shared_ptr<media::Media>> filter(const std::shared_ptr<media::Media>& media) const;
+    std::vector<std::shared_ptr<media::Media>> filter(const std::shared_ptr<media::Novel>& novel) const;
+    std::vector<std::shared_ptr<media::Media>> filter(const std::shared_ptr<media::Album>& album) const;
+    std::vector<std::shared_ptr<media::Media>> filter(const std::shared_ptr<media::Movie>& movie) const;
+    std::vector<std::shared_ptr<media::Media>> filter(const std::shared_ptr<media::Ebook>& ebook) const;
+    std::vector<std::shared_ptr<media::Media>> filter(const std::shared_ptr<media::AudioBook>& audiobook) const;
+    std::vector<std::shared_ptr<media::Media>> filter(const std::shared_ptr<media::Series>& series) const;
+
 };
 }
 #endif // MEMORY_MEDIACONTAINER_H

From 1c9d4f2bee60e23adb7d7dcaf9434dd3ed5e6ffd Mon Sep 17 00:00:00 2001
From: Steva0 <michele.stevanin@gmail.com>
Date: Tue, 20 May 2025 13:09:41 +0200
Subject: [PATCH 04/16] Tolto il virtual

---
 src/Media/Media.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Media/Media.h b/src/Media/Media.h
index dd06409..9b11618 100644
--- a/src/Media/Media.h
+++ b/src/Media/Media.h
@@ -44,7 +44,7 @@ class Media : IMedia{
   const std::string &getImgPath() const;
   const std::string &getNotes() const;
 
-  virtual std::vector<std::shared_ptr<Media>> filter(const std::vector<std::shared_ptr<Media>> &media) const;
+  std::vector<std::shared_ptr<Media>> filter(const std::vector<std::shared_ptr<Media>> &media) const;
 }; 
 }  // namespace media
 #endif

From c74688d9a395b85b69bdc7b52c1c9758c6c080ed Mon Sep 17 00:00:00 2001
From: Steva0 <michele.stevanin@gmail.com>
Date: Tue, 20 May 2025 13:32:19 +0200
Subject: [PATCH 05/16] Metodo filter per Novel

---
 src/Media/Novel.cpp           | 42 +++++++++++++++++++++++++++++++++++
 src/Media/Novel.h             |  3 +++
 src/Memory/MediaContainer.cpp | 34 ++++++++++++++++++++++++++--
 src/Memory/MediaContainer.h   | 13 ++++++-----
 4 files changed, 84 insertions(+), 8 deletions(-)

diff --git a/src/Media/Novel.cpp b/src/Media/Novel.cpp
index 4c827d2..133775e 100644
--- a/src/Media/Novel.cpp
+++ b/src/Media/Novel.cpp
@@ -33,4 +33,46 @@ void Novel::setPages(unsigned int pages) { pages_ = pages; }
 void Novel::setSeries(const std::string& series) { series_ = series; }
 void Novel::setIsbn(const std::string& isbn) { isbn_ = isbn; }
 
+
+std::vector<std::shared_ptr<Novel>> Novel::filter(const std::vector<std::shared_ptr<Novel>>& input) const {
+    std::vector<std::shared_ptr<Novel>> result;
+
+    // Riutilizzo del filtro base di Media
+    std::vector<std::shared_ptr<Media>> baseInput(input.begin(), input.end());
+    std::vector<std::shared_ptr<Media>> filteredBase = Media::filter(baseInput);
+
+    // Filtro specifico per Novel
+    for (const auto& mediaPtr : filteredBase) {
+        auto novelPtr = std::dynamic_pointer_cast<Novel>(mediaPtr);
+        if (!novelPtr) continue;
+
+        bool match = true;
+
+        // Autore
+        if (!author_.empty() && !stringContainsIgnoreCase(novelPtr->getAuthor(), author_))
+            match = false;
+
+        // Editore
+        if (!publisher_.empty() && !stringContainsIgnoreCase(novelPtr->getPublisher(), publisher_))
+            match = false;
+
+        // Serie
+        if (!series_.empty() && !stringContainsIgnoreCase(novelPtr->getSeries(), series_))
+            match = false;
+
+        // ISBN
+        if (!isbn_.empty() && !stringContainsIgnoreCase(novelPtr->getIsbn(), isbn_))
+            match = false;
+
+        // Pagine (confronto stretto)
+        if (pages_ > 0 && novelPtr->getPages() != pages_)
+            match = false;
+
+        if (match)
+            result.push_back(novelPtr);
+    }
+
+    return result;
+}
+
 }
\ No newline at end of file
diff --git a/src/Media/Novel.h b/src/Media/Novel.h
index a736000..b61bf12 100644
--- a/src/Media/Novel.h
+++ b/src/Media/Novel.h
@@ -34,6 +34,9 @@ class Novel : public Media {
     void setPages(unsigned int pages);
     void setSeries(const std::string& series);
     void setIsbn(const std::string& isbn);
+
+    std::vector<std::shared_ptr<Novel>> filter(const std::vector<std::shared_ptr<Novel>> &novel) const;
 };
+
 }
 #endif // Novel_H
\ No newline at end of file
diff --git a/src/Memory/MediaContainer.cpp b/src/Memory/MediaContainer.cpp
index f7ff5df..719ff8a 100644
--- a/src/Memory/MediaContainer.cpp
+++ b/src/Memory/MediaContainer.cpp
@@ -37,6 +37,35 @@ std::vector<std::shared_ptr<media::Media>> MediaContainer::getByType(MediaType t
     return data_[static_cast<size_t>(type)];
 }
 
+std::vector<std::shared_ptr<media::Media>> MediaContainer::getByTypeAndSubtype(MediaType type) const {
+    std::vector<std::shared_ptr<media::Media>> result;
+
+    switch (type) {
+        case MediaType::Novel:
+            result.insert(result.end(), data_[static_cast<size_t>(MediaType::Novel)].begin(), data_[static_cast<size_t>(MediaType::Novel)].end());
+            result.insert(result.end(), data_[static_cast<size_t>(MediaType::EBook)].begin(), data_[static_cast<size_t>(MediaType::EBook)].end());
+            result.insert(result.end(), data_[static_cast<size_t>(MediaType::AudioBook)].begin(), data_[static_cast<size_t>(MediaType::AudioBook)].end());
+            break;
+
+        case MediaType::Movie:
+            result.insert(result.end(), data_[static_cast<size_t>(MediaType::Movie)].begin(), data_[static_cast<size_t>(MediaType::Movie)].end());
+            result.insert(result.end(), data_[static_cast<size_t>(MediaType::Series)].begin(), data_[static_cast<size_t>(MediaType::Series)].end());
+            break;
+
+        case MediaType::All:
+            result = data_[0]; // Tutti i media
+            break;
+
+        default:
+            // Ritorna il vettore corrispondente solo per quel tipo specifico
+            result = data_[static_cast<size_t>(type)];
+            break;
+    }
+
+    return result;
+}
+
+
 MediaType MediaContainer::determineType(const std::shared_ptr<media::Media>& media) const {
     if (std::dynamic_pointer_cast<media::Series>(media)) return MediaType::Series;
     if (std::dynamic_pointer_cast<media::Movie>(media)) return MediaType::Movie;
@@ -52,6 +81,7 @@ std::vector<std::shared_ptr<media::Media>> MediaContainer::filter(const std::sha
     return media->filter(allMedia);
 }
 
-
-
+std::vector<std::shared_ptr<media::Novel>> MediaContainer::filter(const std::shared_ptr<media::Novel>& novel) const{
+    auto allNovel= getByTypeAndSubtype(MediaType::Novel);
+    return novel->filter(allNovel);
 }
\ No newline at end of file
diff --git a/src/Memory/MediaContainer.h b/src/Memory/MediaContainer.h
index 62db178..2fdfb6e 100644
--- a/src/Memory/MediaContainer.h
+++ b/src/Memory/MediaContainer.h
@@ -42,15 +42,16 @@ class MediaContainer {
 
     std::vector<std::shared_ptr<media::Media>> getAll() const;
     std::vector<std::shared_ptr<media::Media>> getByType(MediaType type) const;
+    std::vector<std::shared_ptr<media::Media>> getByTypeAndSubtype(MediaType type) const;
 
     //Sezione filtri
     std::vector<std::shared_ptr<media::Media>> filter(const std::shared_ptr<media::Media>& media) const;
-    std::vector<std::shared_ptr<media::Media>> filter(const std::shared_ptr<media::Novel>& novel) const;
-    std::vector<std::shared_ptr<media::Media>> filter(const std::shared_ptr<media::Album>& album) const;
-    std::vector<std::shared_ptr<media::Media>> filter(const std::shared_ptr<media::Movie>& movie) const;
-    std::vector<std::shared_ptr<media::Media>> filter(const std::shared_ptr<media::Ebook>& ebook) const;
-    std::vector<std::shared_ptr<media::Media>> filter(const std::shared_ptr<media::AudioBook>& audiobook) const;
-    std::vector<std::shared_ptr<media::Media>> filter(const std::shared_ptr<media::Series>& series) const;
+    std::vector<std::shared_ptr<media::Novel>> filter(const std::shared_ptr<media::Novel>& novel) const;
+    std::vector<std::shared_ptr<media::Album>> filter(const std::shared_ptr<media::Album>& album) const;
+    std::vector<std::shared_ptr<media::Movie>> filter(const std::shared_ptr<media::Movie>& movie) const;
+    std::vector<std::shared_ptr<media::Ebook>> filter(const std::shared_ptr<media::Ebook>& ebook) const;
+    std::vector<std::shared_ptr<media::AudioBook>> filter(const std::shared_ptr<media::AudioBook>& audiobook) const;
+    std::vector<std::shared_ptr<media::Series>> filter(const std::shared_ptr<media::Series>& series) const;
 
 };
 }

From 090cf2484ab4518fb1b5ab449f30a757fa22d2ce Mon Sep 17 00:00:00 2001
From: Steva0 <michele.stevanin@gmail.com>
Date: Tue, 20 May 2025 13:45:56 +0200
Subject: [PATCH 06/16] Sistemato filtro per Novel

---
 src/Memory/MediaContainer.cpp | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/Memory/MediaContainer.cpp b/src/Memory/MediaContainer.cpp
index 719ff8a..f5c6f1b 100644
--- a/src/Memory/MediaContainer.cpp
+++ b/src/Memory/MediaContainer.cpp
@@ -82,6 +82,13 @@ std::vector<std::shared_ptr<media::Media>> MediaContainer::filter(const std::sha
 }
 
 std::vector<std::shared_ptr<media::Novel>> MediaContainer::filter(const std::shared_ptr<media::Novel>& novel) const{
-    auto allNovel= getByTypeAndSubtype(MediaType::Novel);
+    auto media= getByTypeAndSubtype(MediaType::Novel);
+    std::vector<std::shared_ptr<media::Novel>> allNovel;
+    for (const auto& mediaPtr : media) {
+        auto novelPtr = std::dynamic_pointer_cast<media::Novel>(mediaPtr);
+        if (novelPtr) {
+            allNovel.push_back(novelPtr);
+        }
+    }
     return novel->filter(allNovel);
 }
\ No newline at end of file

From 0f5cf1301bde1fa8e095f6109522fe2d901020c7 Mon Sep 17 00:00:00 2001
From: Steva0 <michele.stevanin@gmail.com>
Date: Tue, 20 May 2025 14:01:51 +0200
Subject: [PATCH 07/16] Aggiunti parametri di default

---
 src/Media/Album.h     | 4 ++--
 src/Media/AudioBook.h | 3 ++-
 src/Media/Ebook.h     | 2 +-
 src/Media/Media.h     | 2 +-
 src/Media/Movie.h     | 4 ++--
 src/Media/Novel.h     | 4 ++--
 src/Media/Series.h    | 4 ++--
 7 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/src/Media/Album.h b/src/Media/Album.h
index 3839490..c2d5bbc 100644
--- a/src/Media/Album.h
+++ b/src/Media/Album.h
@@ -13,8 +13,8 @@ class Album : public Media {
   Album(const std::string &title, int release, const std::string &language,
         bool favourite, const std::vector<std::string> &genres,
         const std::string &img_path, const std::string &notes,
-        const std::string &band, const std::vector<std::string> &band_members,
-        const std::vector<std::string> &songs);
+        const std::string &band = "", const std::vector<std::string> &band_members = {},
+        const std::vector<std::string> &songs = {});
   const std::string &getBand() const;
   const std::vector<std::string> &getBandMembers() const;
   const std::vector<std::string> &getSongs() const;
diff --git a/src/Media/AudioBook.h b/src/Media/AudioBook.h
index 4b0bc09..999ab78 100644
--- a/src/Media/AudioBook.h
+++ b/src/Media/AudioBook.h
@@ -11,11 +11,12 @@ class AudioBook : public Novel {
     std::string streamingService_;
 
 public:
+    //durata è in minuti e usa il campo dati pagine di Novel
     AudioBook(const std::string& title, int publicationYear, const std::string& language,
               bool favorite, const std::vector<std::string>& genres, const std::string& imagePath, const std::string& notes,
               const std::string& author, const std::string& publisher,
               unsigned int duration, const std::string& series, const std::string& isbn,
-              const std::string& narrator, const std::string& streamingService);
+              const std::string& narrator = "", const std::string& streamingService = "");
 
     bool operator==(const Media& other) const override;
 
diff --git a/src/Media/Ebook.h b/src/Media/Ebook.h
index 7035703..5d5312a 100644
--- a/src/Media/Ebook.h
+++ b/src/Media/Ebook.h
@@ -15,7 +15,7 @@ class Ebook : public Novel {
           bool favorite, const std::vector<std::string>& genres, const std::string& imagePath, const std::string& notes,
           const std::string& author, const std::string& publisher,
           unsigned int pages, const std::string& series, const std::string& isbn,
-          unsigned int fileSizeBytes, bool drm);
+          unsigned int fileSizeBytes = 0, bool drm = false);
 
     bool operator==(const Media& other) const override;
 
diff --git a/src/Media/Media.h b/src/Media/Media.h
index 9b11618..2268e81 100644
--- a/src/Media/Media.h
+++ b/src/Media/Media.h
@@ -22,7 +22,7 @@ class Media : IMedia{
   std::string notes_;
 
   protected:
-  Media(const std::string &title = "", int release = std::numeric_limits<int>::min(), const std::string &language = "",
+  Media(const std::string &title = "", int release = std::numeric_limits<int>::max(), const std::string &language = "",
         bool favourite = false, const std::vector<std::string> &genres = {},
         const std::string &img_path = "", const std::string &notes = "");
   
diff --git a/src/Media/Movie.h b/src/Media/Movie.h
index 0c736dc..d630377 100644
--- a/src/Media/Movie.h
+++ b/src/Media/Movie.h
@@ -17,8 +17,8 @@ class Movie : public Media {
   Movie(const std::string &title, int release, const std::string &language,
         bool favourite, const std::vector<std::string> &genres,
         const std::string &img_path, const std::string &notes,
-        const std::vector<std::string> &cast, unsigned int length,
-        const std::string &universe);
+        const std::vector<std::string> &cast = {}, unsigned int length = std::numeric_limits<unsigned int>::max(),
+        const std::string &universe = "");
   bool operator==(const Media &other) const override;
   const std::vector<std::string> &getCast() const;
   unsigned int getLength() const;
diff --git a/src/Media/Novel.h b/src/Media/Novel.h
index b61bf12..8fba19d 100644
--- a/src/Media/Novel.h
+++ b/src/Media/Novel.h
@@ -16,8 +16,8 @@ class Novel : public Media {
 public:
     Novel(const std::string& title, int publicationYear, const std::string& language,
           bool favorite, const std::vector<std::string>& genres, const std::string& imagePath, const std::string& notes,
-          const std::string& author, const std::string& publisher,
-          unsigned int pages, const std::string& series, const std::string& isbn);
+          const std::string& author = "", const std::string& publisher = "",
+          unsigned int pages = std::numeric_limits<unsigned int>::max(), const std::string& series = "", const std::string& isbn = "");
 
     bool operator==(const Media& other) const override;
 
diff --git a/src/Media/Series.h b/src/Media/Series.h
index 036086f..15b1649 100644
--- a/src/Media/Series.h
+++ b/src/Media/Series.h
@@ -14,8 +14,8 @@ class Series : public Movie {
          bool favourite, const std::vector<std::string> &genres,
          const std::string &img_path, const std::string &notes,
          const std::vector<std::string> &cast, unsigned int length,
-         const std::string &universe, unsigned int episodes,
-         unsigned int seasons, bool ended);
+         const std::string &universe, unsigned int episodes = std::numeric_limits<unsigned int>::max(),
+         unsigned int seasons = std::numeric_limits<unsigned int>::max(), bool ended = false);
   bool operator==(const Media &other) const override;
   unsigned int getEpisodes() const;
   unsigned int getSeasons() const;

From ac28661b7b8294b4421ee75a4d6c4bcdcc875424 Mon Sep 17 00:00:00 2001
From: Steva0 <michele.stevanin@gmail.com>
Date: Tue, 20 May 2025 14:26:57 +0200
Subject: [PATCH 08/16] SIstemata la cartella di git

---
 .gitignore                    |  3 ++-
 CMakeLists.txt                | 43 -----------------------------------
 src/Media/Media.h             | 12 +++++-----
 src/{ => Media}/StringUtils.h |  0
 src/main.cpp                  | 19 ++++++++--------
 5 files changed, 17 insertions(+), 60 deletions(-)
 delete mode 100644 CMakeLists.txt
 rename src/{ => Media}/StringUtils.h (100%)

diff --git a/.gitignore b/.gitignore
index bdb5fa1..33447a5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,7 +9,7 @@
 *.so.*
 *.dll
 *.dylib
-build
+Build
 checks.json
 
 # Qt-es
@@ -18,6 +18,7 @@ object_script.*.Debug
 *_plugin_import.cpp
 /.qmake.cache
 /.qmake.stash
+src/*.qmake.stash
 *.pro.user
 *.pro.user.*
 *.qbs.user
diff --git a/CMakeLists.txt b/CMakeLists.txt
deleted file mode 100644
index e087f6b..0000000
--- a/CMakeLists.txt
+++ /dev/null
@@ -1,43 +0,0 @@
-cmake_minimum_required(VERSION 3.16)
-
-project(MediaLibraryBuild VERSION 1.0 LANGUAGES CXX)
-
-# Qt5: automatizza moc, uic, rcc
-set(CMAKE_AUTOMOC ON)
-set(CMAKE_AUTORCC ON)
-set(CMAKE_AUTOUIC ON)
-
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-# Raccoglie tutti i file .cpp e .h nella cartella src/
-file(GLOB_RECURSE SOURCES CONFIGURE_DEPENDS src/*.cpp src/*.h)
-
-# Crea l'eseguibile principale
-add_executable(${PROJECT_NAME} ${SOURCES})
-
-target_include_directories(${PROJECT_NAME} PRIVATE src)
-
-# Trova e linka le librerie Qt necessarie
-find_package(Qt5 REQUIRED COMPONENTS Core Widgets Gui)
-
-target_link_libraries(${PROJECT_NAME} PRIVATE Qt5::Core Qt5::Widgets Qt5::Gui)
-
-# Imposta la cartella output dell'eseguibile
-set_target_properties(${PROJECT_NAME} PROPERTIES
-    RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}
-)
-
-# Abilita il supporto ai test
-enable_testing()
-
-# Test (facoltativi)
-file(GLOB_RECURSE TEST_SOURCES CONFIGURE_DEPENDS src/test*.cpp)
-
-foreach(test_src ${TEST_SOURCES})
-    get_filename_component(test_name ${test_src} NAME_WE)
-    add_executable(${test_name} ${test_src})
-    target_include_directories(${test_name} PRIVATE src)
-    target_link_libraries(${test_name} PRIVATE Qt5::Core Qt5::Widgets Qt5::Gui)
-    add_test(NAME ${test_name} COMMAND ${test_name})
-endforeach()
diff --git a/src/Media/Media.h b/src/Media/Media.h
index 2268e81..0d39960 100644
--- a/src/Media/Media.h
+++ b/src/Media/Media.h
@@ -21,14 +21,14 @@ class Media : IMedia{
   std::string img_path_;
   std::string notes_;
 
-  protected:
+   
+  public:
+
   Media(const std::string &title = "", int release = std::numeric_limits<int>::max(), const std::string &language = "",
-        bool favourite = false, const std::vector<std::string> &genres = {},
-        const std::string &img_path = "", const std::string &notes = "");
-  
- public:
+          bool favourite = false, const std::vector<std::string> &genres = {},
+          const std::string &img_path = "", const std::string &notes = "");
 
-  virtual bool operator==(const Media &other) const;
+    virtual bool operator==(const Media &other) const;
   
   void accept(IConstMediaVisitor &) const override;
   bool open() override;
diff --git a/src/StringUtils.h b/src/Media/StringUtils.h
similarity index 100%
rename from src/StringUtils.h
rename to src/Media/StringUtils.h
diff --git a/src/main.cpp b/src/main.cpp
index 57bbbbb..55a15bc 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -2,7 +2,7 @@
 #include <memory>
 #include <vector>
 #include <limits>
-#include "Media.h"  // Include il tuo header
+#include "Media/Media.h"  // Include il tuo header
 
 int main() {
     // Crea alcuni media
@@ -10,24 +10,24 @@ int main() {
         "House of Cards",
         2013,
         "English",
-        std::vector<std::string>{"Drama", "Politics"},
-        true
+        true,
+        std::vector<std::string>{"Drama", "Politics"}
     );
 
     auto media2 = std::make_shared<media::Media>(
         "The Crown",
         2016,
         "English",
-        std::vector<std::string>{"History", "Drama"},
-        false
+        false,
+        std::vector<std::string>{"History", "Drama"}
     );
 
     auto media3 = std::make_shared<media::Media>(
         "Breaking Bad",
         2008,
         "English",
-        std::vector<std::string>{"Crime", "Thriller"},
-        false
+        false,
+        std::vector<std::string>{"Crime", "Thriller"}
     );
 
     // Inserisci i media in un vettore
@@ -36,14 +36,13 @@ int main() {
     // Crea un oggetto Media come filtro
     auto filterMedia = std::make_shared<media::Media>(
         "Ho",
-        std::numeric_limits<int>::min(), 
-        "dra"
+        std::numeric_limits<int>::min()
     );
     
     // Filtra
     std::vector<std::shared_ptr<media::Media>> filtered = filterMedia->filter(inputList);
 
-    // Stampa i risultati
+    //Stampa i risultati
     std::cout << "Media che passano il filtro:\n";
     for (const auto& m : filtered) {
         std::cout << "- " << m->getTitle() << "\n";

From 36fe7d7d0593a5f4322a6f8867058c6dbb7b6418 Mon Sep 17 00:00:00 2001
From: Steva0 <michele.stevanin@gmail.com>
Date: Tue, 20 May 2025 14:28:29 +0200
Subject: [PATCH 09/16] Modficia .gitignore

---
 .gitignore | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.gitignore b/.gitignore
index 33447a5..9b61d93 100644
--- a/.gitignore
+++ b/.gitignore
@@ -11,6 +11,8 @@
 *.dylib
 Build
 checks.json
+.vscode
+build
 
 # Qt-es
 object_script.*.Release

From 2886b1353d4cf9a448bb667caf64a8f02471e181 Mon Sep 17 00:00:00 2001
From: Steva0 <michele.stevanin@gmail.com>
Date: Tue, 20 May 2025 16:06:02 +0200
Subject: [PATCH 10/16] Metodi filter aggiunti ovunque

---
 src/Media/Album.cpp           | 60 +++++++++++++++++++++++
 src/Media/Album.h             |  3 ++
 src/Media/AudioBook.cpp       | 29 +++++++++++
 src/Media/AudioBook.h         |  2 +
 src/Media/Ebook.cpp           | 30 ++++++++++++
 src/Media/Ebook.h             |  3 ++
 src/Media/Movie.cpp           | 48 +++++++++++++++++++
 src/Media/Movie.h             |  2 +
 src/Media/Novel.cpp           |  4 +-
 src/Media/Novel.h             |  2 +-
 src/Media/Series.cpp          | 33 +++++++++++++
 src/Media/Series.h            |  2 +
 src/Memory/MediaContainer.cpp | 90 ++++++++++++++++++++++++++++-------
 src/Memory/MediaContainer.h   | 25 +++++-----
 14 files changed, 302 insertions(+), 31 deletions(-)

diff --git a/src/Media/Album.cpp b/src/Media/Album.cpp
index 4f3453c..d19e638 100644
--- a/src/Media/Album.cpp
+++ b/src/Media/Album.cpp
@@ -26,4 +26,64 @@ bool Album::operator==(const Media &other) const {
   return false;
 }
 
+std::vector<std::shared_ptr<Media>> Album::filter(const std::vector<std::shared_ptr<Album>>& input) const {
+    std::vector<std::shared_ptr<Media>> result;
+
+    // Riutilizzo filtro base di Media
+    std::vector<std::shared_ptr<Media>> baseInput(input.begin(), input.end());
+    std::vector<std::shared_ptr<Media>> filteredBase = Media::filter(baseInput);
+
+    // Filtro specifico per Album
+    for (const auto& mediaPtr : filteredBase) {
+        auto albumPtr = std::dynamic_pointer_cast<Album>(mediaPtr);
+        if (!albumPtr) continue;
+
+        bool match = true;
+
+        // Band
+        if (!band_.empty() && !stringContainsIgnoreCase(albumPtr->getBand(), band_))
+            match = false;
+
+        // Band members (ogni membro richiesto deve matchare almeno uno esistente)
+        if (!band_members_.empty()) {
+            for (const auto& memberFilter : band_members_) {
+                bool found = false;
+                for (const auto& m : albumPtr->getBandMembers()) {
+                    if (stringContainsIgnoreCase(m, memberFilter)) {
+                        found = true;
+                        break;
+                    }
+                }
+                if (!found) {
+                    match = false;
+                    break;
+                }
+            }
+        }
+
+        // Songs (ogni canzone richiesta deve matchare almeno una esistente)
+        if (!songs_.empty()) {
+            for (const auto& songFilter : songs_) {
+                bool found = false;
+                for (const auto& s : albumPtr->getSongs()) {
+                    if (stringContainsIgnoreCase(s, songFilter)) {
+                        found = true;
+                        break;
+                    }
+                }
+                if (!found) {
+                    match = false;
+                    break;
+                }
+            }
+        }
+
+        if (match)
+            result.push_back(albumPtr);
+    }
+
+    return result;
+}
+
+
 }  // namespace media
diff --git a/src/Media/Album.h b/src/Media/Album.h
index c2d5bbc..da0fd7c 100644
--- a/src/Media/Album.h
+++ b/src/Media/Album.h
@@ -19,6 +19,9 @@ class Album : public Media {
   const std::vector<std::string> &getBandMembers() const;
   const std::vector<std::string> &getSongs() const;
   bool operator==(const Media &other) const override;
+
+  std::vector<std::shared_ptr<Media>> filter(const std::vector<std::shared_ptr<Album>>& input) const;
+
 };
 }  // namespace media
 #endif
diff --git a/src/Media/AudioBook.cpp b/src/Media/AudioBook.cpp
index 4a85455..89f43ca 100644
--- a/src/Media/AudioBook.cpp
+++ b/src/Media/AudioBook.cpp
@@ -37,4 +37,33 @@ void AudioBook::setStreamingService(const std::string& service) {
     streamingService_ = service;
 }
 
+std::vector<std::shared_ptr<Media>> AudioBook::filter(const std::vector<std::shared_ptr<AudioBook>>& input) const {
+    std::vector<std::shared_ptr<Media>> result;
+
+    // Riutilizza filtro base di Novel (che include filtro di Media)
+    std::vector<std::shared_ptr<Novel>> novels(input.begin(), input.end());
+    std::vector<std::shared_ptr<Media>> filteredNovels = Novel::filter(novels);
+
+    // Filtro specifico AudioBook
+    for (const auto& novelPtr : filteredNovels) {
+        auto audiobookPtr = std::dynamic_pointer_cast<AudioBook>(novelPtr);
+        if (!audiobookPtr) continue;
+
+        bool match = true;
+
+        // File size
+        if (narrator_ != "" && audiobookPtr->getNarrator()!= narrator_)
+            match = false;
+
+        // DRM
+        if (streamingService_ != "" && audiobookPtr->getStreamingService() != streamingService_)
+            match = false;
+
+        if (match)
+            result.push_back(audiobookPtr);
+    }
+
+    return result;
+}
+
 }
\ No newline at end of file
diff --git a/src/Media/AudioBook.h b/src/Media/AudioBook.h
index 999ab78..b674797 100644
--- a/src/Media/AudioBook.h
+++ b/src/Media/AudioBook.h
@@ -25,6 +25,8 @@ class AudioBook : public Novel {
 
     void setNarrator(const std::string& narrator);
     void setStreamingService(const std::string& service);
+
+    std::vector<std::shared_ptr<Media>> filter(const std::vector<std::shared_ptr<AudioBook>>& input) const;
 };
 
 }
diff --git a/src/Media/Ebook.cpp b/src/Media/Ebook.cpp
index c12bf2a..60a10c4 100644
--- a/src/Media/Ebook.cpp
+++ b/src/Media/Ebook.cpp
@@ -36,4 +36,34 @@ void Ebook::setDrm(bool drm) {
     drm_ = drm;
 }
 
+std::vector<std::shared_ptr<Media>> Ebook::filter(const std::vector<std::shared_ptr<Ebook>>& input) const {
+    std::vector<std::shared_ptr<Media>> result;
+
+    // Riutilizza filtro base di Novel (che include filtro di Media)
+    std::vector<std::shared_ptr<Novel>> novels(input.begin(), input.end());
+    std::vector<std::shared_ptr<Media>> filteredNovels = Novel::filter(novels);
+
+    // Filtro specifico Ebook
+    for (const auto& novelPtr : filteredNovels) {
+        auto ebookPtr = std::dynamic_pointer_cast<Ebook>(novelPtr);
+        if (!ebookPtr) continue;
+
+        bool match = true;
+
+        // File size
+        if (fileSizeBytes_ > 0 && ebookPtr->getFileSizeBytes() != fileSizeBytes_)
+            match = false;
+
+        // DRM
+        if (drm_ && ebookPtr->hasDrm() != drm_)
+            match = false;
+
+        if (match)
+            result.push_back(ebookPtr);
+    }
+
+    return result;
+}
+
+
 }
\ No newline at end of file
diff --git a/src/Media/Ebook.h b/src/Media/Ebook.h
index 5d5312a..b8282e8 100644
--- a/src/Media/Ebook.h
+++ b/src/Media/Ebook.h
@@ -24,6 +24,9 @@ class Ebook : public Novel {
 
     void setFileSizeBytes(unsigned int size);
     void setDrm(bool drm);
+
+    std::vector<std::shared_ptr<Media>> filter(const std::vector<std::shared_ptr<Ebook>>& input) const;
+
 };
 
 }
diff --git a/src/Media/Movie.cpp b/src/Media/Movie.cpp
index 026eb63..6d83d6b 100644
--- a/src/Media/Movie.cpp
+++ b/src/Media/Movie.cpp
@@ -21,4 +21,52 @@ bool Movie::operator==(const Media &other) const {
 const std::vector<std::string> &Movie::getCast() const { return cast_; }
 unsigned int Movie::getLength() const { return length_; }
 const std::string &Movie::getUniverse() const { return universe_; }
+
+std::vector<std::shared_ptr<Media>> Movie::filter(const std::vector<std::shared_ptr<Movie>>& input) const {
+    std::vector<std::shared_ptr<Media>> result;
+
+    // Riutilizza filtro base di Media (poiché Movie deriva da Media)
+    std::vector<std::shared_ptr<Media>> baseInput(input.begin(), input.end());
+    std::vector<std::shared_ptr<Media>> filteredBase = Media::filter(baseInput);
+
+    for (const auto& mediaPtr : filteredBase) {
+        auto moviePtr = std::dynamic_pointer_cast<Movie>(mediaPtr);
+        if (!moviePtr) continue;
+
+        bool match = true;
+
+        // Cast (match parziale, case-insensitive)
+        if (!cast_.empty()) {
+            const auto& movieCast = moviePtr->getCast();
+            for (const auto& filterCast : cast_) {
+                bool found = false;
+                for (const auto& member : movieCast) {
+                    if (stringContainsIgnoreCase(member, filterCast)) {
+                        found = true;
+                        break;
+                    }
+                }
+                if (!found) {
+                    match = false;
+                    break;
+                }
+            }
+        }
+
+        // Length (confronto stretto)
+        if (length_ != std::numeric_limits<unsigned int>::max() && moviePtr->getLength() != length_)
+            match = false;
+
+        // Universe (match parziale, case-insensitive)
+        if (!universe_.empty() && !stringContainsIgnoreCase(moviePtr->getUniverse(), universe_))
+            match = false;
+
+        if (match)
+            result.push_back(moviePtr);
+    }
+
+    return result;
+}
+
+
 }  // namespace media
diff --git a/src/Media/Movie.h b/src/Media/Movie.h
index d630377..c37d134 100644
--- a/src/Media/Movie.h
+++ b/src/Media/Movie.h
@@ -23,6 +23,8 @@ class Movie : public Media {
   const std::vector<std::string> &getCast() const;
   unsigned int getLength() const;
   const std::string &getUniverse() const;
+
+  std::vector<std::shared_ptr<Media>> filter(const std::vector<std::shared_ptr<Movie>>& input) const;
 };
 }  // namespace media
 #endif
diff --git a/src/Media/Novel.cpp b/src/Media/Novel.cpp
index 133775e..88f9195 100644
--- a/src/Media/Novel.cpp
+++ b/src/Media/Novel.cpp
@@ -34,8 +34,8 @@ void Novel::setSeries(const std::string& series) { series_ = series; }
 void Novel::setIsbn(const std::string& isbn) { isbn_ = isbn; }
 
 
-std::vector<std::shared_ptr<Novel>> Novel::filter(const std::vector<std::shared_ptr<Novel>>& input) const {
-    std::vector<std::shared_ptr<Novel>> result;
+std::vector<std::shared_ptr<Media>> Novel::filter(const std::vector<std::shared_ptr<Novel>>& input) const {
+    std::vector<std::shared_ptr<Media>> result;
 
     // Riutilizzo del filtro base di Media
     std::vector<std::shared_ptr<Media>> baseInput(input.begin(), input.end());
diff --git a/src/Media/Novel.h b/src/Media/Novel.h
index 8fba19d..f5fb608 100644
--- a/src/Media/Novel.h
+++ b/src/Media/Novel.h
@@ -35,7 +35,7 @@ class Novel : public Media {
     void setSeries(const std::string& series);
     void setIsbn(const std::string& isbn);
 
-    std::vector<std::shared_ptr<Novel>> filter(const std::vector<std::shared_ptr<Novel>> &novel) const;
+    std::vector<std::shared_ptr<Media>> filter(const std::vector<std::shared_ptr<Novel>> &novel) const;
 };
 
 }
diff --git a/src/Media/Series.cpp b/src/Media/Series.cpp
index 4004f93..3dd0a1f 100644
--- a/src/Media/Series.cpp
+++ b/src/Media/Series.cpp
@@ -24,4 +24,37 @@ bool Series::operator==(const Media &other) const {
 unsigned int Series::getEpisodes() const { return episodes_; }
 unsigned int Series::getSeasons() const { return seasons_; }
 bool Series::isEnded() const { return ended_; }
+
+std::vector<std::shared_ptr<Media>> Series::filter(const std::vector<std::shared_ptr<Series>>& input) const {
+    std::vector<std::shared_ptr<Media>> result;
+
+    // Riutilizzo filtro base di Movie (che a sua volta chiama Media::filter)
+    std::vector<std::shared_ptr<Movie>> baseInput(input.begin(), input.end());
+    std::vector<std::shared_ptr<Media>> filteredBase = Movie::filter(baseInput);
+
+    for (const auto& mediaPtr : filteredBase) {
+        auto seriesPtr = std::dynamic_pointer_cast<Series>(mediaPtr);
+        if (!seriesPtr) continue;
+
+        bool match = true;
+
+        // Episodes (confronto stretto)
+        if (episodes_ != std::numeric_limits<unsigned int>::max() && seriesPtr->getEpisodes() != episodes_)
+            match = false;
+
+        // Seasons (confronto stretto)
+        if (seasons_ != std::numeric_limits<unsigned int>::max() && seriesPtr->getSeasons() != seasons_)
+            match = false;
+
+        // Ended (confronto booleano)
+        if (ended_ && ended_ != seriesPtr->isEnded())
+            match = false;
+
+        if (match)
+            result.push_back(seriesPtr);
+    }
+
+    return result;
+}
+
 }  // namespace media
diff --git a/src/Media/Series.h b/src/Media/Series.h
index 15b1649..a950cb2 100644
--- a/src/Media/Series.h
+++ b/src/Media/Series.h
@@ -20,6 +20,8 @@ class Series : public Movie {
   unsigned int getEpisodes() const;
   unsigned int getSeasons() const;
   bool isEnded() const;
+
+  std::vector<std::shared_ptr<Media>> filter(const std::vector<std::shared_ptr<Series>>& input) const;
 };
 }  // namespace media
 #endif
diff --git a/src/Memory/MediaContainer.cpp b/src/Memory/MediaContainer.cpp
index f5c6f1b..ca51afd 100644
--- a/src/Memory/MediaContainer.cpp
+++ b/src/Memory/MediaContainer.cpp
@@ -1,4 +1,5 @@
 #include "MediaContainer.h"
+
 namespace memory {
 
 void MediaContainer::addMedia(const std::shared_ptr<media::Media>& media) {
@@ -46,18 +47,14 @@ std::vector<std::shared_ptr<media::Media>> MediaContainer::getByTypeAndSubtype(M
             result.insert(result.end(), data_[static_cast<size_t>(MediaType::EBook)].begin(), data_[static_cast<size_t>(MediaType::EBook)].end());
             result.insert(result.end(), data_[static_cast<size_t>(MediaType::AudioBook)].begin(), data_[static_cast<size_t>(MediaType::AudioBook)].end());
             break;
-
         case MediaType::Movie:
             result.insert(result.end(), data_[static_cast<size_t>(MediaType::Movie)].begin(), data_[static_cast<size_t>(MediaType::Movie)].end());
             result.insert(result.end(), data_[static_cast<size_t>(MediaType::Series)].begin(), data_[static_cast<size_t>(MediaType::Series)].end());
             break;
-
         case MediaType::All:
-            result = data_[0]; // Tutti i media
+            result = data_[0];
             break;
-
         default:
-            // Ritorna il vettore corrispondente solo per quel tipo specifico
             result = data_[static_cast<size_t>(type)];
             break;
     }
@@ -65,7 +62,6 @@ std::vector<std::shared_ptr<media::Media>> MediaContainer::getByTypeAndSubtype(M
     return result;
 }
 
-
 MediaType MediaContainer::determineType(const std::shared_ptr<media::Media>& media) const {
     if (std::dynamic_pointer_cast<media::Series>(media)) return MediaType::Series;
     if (std::dynamic_pointer_cast<media::Movie>(media)) return MediaType::Movie;
@@ -76,19 +72,79 @@ MediaType MediaContainer::determineType(const std::shared_ptr<media::Media>& med
     return MediaType::All;
 }
 
-std::vector<std::shared_ptr<media::Media>> MediaContainer::filter(const std::shared_ptr<media::Media>& media) const{
+std::vector<std::shared_ptr<media::Media>> MediaContainer::filter(const std::shared_ptr<media::Media>& media) const {
+    if (auto m = std::dynamic_pointer_cast<media::Series>(media)) return filters(m);
+    if (auto m = std::dynamic_pointer_cast<media::Movie>(media)) return filters(m);
+    if (auto m = std::dynamic_pointer_cast<media::AudioBook>(media)) return filters(m);
+    if (auto m = std::dynamic_pointer_cast<media::Ebook>(media)) return filters(m);
+    if (auto m = std::dynamic_pointer_cast<media::Novel>(media)) return filters(m);
+    if (auto m = std::dynamic_pointer_cast<media::Album>(media)) return filters(m);
+    return filters(media);
+}
+
+std::vector<std::shared_ptr<media::Media>> MediaContainer::filters(const std::shared_ptr<media::Media>& media) const {
     auto allMedia = getAll();
     return media->filter(allMedia);
 }
 
-std::vector<std::shared_ptr<media::Novel>> MediaContainer::filter(const std::shared_ptr<media::Novel>& novel) const{
-    auto media= getByTypeAndSubtype(MediaType::Novel);
+std::vector<std::shared_ptr<media::Media>> MediaContainer::filters(const std::shared_ptr<media::Novel>& novel) const {
+    auto media = getByTypeAndSubtype(MediaType::Novel);
     std::vector<std::shared_ptr<media::Novel>> allNovel;
-    for (const auto& mediaPtr : media) {
-        auto novelPtr = std::dynamic_pointer_cast<media::Novel>(mediaPtr);
-        if (novelPtr) {
-            allNovel.push_back(novelPtr);
-        }
-    }
-    return novel->filter(allNovel);
-}
\ No newline at end of file
+    for (const auto& m : media)
+        if (auto ptr = std::dynamic_pointer_cast<media::Novel>(m)) allNovel.push_back(ptr);
+    std::vector<std::shared_ptr<media::Media>> result;
+    for (const auto& m : novel->filter(allNovel)) result.push_back(m);
+    return result;
+}
+
+std::vector<std::shared_ptr<media::Media>> MediaContainer::filters(const std::shared_ptr<media::Album>& album) const {
+    auto media = getByType(MediaType::Album);
+    std::vector<std::shared_ptr<media::Album>> allAlbum;
+    for (const auto& m : media)
+        if (auto ptr = std::dynamic_pointer_cast<media::Album>(m)) allAlbum.push_back(ptr);
+    std::vector<std::shared_ptr<media::Media>> result;
+    for (const auto& m : album->filter(allAlbum)) result.push_back(m);
+    return result;
+}
+
+std::vector<std::shared_ptr<media::Media>> MediaContainer::filters(const std::shared_ptr<media::Movie>& movie) const {
+    auto media = getByTypeAndSubtype(MediaType::Movie);
+    std::vector<std::shared_ptr<media::Movie>> allMovie;
+    for (const auto& m : media)
+        if (auto ptr = std::dynamic_pointer_cast<media::Movie>(m)) allMovie.push_back(ptr);
+    std::vector<std::shared_ptr<media::Media>> result;
+    for (const auto& m : movie->filter(allMovie)) result.push_back(m);
+    return result;
+}
+
+std::vector<std::shared_ptr<media::Media>> MediaContainer::filters(const std::shared_ptr<media::Ebook>& ebook) const {
+    auto media = getByType(MediaType::EBook);
+    std::vector<std::shared_ptr<media::Ebook>> allEbook;
+    for (const auto& m : media)
+        if (auto ptr = std::dynamic_pointer_cast<media::Ebook>(m)) allEbook.push_back(ptr);
+    std::vector<std::shared_ptr<media::Media>> result;
+    for (const auto& m : ebook->filter(allEbook)) result.push_back(m);
+    return result;
+}
+
+std::vector<std::shared_ptr<media::Media>> MediaContainer::filters(const std::shared_ptr<media::AudioBook>& audiobook) const {
+    auto media = getByType(MediaType::AudioBook);
+    std::vector<std::shared_ptr<media::AudioBook>> allAudio;
+    for (const auto& m : media)
+        if (auto ptr = std::dynamic_pointer_cast<media::AudioBook>(m)) allAudio.push_back(ptr);
+    std::vector<std::shared_ptr<media::Media>> result;
+    for (const auto& m : audiobook->filter(allAudio)) result.push_back(m);
+    return result;
+}
+
+std::vector<std::shared_ptr<media::Media>> MediaContainer::filters(const std::shared_ptr<media::Series>& series) const {
+    auto media = getByType(MediaType::Series);
+    std::vector<std::shared_ptr<media::Series>> allSeries;
+    for (const auto& m : media)
+        if (auto ptr = std::dynamic_pointer_cast<media::Series>(m)) allSeries.push_back(ptr);
+    std::vector<std::shared_ptr<media::Media>> result;
+    for (const auto& m : series->filter(allSeries)) result.push_back(m);
+    return result;
+}
+
+} // namespace memory
diff --git a/src/Memory/MediaContainer.h b/src/Memory/MediaContainer.h
index 2fdfb6e..19c018e 100644
--- a/src/Memory/MediaContainer.h
+++ b/src/Memory/MediaContainer.h
@@ -6,7 +6,6 @@
 #include <memory>
 #include <string>
 #include <algorithm>
-#include <functional>
 
 #include "Media.h"
 #include "Novel.h"
@@ -16,7 +15,7 @@
 #include "AudioBook.h"
 #include "Series.h"
 
-namespace memory{
+namespace memory {
 
 enum class MediaType {
     All = 0,
@@ -26,7 +25,7 @@ enum class MediaType {
     EBook,
     AudioBook,
     Series,
-    Count // serve per la dimensione dell’array
+    Count
 };
 
 class MediaContainer {
@@ -35,6 +34,14 @@ class MediaContainer {
 
     MediaType determineType(const std::shared_ptr<media::Media>& media) const;
 
+    std::vector<std::shared_ptr<media::Media>> filters(const std::shared_ptr<media::Media>& media) const;
+    std::vector<std::shared_ptr<media::Media>> filters(const std::shared_ptr<media::Novel>& novel) const;
+    std::vector<std::shared_ptr<media::Media>> filters(const std::shared_ptr<media::Album>& album) const;
+    std::vector<std::shared_ptr<media::Media>> filters(const std::shared_ptr<media::Movie>& movie) const;
+    std::vector<std::shared_ptr<media::Media>> filters(const std::shared_ptr<media::Ebook>& ebook) const;
+    std::vector<std::shared_ptr<media::Media>> filters(const std::shared_ptr<media::AudioBook>& audiobook) const;
+    std::vector<std::shared_ptr<media::Media>> filters(const std::shared_ptr<media::Series>& series) const;
+
 public:
     void addMedia(const std::shared_ptr<media::Media>& media);
     void removeMedia(const std::shared_ptr<media::Media>& media);
@@ -44,15 +51,11 @@ class MediaContainer {
     std::vector<std::shared_ptr<media::Media>> getByType(MediaType type) const;
     std::vector<std::shared_ptr<media::Media>> getByTypeAndSubtype(MediaType type) const;
 
-    //Sezione filtri
+    // Filtri
     std::vector<std::shared_ptr<media::Media>> filter(const std::shared_ptr<media::Media>& media) const;
-    std::vector<std::shared_ptr<media::Novel>> filter(const std::shared_ptr<media::Novel>& novel) const;
-    std::vector<std::shared_ptr<media::Album>> filter(const std::shared_ptr<media::Album>& album) const;
-    std::vector<std::shared_ptr<media::Movie>> filter(const std::shared_ptr<media::Movie>& movie) const;
-    std::vector<std::shared_ptr<media::Ebook>> filter(const std::shared_ptr<media::Ebook>& ebook) const;
-    std::vector<std::shared_ptr<media::AudioBook>> filter(const std::shared_ptr<media::AudioBook>& audiobook) const;
-    std::vector<std::shared_ptr<media::Series>> filter(const std::shared_ptr<media::Series>& series) const;
 
 };
-}
+
+} // namespace memory
+
 #endif // MEMORY_MEDIACONTAINER_H

From 60a6ad8d2f4f570ca113123c074c90b5f411a82d Mon Sep 17 00:00:00 2001
From: Steva0 <michele.stevanin@gmail.com>
Date: Tue, 20 May 2025 16:09:36 +0200
Subject: [PATCH 11/16] Modificato nome programma .pro

---
 src/src.pro | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/src.pro b/src/src.pro
index 131b69f..a6c6f88 100644
--- a/src/src.pro
+++ b/src/src.pro
@@ -3,7 +3,7 @@
 ######################################################################
 
 TEMPLATE = app
-TARGET = src
+TARGET = MediaLibrary
 INCLUDEPATH += .
 QT += widgets
 

From a6dab30562e32f20c8040468ee59b073b81607c0 Mon Sep 17 00:00:00 2001
From: Steva0 <michele.stevanin@gmail.com>
Date: Tue, 20 May 2025 16:09:59 +0200
Subject: [PATCH 12/16] Modificato nome .pro

---
 src/{src.pro => MediaLibrary.pro} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename src/{src.pro => MediaLibrary.pro} (100%)

diff --git a/src/src.pro b/src/MediaLibrary.pro
similarity index 100%
rename from src/src.pro
rename to src/MediaLibrary.pro

From 15db58b665a3a7ab592637732895462555ddc1c0 Mon Sep 17 00:00:00 2001
From: Steva0 <michele.stevanin@gmail.com>
Date: Tue, 20 May 2025 16:12:29 +0200
Subject: [PATCH 13/16] Sistemati nomi file

---
 src/Memory/Deserializer.h | 7 ++++---
 src/Memory/Serializer.h   | 7 +++----
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/Memory/Deserializer.h b/src/Memory/Deserializer.h
index c86b172..12e1040 100644
--- a/src/Memory/Deserializer.h
+++ b/src/Memory/Deserializer.h
@@ -1,16 +1,17 @@
 #ifndef MEMORY_DESERIALIZER_H
 #define MEMORY_DESERIALIZER_H
 #include <QFile>
+
 #include "../Media/Media.h"
 
 namespace memory {
 class Deserializer {
  private:
-  static int vecToJSON(const std::vector<media::Media *> &, QFile &);
-  static int vecToXML(const std::vector<media::Media *> &, QFile &);
+  static std::vector<media::Media *>& XMLtoVec(const QFile &);
+  static std::vector<media::Media *>& JSONtoVec(const QFile &);
 
  public:
-  static int deserialize(const std::vector<media::Media *> &, QFile &);
+  static std::vector<media::Media *>& deserialize(const QFile &);
 };
 }  // namespace memory
 #endif
diff --git a/src/Memory/Serializer.h b/src/Memory/Serializer.h
index f34aad0..79b0546 100644
--- a/src/Memory/Serializer.h
+++ b/src/Memory/Serializer.h
@@ -1,17 +1,16 @@
 #ifndef MEMORY_SERIALIZER_H
 #define MEMORY_SERIALIZER_H
 #include <QFile>
-
 #include "../Media/Media.h"
 
 namespace memory {
 class Serializer {
  private:
-  static std::vector<media::Media *>& XMLtoVec(const QFile &);
-  static std::vector<media::Media *>& JSONtoVec(const QFile &);
+  static int vecToJSON(const std::vector<media::Media *> &, QFile &);
+  static int vecToXML(const std::vector<media::Media *> &, QFile &);
 
  public:
-  static std::vector<media::Media *>& serialize(const QFile &);
+  static int Serialize(const std::vector<media::Media *> &, QFile &);
 };
 }  // namespace memory
 #endif

From 91e29abf535d34eb2ef7e8e897d3186436c9a274 Mon Sep 17 00:00:00 2001
From: Steva0 <michele.stevanin@gmail.com>
Date: Tue, 20 May 2025 16:15:27 +0200
Subject: [PATCH 14/16] Sistemati #ifndef

---
 src/Media/AudioBook.h   | 6 +++---
 src/Media/Ebook.h       | 6 +++---
 src/Media/IMedia.h      | 7 ++-----
 src/Media/Novel.h       | 6 +++---
 src/Media/Series.h      | 4 ++--
 src/Media/StringUtils.h | 6 +++---
 6 files changed, 16 insertions(+), 19 deletions(-)

diff --git a/src/Media/AudioBook.h b/src/Media/AudioBook.h
index b674797..38d77fa 100644
--- a/src/Media/AudioBook.h
+++ b/src/Media/AudioBook.h
@@ -1,5 +1,5 @@
-#ifndef AudioBook_H
-#define AudioBook_H
+#ifndef MEDIA_AUDIOBOOK_H
+#define MEDIA_AUDIOBOOK_H
 
 #include "Novel.h"
 
@@ -31,4 +31,4 @@ class AudioBook : public Novel {
 
 }
 
-#endif // AudioBook_H
\ No newline at end of file
+#endif // MEDIA_AUDIOBOOK_H
\ No newline at end of file
diff --git a/src/Media/Ebook.h b/src/Media/Ebook.h
index b8282e8..d2ba138 100644
--- a/src/Media/Ebook.h
+++ b/src/Media/Ebook.h
@@ -1,5 +1,5 @@
-#ifndef EBOOK_H
-#define EBOOK_H
+#ifndef MEDIA_EBOOK_H
+#define MEDIA_EBOOK_H
 
 #include "Novel.h"
 
@@ -31,4 +31,4 @@ class Ebook : public Novel {
 
 }
 
-#endif // EBOOK_H
\ No newline at end of file
+#endif // MEDIA_EBOOK_H
\ No newline at end of file
diff --git a/src/Media/IMedia.h b/src/Media/IMedia.h
index 4f603b7..d2ffa8b 100644
--- a/src/Media/IMedia.h
+++ b/src/Media/IMedia.h
@@ -1,12 +1,10 @@
-#ifndef IMedia_H
-#define IMedia_H
+#ifndef MEDIA_IMedia_H
+#define MEDIA_IMedia_H
 
 #include "IConstMediaVisitor.h"
 
-
 namespace media {
 
-
 class IMedia {
     virtual void accept(IConstMediaVisitor &) const = 0;
     virtual bool open() = 0;
@@ -14,5 +12,4 @@ class IMedia {
 
 }
 
-
 #endif
\ No newline at end of file
diff --git a/src/Media/Novel.h b/src/Media/Novel.h
index f5fb608..64f91c9 100644
--- a/src/Media/Novel.h
+++ b/src/Media/Novel.h
@@ -1,5 +1,5 @@
-#ifndef Romanzo_H
-#define Romanzo_H
+#ifndef MEDIA_ROMANZO_H
+#define MEDIA_ROMANZO_H
 
 #include "Media.h"
 
@@ -39,4 +39,4 @@ class Novel : public Media {
 };
 
 }
-#endif // Novel_H
\ No newline at end of file
+#endif // MEDIA_ROMANZO_H
\ No newline at end of file
diff --git a/src/Media/Series.h b/src/Media/Series.h
index a950cb2..42118bc 100644
--- a/src/Media/Series.h
+++ b/src/Media/Series.h
@@ -23,5 +23,5 @@ class Series : public Movie {
 
   std::vector<std::shared_ptr<Media>> filter(const std::vector<std::shared_ptr<Series>>& input) const;
 };
-}  // namespace media
-#endif
+}  
+#endif  // MEDIA_SERIES_H
diff --git a/src/Media/StringUtils.h b/src/Media/StringUtils.h
index 5be116a..9d52635 100644
--- a/src/Media/StringUtils.h
+++ b/src/Media/StringUtils.h
@@ -1,5 +1,5 @@
-#ifndef STRINGUTILS_H
-#define STRINGUTILS_H
+#ifndef MEDIA_STRINGUTILS_H
+#define MEDIA_STRINGUTILS_H
 
 #include <string>
 #include <algorithm>
@@ -17,4 +17,4 @@ inline bool stringContainsIgnoreCase(const std::string& text, const std::string&
     return toLowerCase(text).find(toLowerCase(pattern)) != std::string::npos;
 }
 }
-#endif // STRINGUTILS_H
+#endif // MEDIA_STRINGUTILS_H

From b7a36248c18d0b0aff5510ba61e3811a5f930228 Mon Sep 17 00:00:00 2001
From: Steva0 <michele.stevanin@gmail.com>
Date: Tue, 20 May 2025 16:33:33 +0200
Subject: [PATCH 15/16] Sistemato interfacce e parte di Filtri

---
 src/Memory/Deserializer.h     | 6 +++---
 src/Memory/MediaContainer.cpp | 4 ++++
 src/Memory/MediaContainer.h   | 3 +++
 src/Memory/Serializer.h       | 8 ++++----
 4 files changed, 14 insertions(+), 7 deletions(-)

diff --git a/src/Memory/Deserializer.h b/src/Memory/Deserializer.h
index 12e1040..d44d427 100644
--- a/src/Memory/Deserializer.h
+++ b/src/Memory/Deserializer.h
@@ -7,11 +7,11 @@
 namespace memory {
 class Deserializer {
  private:
-  static std::vector<media::Media *>& XMLtoVec(const QFile &);
-  static std::vector<media::Media *>& JSONtoVec(const QFile &);
+  static std::vector<std::shared_ptr<media::Media>>& XMLtoVec(const QFile &);
+  static std::vector<std::shared_ptr<media::Media>>& JSONtoVec(const QFile &);
 
  public:
-  static std::vector<media::Media *>& deserialize(const QFile &);
+  static std::vector<std::shared_ptr<media::Media>>& deserialize(const QFile &);
 };
 }  // namespace memory
 #endif
diff --git a/src/Memory/MediaContainer.cpp b/src/Memory/MediaContainer.cpp
index ca51afd..c92553c 100644
--- a/src/Memory/MediaContainer.cpp
+++ b/src/Memory/MediaContainer.cpp
@@ -147,4 +147,8 @@ std::vector<std::shared_ptr<media::Media>> MediaContainer::filters(const std::sh
     return result;
 }
 
+int MediaContainer::serialize(QSaveFile& file) const {
+    return Serializer::Serialize(getAll(), file);
+}
+
 } // namespace memory
diff --git a/src/Memory/MediaContainer.h b/src/Memory/MediaContainer.h
index 19c018e..38ea5ec 100644
--- a/src/Memory/MediaContainer.h
+++ b/src/Memory/MediaContainer.h
@@ -6,6 +6,7 @@
 #include <memory>
 #include <string>
 #include <algorithm>
+#include <QSaveFile>
 
 #include "Media.h"
 #include "Novel.h"
@@ -14,6 +15,7 @@
 #include "Ebook.h"
 #include "AudioBook.h"
 #include "Series.h"
+#include "Serializer.h"
 
 namespace memory {
 
@@ -54,6 +56,7 @@ class MediaContainer {
     // Filtri
     std::vector<std::shared_ptr<media::Media>> filter(const std::shared_ptr<media::Media>& media) const;
 
+    int serialize(QSaveFile& file) const;
 };
 
 } // namespace memory
diff --git a/src/Memory/Serializer.h b/src/Memory/Serializer.h
index 79b0546..34b5fa9 100644
--- a/src/Memory/Serializer.h
+++ b/src/Memory/Serializer.h
@@ -1,16 +1,16 @@
 #ifndef MEMORY_SERIALIZER_H
 #define MEMORY_SERIALIZER_H
-#include <QFile>
+#include <QSaveFile>
 #include "../Media/Media.h"
 
 namespace memory {
 class Serializer {
  private:
-  static int vecToJSON(const std::vector<media::Media *> &, QFile &);
-  static int vecToXML(const std::vector<media::Media *> &, QFile &);
+  static int vecToJSON(const std::vector<std::shared_ptr<media::Media>> &, QSaveFile &);
+  static int vecToXML(const std::vector<std::shared_ptr<media::Media>> &, QSaveFile &);
 
  public:
-  static int Serialize(const std::vector<media::Media *> &, QFile &);
+  static int Serialize(const std::vector<std::shared_ptr<media::Media>> &, QSaveFile &);
 };
 }  // namespace memory
 #endif

From 548e73cb16acad53839ef8e16355380091fbaa7e Mon Sep 17 00:00:00 2001
From: Steva0 <michele.stevanin@gmail.com>
Date: Tue, 20 May 2025 17:07:32 +0200
Subject: [PATCH 16/16] Sistemato riferimenti

---
 src/Memory/MediaContainer.cpp | 24 +++++++++++++-----------
 src/Memory/MediaContainer.h   | 12 ++++++------
 2 files changed, 19 insertions(+), 17 deletions(-)

diff --git a/src/Memory/MediaContainer.cpp b/src/Memory/MediaContainer.cpp
index c92553c..7d9c177 100644
--- a/src/Memory/MediaContainer.cpp
+++ b/src/Memory/MediaContainer.cpp
@@ -30,15 +30,15 @@ void MediaContainer::clear() {
     }
 }
 
-std::vector<std::shared_ptr<media::Media>> MediaContainer::getAll() const {
+const std::vector<std::shared_ptr<media::Media>>& MediaContainer::getAll() const {
     return data_[static_cast<size_t>(MediaType::All)];
 }
 
-std::vector<std::shared_ptr<media::Media>> MediaContainer::getByType(MediaType type) const {
+const std::vector<std::shared_ptr<media::Media>>& MediaContainer::getByType(MediaType type) const {
     return data_[static_cast<size_t>(type)];
 }
 
-std::vector<std::shared_ptr<media::Media>> MediaContainer::getByTypeAndSubtype(MediaType type) const {
+const std::vector<std::shared_ptr<media::Media>>& MediaContainer::getByTypeAndSubtype(MediaType type) const {
     std::vector<std::shared_ptr<media::Media>> result;
 
     switch (type) {
@@ -72,14 +72,16 @@ MediaType MediaContainer::determineType(const std::shared_ptr<media::Media>& med
     return MediaType::All;
 }
 
-std::vector<std::shared_ptr<media::Media>> MediaContainer::filter(const std::shared_ptr<media::Media>& media) const {
-    if (auto m = std::dynamic_pointer_cast<media::Series>(media)) return filters(m);
-    if (auto m = std::dynamic_pointer_cast<media::Movie>(media)) return filters(m);
-    if (auto m = std::dynamic_pointer_cast<media::AudioBook>(media)) return filters(m);
-    if (auto m = std::dynamic_pointer_cast<media::Ebook>(media)) return filters(m);
-    if (auto m = std::dynamic_pointer_cast<media::Novel>(media)) return filters(m);
-    if (auto m = std::dynamic_pointer_cast<media::Album>(media)) return filters(m);
-    return filters(media);
+std::vector<std::shared_ptr<media::Media>> MediaContainer::filter(const media::Media& media) const {
+    std::shared_ptr<media::Media> mediaPtr = std::make_shared<media::Media>(media);
+
+    if (auto m = std::dynamic_pointer_cast<media::Series>(mediaPtr)) return filters(m);
+    if (auto m = std::dynamic_pointer_cast<media::Movie>(mediaPtr)) return filters(m);
+    if (auto m = std::dynamic_pointer_cast<media::AudioBook>(mediaPtr)) return filters(m);
+    if (auto m = std::dynamic_pointer_cast<media::Ebook>(mediaPtr)) return filters(m);
+    if (auto m = std::dynamic_pointer_cast<media::Novel>(mediaPtr)) return filters(m);
+    if (auto m = std::dynamic_pointer_cast<media::Album>(mediaPtr)) return filters(m);
+    return filters(mediaPtr);
 }
 
 std::vector<std::shared_ptr<media::Media>> MediaContainer::filters(const std::shared_ptr<media::Media>& media) const {
diff --git a/src/Memory/MediaContainer.h b/src/Memory/MediaContainer.h
index 38ea5ec..c4d5938 100644
--- a/src/Memory/MediaContainer.h
+++ b/src/Memory/MediaContainer.h
@@ -44,17 +44,17 @@ class MediaContainer {
     std::vector<std::shared_ptr<media::Media>> filters(const std::shared_ptr<media::AudioBook>& audiobook) const;
     std::vector<std::shared_ptr<media::Media>> filters(const std::shared_ptr<media::Series>& series) const;
 
+    const std::vector<std::shared_ptr<media::Media>>& getAll() const;
+    const std::vector<std::shared_ptr<media::Media>>& getByType(MediaType type) const;
+    const std::vector<std::shared_ptr<media::Media>>& getByTypeAndSubtype(MediaType type) const;
+
 public:
     void addMedia(const std::shared_ptr<media::Media>& media);
     void removeMedia(const std::shared_ptr<media::Media>& media);
     void clear();
-
-    std::vector<std::shared_ptr<media::Media>> getAll() const;
-    std::vector<std::shared_ptr<media::Media>> getByType(MediaType type) const;
-    std::vector<std::shared_ptr<media::Media>> getByTypeAndSubtype(MediaType type) const;
-
+ 
     // Filtri
-    std::vector<std::shared_ptr<media::Media>> filter(const std::shared_ptr<media::Media>& media) const;
+    std::vector<std::shared_ptr<media::Media>> filter(const media::Media& media) const;
 
     int serialize(QSaveFile& file) const;
 };