diff --git a/src/Media/Album.cpp b/src/Media/Album.cpp
index d19e638..ef163d7 100644
--- a/src/Media/Album.cpp
+++ b/src/Media/Album.cpp
@@ -26,64 +26,57 @@ 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;
+std::unique_ptr<Media> Album::clone() const {
+    return std::make_unique<Album>(*this);
+}
 
-    // 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 Album::filter(const Media& album) const {
+    // Riutilizzo filtro base di Media
+    if (!Media::filter(album))
+        return false;
 
-        bool match = true;
+    // Cast to Album to access Album-specific members
+    const Album* albumPtr = dynamic_cast<const Album*>(&album);
+    if (!albumPtr)
+        return false;
 
-        // Band
-        if (!band_.empty() && !stringContainsIgnoreCase(albumPtr->getBand(), band_))
-            match = false;
+    // Band
+    if (!band_.empty() && !stringContainsIgnoreCase(albumPtr->getBand(), band_))
+        return 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;
+    // 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) {
+                return false;
+            }
         }
+    }
 
-        // 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;
+    // 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) {
+                return false;
+            }
         }
-
-        if (match)
-            result.push_back(albumPtr);
     }
-
-    return result;
+    return true;
 }
 
-
 }  // namespace media
diff --git a/src/Media/Album.h b/src/Media/Album.h
index da0fd7c..6efe82a 100644
--- a/src/Media/Album.h
+++ b/src/Media/Album.h
@@ -20,8 +20,11 @@ class Album : public Media {
   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;
+  std::unique_ptr<Media> clone() const override;
+
+  bool filter(const Media& album) const override;
 
 };
 }  // namespace media
+
 #endif
diff --git a/src/Media/AudioBook.cpp b/src/Media/AudioBook.cpp
index 89f43ca..f9d91f8 100644
--- a/src/Media/AudioBook.cpp
+++ b/src/Media/AudioBook.cpp
@@ -21,6 +21,10 @@ bool AudioBook::operator==(const Media& other) const {
     return false;
 }
 
+std::unique_ptr<Media> AudioBook::clone() const {
+    return std::make_unique<AudioBook>(*this);
+}
+
 std::string AudioBook::getNarrator() const {
     return narrator_;
 }
@@ -37,33 +41,21 @@ 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);
+bool AudioBook::filter(const Media& input) const {
+    if (!Novel::filter(input))
+        return false;
+    const AudioBook* audiobookPtr = dynamic_cast<const AudioBook*>(&input);
+    if (!audiobookPtr)
+        return false; // Protegge da cast fallito
 
     // Filtro specifico AudioBook
-    for (const auto& novelPtr : filteredNovels) {
-        auto audiobookPtr = std::dynamic_pointer_cast<AudioBook>(novelPtr);
-        if (!audiobookPtr) continue;
-
-        bool match = true;
+    if (!narrator_.empty() && !stringContainsIgnoreCase(audiobookPtr->getNarrator(), narrator_))
+        return false;
 
-        // File size
-        if (narrator_ != "" && audiobookPtr->getNarrator()!= narrator_)
-            match = false;
-
-        // DRM
-        if (streamingService_ != "" && audiobookPtr->getStreamingService() != streamingService_)
-            match = false;
-
-        if (match)
-            result.push_back(audiobookPtr);
-    }
+    if (!streamingService_.empty() && !stringContainsIgnoreCase(audiobookPtr->getStreamingService(), streamingService_))
+        return false;
 
-    return result;
+    return true;
 }
 
 }
\ No newline at end of file
diff --git a/src/Media/AudioBook.h b/src/Media/AudioBook.h
index 38d77fa..2012e99 100644
--- a/src/Media/AudioBook.h
+++ b/src/Media/AudioBook.h
@@ -26,7 +26,9 @@ 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;
+    std::unique_ptr<Media> clone() const override;
+
+    bool filter(const Media& audiobook) const override;
 };
 
 }
diff --git a/src/Media/Ebook.cpp b/src/Media/Ebook.cpp
index 60a10c4..cb4d562 100644
--- a/src/Media/Ebook.cpp
+++ b/src/Media/Ebook.cpp
@@ -36,34 +36,28 @@ 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;
+std::unique_ptr<Media> Ebook::clone() const {
+    return std::make_unique<Ebook>(*this);
+}
 
-        // File size
-        if (fileSizeBytes_ > 0 && ebookPtr->getFileSizeBytes() != fileSizeBytes_)
-            match = false;
+bool Ebook::filter(const Media& input) const {
+    // Riutilizzo filtro base di Novel
+    if (!Novel::filter(input))
+        return false;
+    // Cast to Ebook to access Ebook-specific members
+    const Ebook* ebookPtr = dynamic_cast<const Ebook*>(&input);
+    if (!ebookPtr)
+        return false;
 
-        // DRM
-        if (drm_ && ebookPtr->hasDrm() != drm_)
-            match = false;
+    // File size filter
+    if (fileSizeBytes_ > 0 && ebookPtr->getFileSizeBytes() != fileSizeBytes_)
+        return false;
 
-        if (match)
-            result.push_back(ebookPtr);
-    }
+    // DRM filter
+    if (drm_ && ebookPtr->hasDrm() != drm_)
+        return false;
 
-    return result;
+    return true;
 }
 
-
 }
\ No newline at end of file
diff --git a/src/Media/Ebook.h b/src/Media/Ebook.h
index d2ba138..e277746 100644
--- a/src/Media/Ebook.h
+++ b/src/Media/Ebook.h
@@ -25,7 +25,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;
+    std::unique_ptr<Media> clone() const override;
+
+    bool filter(const Media& ebook) const override;
 
 };
 
diff --git a/src/Media/IMedia.h b/src/Media/IMedia.h
index d2ffa8b..677381b 100644
--- a/src/Media/IMedia.h
+++ b/src/Media/IMedia.h
@@ -8,6 +8,7 @@ namespace media {
 class IMedia {
     virtual void accept(IConstMediaVisitor &) const = 0;
     virtual bool open() = 0;
+    virtual std::unique_ptr<Media> clone() const = 0;
 };
 
 }
diff --git a/src/Media/Media.cpp b/src/Media/Media.cpp
index 2fcdcae..3e7b8dc 100644
--- a/src/Media/Media.cpp
+++ b/src/Media/Media.cpp
@@ -18,6 +18,11 @@ Media::Media(const std::string &title, int release, const std::string &language,
 
 void Media::accept(IConstMediaVisitor &v) const {}
 
+std::unique_ptr<media::Media> media::Media::clone() const {
+    return std::make_unique<media::Media>(*this);
+}
+
+
 bool Media::operator==(const Media &other) const {
   return title_ == other.title_ && release_ == other.release_ &&
          language_ == other.language_ && favourite_ == other.favourite_ &&
@@ -31,55 +36,42 @@ 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;
-
+bool Media::filter(const Media& media) const {
         // 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;
+    if (!getTitle().empty() && !stringContainsIgnoreCase(media.getTitle(), getTitle()))
+        return false;
+
+    // Release (confronto stretto)
+    if (getRelease() != std::numeric_limits<int>::min() &&
+        media.getRelease() != getRelease())
+        return false;
+
+    // Language (substring, case-insensitive)
+    if (!getLanguage().empty() && media.getLanguage() != getLanguage())
+        return false;
+
+    // Favourite (confronto booleano)
+    if (isFavourite() && media.isFavourite() != isFavourite())
+        return 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) {
+                return false;
+            }
         }
+    }   
 
-        if (match)
-            result.push_back(mediaPtr);
-    }
-
-    return result;
+    return true;
 }
 
 
diff --git a/src/Media/Media.h b/src/Media/Media.h
index 0d39960..7d607c4 100644
--- a/src/Media/Media.h
+++ b/src/Media/Media.h
@@ -44,7 +44,10 @@ class Media : IMedia{
   const std::string &getImgPath() const;
   const std::string &getNotes() const;
 
-  std::vector<std::shared_ptr<Media>> filter(const std::vector<std::shared_ptr<Media>> &media) const;
+  virtual std::unique_ptr<Media> clone() const;
+
+
+  virtual bool filter(const Media &media) const;
 }; 
 }  // namespace media
 #endif
diff --git a/src/Media/Movie.cpp b/src/Media/Movie.cpp
index 6d83d6b..59652ab 100644
--- a/src/Media/Movie.cpp
+++ b/src/Media/Movie.cpp
@@ -18,55 +18,53 @@ bool Movie::operator==(const Media &other) const {
     }
     return false;
 }
+
+std::unique_ptr<Media> Movie::clone() const {
+    return std::make_unique<Movie>(*this);
+}
+
 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);
+bool Movie::filter(const Media& movie) const {
 
-    for (const auto& mediaPtr : filteredBase) {
-        auto moviePtr = std::dynamic_pointer_cast<Movie>(mediaPtr);
-        if (!moviePtr) continue;
+    if (!Media::filter(movie))
+        return false;
 
-        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;
+    // Cast (match parziale, case-insensitive)
+    const Movie* moviePtr = dynamic_cast<const Movie*>(&movie);
+    if (!moviePtr) {
+        return false;
+    }
+    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) {
+                return false;
+            }
         }
-
-        // 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;
+    // Length (confronto stretto)
+    if (length_ != std::numeric_limits<unsigned int>::max() && moviePtr->getLength() != length_)
+        return false;
+
+    // Universe (match parziale, case-insensitive)
+    if (!universe_.empty() && !stringContainsIgnoreCase(moviePtr->getUniverse(), universe_))
+        return false;
+    
+    return true;
 }
 
 
 }  // namespace media
+
+
diff --git a/src/Media/Movie.h b/src/Media/Movie.h
index c37d134..19a50d7 100644
--- a/src/Media/Movie.h
+++ b/src/Media/Movie.h
@@ -24,7 +24,10 @@ class Movie : public Media {
   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;
+  std::unique_ptr<Media> clone() const override;
+
+  bool filter(const Media& movie) const override;
 };
 }  // namespace media
 #endif
+
diff --git a/src/Media/Novel.cpp b/src/Media/Novel.cpp
index 88f9195..361585c 100644
--- a/src/Media/Novel.cpp
+++ b/src/Media/Novel.cpp
@@ -19,6 +19,10 @@ bool Novel::operator==(const Media& other) const {
     return false;
 }
 
+std::unique_ptr<Media> Novel::clone() const {
+    return std::make_unique<Novel>(*this);
+}
+
 // Getters
 std::string Novel::getAuthor() const { return author_; }
 std::string Novel::getPublisher() const { return publisher_; }
@@ -34,45 +38,37 @@ void Novel::setSeries(const std::string& series) { series_ = series; }
 void Novel::setIsbn(const std::string& isbn) { isbn_ = isbn; }
 
 
-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());
-    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 Novel::filter(const Media& input) const {
+    // Riutilizzo filtro base di Media
+    if (!Media::filter(input))
+        return false;
+    // Cast to Novel to access Novel-specific members
+    const Novel* novelPtr = dynamic_cast<const Novel*>(&input);
+    if (!novelPtr)
+        return false;
 
-        bool match = true;
+    // Match fields
+    // Autore
+    if (!author_.empty() && !stringContainsIgnoreCase(novelPtr->getAuthor(), author_))
+        return false;
 
-        // Autore
-        if (!author_.empty() && !stringContainsIgnoreCase(novelPtr->getAuthor(), author_))
-            match = false;
+    // Editore
+    if (!publisher_.empty() && !stringContainsIgnoreCase(novelPtr->getPublisher(), publisher_))
+        return false;
 
-        // Editore
-        if (!publisher_.empty() && !stringContainsIgnoreCase(novelPtr->getPublisher(), publisher_))
-            match = false;
+    // Serie
+    if (!series_.empty() && !stringContainsIgnoreCase(novelPtr->getSeries(), series_))
+        return false;
 
-        // Serie
-        if (!series_.empty() && !stringContainsIgnoreCase(novelPtr->getSeries(), series_))
-            match = false;
+    // ISBN
+    if (!isbn_.empty() && !stringContainsIgnoreCase(novelPtr->getIsbn(), isbn_))
+        return 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);
-    }
+    // Pagine (confronto stretto)
+    if (pages_ != std::numeric_limits<unsigned int>::max() && novelPtr->getPages() != pages_)
+        return false;
 
-    return result;
+    return true;
 }
 
 }
\ No newline at end of file
diff --git a/src/Media/Novel.h b/src/Media/Novel.h
index 64f91c9..6fa0ad5 100644
--- a/src/Media/Novel.h
+++ b/src/Media/Novel.h
@@ -35,7 +35,9 @@ class Novel : public Media {
     void setSeries(const std::string& series);
     void setIsbn(const std::string& isbn);
 
-    std::vector<std::shared_ptr<Media>> filter(const std::vector<std::shared_ptr<Novel>> &novel) const;
+    std::unique_ptr<Media> clone() const override;
+
+    bool filter(const Media &novel) const override;
 };
 
 }
diff --git a/src/Media/Series.cpp b/src/Media/Series.cpp
index 3dd0a1f..f0fa1a9 100644
--- a/src/Media/Series.cpp
+++ b/src/Media/Series.cpp
@@ -21,40 +21,36 @@ bool Series::operator==(const Media &other) const {
     }
     return false;
 }
+
+std::unique_ptr<Media> Series::clone() const {
+    return std::make_unique<Series>(*this);
+}
+
 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);
+bool Series::filter(const Media& input) const {
+     if (!Movie::filter(input))
+        return false;
 
-    for (const auto& mediaPtr : filteredBase) {
-        auto seriesPtr = std::dynamic_pointer_cast<Series>(mediaPtr);
-        if (!seriesPtr) continue;
+    const Series* seriesPtr = dynamic_cast<const Series*>(&input);
+    if (!seriesPtr)
+        return false; // Protegge da cast fallito
 
-        bool match = true;
+    // Episodes (confronto stretto)
+    if (episodes_ != std::numeric_limits<unsigned int>::max() && seriesPtr->getEpisodes() != episodes_)
+        return false;
 
-        // 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_)
+        return 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);
-    }
+    // Ended (confronto booleano)
+    if (ended_ && ended_ != seriesPtr->isEnded())
+        return false;
 
-    return result;
+    return true;
 }
 
 }  // namespace media
diff --git a/src/Media/Series.h b/src/Media/Series.h
index 42118bc..73fa611 100644
--- a/src/Media/Series.h
+++ b/src/Media/Series.h
@@ -20,8 +20,10 @@ class Series : public Movie {
   unsigned int getEpisodes() const;
   unsigned int getSeasons() const;
   bool isEnded() const;
+  
+  std::unique_ptr<Media> clone() const override;
 
-  std::vector<std::shared_ptr<Media>> filter(const std::vector<std::shared_ptr<Series>>& input) const;
+  bool filter(const Media& input) const override;
 };
 }  
 #endif  // MEDIA_SERIES_H
diff --git a/src/Memory/Database.cpp b/src/Memory/Database.cpp
deleted file mode 100644
index 4744e0b..0000000
--- a/src/Memory/Database.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-#include "Database.h"
-
-namespace memory {
-DataBase::~DataBase() {
-  // può darsi che se ne occupi il distruttore di QFile
-  // comportamento di default: per ora metto che non vengono salvati i
-  // cambiamenti
-  close(false);
-}
-int DataBase::open(const QString &path) {
-  // QFile.close() non lancia errori se il file non è stato aperto
-  // file_.commit();
-  file_.setFileName(path);
-  if (!file_.open(QIODevice::ReadOnly | QIODevice::Text)) {
-    // TODO(alessandro): possiamo creare una qualche enum per i codici di errore
-    return 1;
-  }
-  return 0;
-}
-int DataBase::close(bool save_on_exit) {
-  if (save_on_exit) {
-    // ritorna false se c'è stato un errore. Possiamo voler cambiare il tipo di
-    // ritorno del metodo.
-    file_.commit();
-  } else {
-    // void cancelWriting()
-    file_.cancelWriting();
-  }
-  return 0;
-}
-
-int DataBase::save() {
-  // ritorna false in caso di fallimento
-  if (!file_.commit()) {
-    // errore in scrittura
-    return -1;
-  }
-  // riapri il file dopo averlo chiuso
-  // ritorna false in caso di fallimento
-  if (!file_.open(QIODevice::ReadOnly | QIODevice::Text)) {
-    return 1;
-  }
-  return 0;
-}
-
-// qua possiamo volendo utilizzare riferimenti costanti al posto di puntatori
-std::vector<media::Media *> DataBase::filterMedia(
-    const media::Media *media_as_filter) {
-  return media_container_.filter(media_as_filter);
-}
-
-}  // namespace memory
diff --git a/src/Memory/Database.h b/src/Memory/Database.h
deleted file mode 100644
index d327857..0000000
--- a/src/Memory/Database.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef MEMORY_DATABASE_H
-#define MEMORY_DATABASE_H
-#include <QSaveFile>
-
-#include "./MediaContainer.h"
-
-namespace memory {
-class DataBase {
- private:
-  MediaContainer media_container_;
-  QSaveFile file_;
-
-  // possiamo mettere open, close e save privati e poi usare un tipo di observer
-  // pattern per chiamare le funzioni.
- public:
-  DataBase() = default;
-  ~DataBase();
-  int open(const QString &path);
-  int close(bool save);
-  int save();
-  // TODO(alessandro): smart pointer
-  // possiamo cambiarlo a riferimenti costanti
-  std::vector<media::Media *> filterMedia(const media::Media *);
-};
-}  // namespace memory
-#endif
diff --git a/src/Memory/Deserializer.h b/src/Memory/Deserializer.h
index d44d427..fb074c9 100644
--- a/src/Memory/Deserializer.h
+++ b/src/Memory/Deserializer.h
@@ -7,11 +7,11 @@
 namespace memory {
 class Deserializer {
  private:
-  static std::vector<std::shared_ptr<media::Media>>& XMLtoVec(const QFile &);
-  static std::vector<std::shared_ptr<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<std::shared_ptr<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 7d9c177..1cff655 100644
--- a/src/Memory/MediaContainer.cpp
+++ b/src/Memory/MediaContainer.cpp
@@ -1,25 +1,39 @@
 #include "MediaContainer.h"
+#include <typeinfo>
+#include <algorithm>
 
 namespace memory {
 
-void MediaContainer::addMedia(const std::shared_ptr<media::Media>& media) {
-    if (!media) return;
+void MediaContainer::addMedia(const media::Media& media) {
+    std::unique_ptr<media::Media> clone = media.clone();
+    media::Media* rawPtr = clone.get();
 
-    data_[static_cast<size_t>(MediaType::All)].push_back(media);
+    // Inserisce rawPtr nel vettore "All" copiando il puntatore (non l’oggetto!)
+    data_[static_cast<int>(Type::All)].push_back(std::unique_ptr<media::Media>(clone->clone()));
 
-    MediaType type = determineType(media);
-    if (type != MediaType::All) {
-        data_[static_cast<size_t>(type)].push_back(media);
+    // Inserisco anche nel tipo specifico
+    Type t = detectType(*clone);
+    if (t != Type::All) {
+        data_[static_cast<int>(t)].push_back(std::move(clone));
     }
 }
 
-void MediaContainer::removeMedia(const std::shared_ptr<media::Media>& media) {
-    if (!media) return;
 
+MediaContainer::Type MediaContainer::detectType(const media::Media& media) const {
+    if (dynamic_cast<const media::Series*>(&media))      return Type::Series;
+    if (dynamic_cast<const media::AudioBook*>(&media))   return Type::AudioBook;
+    if (dynamic_cast<const media::Ebook*>(&media))       return Type::Ebook;
+    if (dynamic_cast<const media::Movie*>(&media))       return Type::Movie;
+    if (dynamic_cast<const media::Album*>(&media))       return Type::Album;
+    if (dynamic_cast<const media::Novel*>(&media))       return Type::Novel;
+    return Type::All;
+}
+
+void MediaContainer::removeMedia(const media::Media& media) {
     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;
+            [&](const std::unique_ptr<media::Media>& m) {
+                return typeid(*m) == typeid(media) && *m == media;
             }), vec.end());
     }
 }
@@ -30,127 +44,65 @@ void MediaContainer::clear() {
     }
 }
 
-const std::vector<std::shared_ptr<media::Media>>& MediaContainer::getAll() const {
-    return data_[static_cast<size_t>(MediaType::All)];
+std::vector<const media::Media*> MediaContainer::getAll() const {
+    return getByType(Type::All);
 }
 
-const std::vector<std::shared_ptr<media::Media>>& MediaContainer::getByType(MediaType type) const {
-    return data_[static_cast<size_t>(type)];
+std::vector<const media::Media*> MediaContainer::getByType(Type type) const {
+    std::vector<const media::Media*> result;
+    for (const auto& ptr : data_[static_cast<int>(type)]) {
+        result.push_back(ptr.get());
+    }
+    return result;
 }
 
-const std::vector<std::shared_ptr<media::Media>>& MediaContainer::getByTypeAndSubtype(MediaType type) const {
-    std::vector<std::shared_ptr<media::Media>> result;
+std::vector<const media::Media*> MediaContainer::getByGroup(Type type) const {
+    std::vector<const media::Media*> result;
+
+    auto appendGroup = [&](Type t) {
+        for (const auto& ptr : data_[static_cast<int>(t)]) {
+            result.push_back(ptr.get());
+        }
+    };
 
     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());
+        case Type::Novel:
+            appendGroup(Type::Novel);
+            appendGroup(Type::Ebook);
+            appendGroup(Type::AudioBook);
             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());
+        case Type::Movie:
+            appendGroup(Type::Movie);
+            appendGroup(Type::Series);
             break;
-        case MediaType::All:
-            result = data_[0];
+        case Type::All:
+            appendGroup(Type::All);
             break;
         default:
-            result = data_[static_cast<size_t>(type)];
+            appendGroup(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;
-    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;
-}
-
-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 {
-    auto allMedia = getAll();
-    return media->filter(allMedia);
-}
-
-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& 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;
+std::vector<const media::Media*> MediaContainer::filter(const media::Media& media) const {
+    std::vector<const media::Media*> results;
+    Type t = detectType(media);
+    for (const media::Media* m : getByGroup(t)) {
+        if (media.filter(*m)) {
+            results.push_back(m);
+        }
+    }
+    return results;
 }
 
 int MediaContainer::serialize(QSaveFile& file) const {
-    return Serializer::Serialize(getAll(), file);
+    std::vector<const media::Media*> rawAll;
+    for (const auto& ptr : data_[static_cast<int>(Type::All)]) {
+        rawAll.push_back(ptr.get());
+    }
+    return Serializer::Serialize(rawAll, file);
 }
 
 } // namespace memory
diff --git a/src/Memory/MediaContainer.h b/src/Memory/MediaContainer.h
index c4d5938..7b26273 100644
--- a/src/Memory/MediaContainer.h
+++ b/src/Memory/MediaContainer.h
@@ -4,57 +4,47 @@
 #include <array>
 #include <vector>
 #include <memory>
-#include <string>
-#include <algorithm>
 #include <QSaveFile>
 
-#include "Media.h"
-#include "Novel.h"
-#include "Album.h"
-#include "Movie.h"
-#include "Ebook.h"
-#include "AudioBook.h"
-#include "Series.h"
+#include "../Media/Media.h"
+#include "../Media/Novel.h"
+#include "../Media/Album.h"
+#include "../Media/Movie.h"
+#include "../Media/Ebook.h"
+#include "../Media/AudioBook.h"
+#include "../Media/Series.h"
 #include "Serializer.h"
 
 namespace memory {
 
-enum class MediaType {
-    All = 0,
-    Novel,
-    Album,
-    Movie,
-    EBook,
-    AudioBook,
-    Series,
-    Count
-};
-
 class MediaContainer {
 private:
-    std::array<std::vector<std::shared_ptr<media::Media>>, static_cast<size_t>(MediaType::Count)> data_;
+    enum class Type {
+        All = 0,
+        Novel,
+        Album,
+        Movie,
+        Ebook,
+        AudioBook,
+        Series,
+        TypeCount
+    };
 
-    MediaType determineType(const std::shared_ptr<media::Media>& media) const;
+    std::array<std::vector<std::unique_ptr<media::Media>>, static_cast<int>(Type::TypeCount)> data_;
 
-    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;
+    Type detectType(const media::Media& media) 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;
+    std::vector<const media::Media*> getByType(Type type) const;
+    std::vector<const media::Media*> getByGroup(Type type) const;
 
 public:
-    void addMedia(const std::shared_ptr<media::Media>& media);
-    void removeMedia(const std::shared_ptr<media::Media>& media);
+    void addMedia(const media::Media& media);
+    void removeMedia(const media::Media& media);
     void clear();
- 
-    // Filtri
-    std::vector<std::shared_ptr<media::Media>> filter(const media::Media& media) const;
+
+    std::vector<const media::Media*> filter(const media::Media& media) const;
+
+    std::vector<const media::Media*> getAll() const;
 
     int serialize(QSaveFile& file) const;
 };
diff --git a/src/Memory/Serializer.h b/src/Memory/Serializer.h
index 34b5fa9..cecc7d7 100644
--- a/src/Memory/Serializer.h
+++ b/src/Memory/Serializer.h
@@ -5,12 +5,13 @@
 
 namespace memory {
 class Serializer {
+
  private:
-  static int vecToJSON(const std::vector<std::shared_ptr<media::Media>> &, QSaveFile &);
-  static int vecToXML(const std::vector<std::shared_ptr<media::Media>> &, QSaveFile &);
+  static int vecToJSON(const media::Media &, QSaveFile &){}
+  static int vecToXML(const media::Media&, QSaveFile &){}
 
  public:
-  static int Serialize(const std::vector<std::shared_ptr<media::Media>> &, QSaveFile &);
+  static int Serialize(std::vector<const media::Media*>, QSaveFile &){}
 };
 }  // namespace memory
 #endif
diff --git a/src/main.cpp b/src/main.cpp
index 55a15bc..4a96007 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -5,48 +5,6 @@
 #include "Media/Media.h"  // Include il tuo header
 
 int main() {
-    // Crea alcuni media
-    auto media1 = std::make_shared<media::Media>(
-        "House of Cards",
-        2013,
-        "English",
-        true,
-        std::vector<std::string>{"Drama", "Politics"}
-    );
-
-    auto media2 = std::make_shared<media::Media>(
-        "The Crown",
-        2016,
-        "English",
-        false,
-        std::vector<std::string>{"History", "Drama"}
-    );
-
-    auto media3 = std::make_shared<media::Media>(
-        "Breaking Bad",
-        2008,
-        "English",
-        false,
-        std::vector<std::string>{"Crime", "Thriller"}
-    );
-
-    // 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()
-    );
-    
-    // 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";
-    }
-
+    std::cout << "Aggiornato" << std::endl;
     return 0;
 }