Refactor movie review logging and resolution strategies

- Introduced `MovieResolver` and associated strategies for resolving movie data based on external metadata ID, manual title, or manual entry.
- Updated `log_review` use case to utilize the new `MovieResolver` for fetching movie details.
- Simplified the `LogReviewData` structure and its conversion to `LogReviewCommand`.
- Enhanced error handling for date parsing in review forms and requests.
- Updated dependencies in `Cargo.toml` and `Cargo.lock` to include necessary crates for async operations.
- Added tests for new functionality in `movie_resolver.rs` to ensure correct behavior of resolution strategies.

crates/application/Cargo.toml

@@ -4,7 +4,11 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+async-trait = { workspace = true }
 domain = { workspace = true }
 uuid = { workspace = true }
 chrono = { workspace = true }
 tracing = { workspace = true }
+
+[dev-dependencies]
+tokio = { workspace = true }

crates/application/src/lib.rs

@@ -1,6 +1,7 @@
 pub mod commands;
 pub mod config;
 pub mod context;
+pub mod movie_resolver;
 pub mod ports;
 pub mod queries;
 pub mod use_cases;

crates/application/src/movie_resolver.rs

@@ -0,0 +1,583 @@
+use async_trait::async_trait;
+use domain::{
+    errors::DomainError,
+    models::Movie,
+    ports::{MetadataClient, MetadataSearchCriteria, MovieRepository},
+    value_objects::{ExternalMetadataId, MovieTitle, ReleaseYear},
+};
+
+use crate::commands::LogReviewCommand;
+
+pub struct MovieResolverDeps<'a> {
+    pub repository: &'a dyn MovieRepository,
+    pub metadata_client: &'a dyn MetadataClient,
+}
+
+#[async_trait]
+pub trait ResolutionStrategy: Send + Sync {
+    fn can_handle(&self, cmd: &LogReviewCommand) -> bool;
+    async fn resolve(
+        &self,
+        cmd: &LogReviewCommand,
+        deps: &MovieResolverDeps<'_>,
+    ) -> Result<Option<(Movie, bool)>, DomainError>;
+}
+
+pub struct ExternalIdStrategy;
+pub struct TitleSearchStrategy;
+pub struct ManualMovieStrategy;
+
+pub struct MovieResolver {
+    strategies: Vec<Box<dyn ResolutionStrategy>>,
+}
+
+impl MovieResolver {
+    pub fn default_pipeline() -> Self {
+        Self {
+            strategies: vec![
+                Box::new(ExternalIdStrategy),
+                Box::new(TitleSearchStrategy),
+                Box::new(ManualMovieStrategy),
+            ],
+        }
+    }
+
+    pub async fn resolve(
+        &self,
+        cmd: &LogReviewCommand,
+        deps: &MovieResolverDeps<'_>,
+    ) -> Result<(Movie, bool), DomainError> {
+        for strategy in &self.strategies {
+            if strategy.can_handle(cmd) {
+                if let Some(result) = strategy.resolve(cmd, deps).await? {
+                    return Ok(result);
+                }
+            }
+        }
+        Err(DomainError::ValidationError(
+            "Manual title required if TMDB fetch fails or is omitted".into(),
+        ))
+    }
+}
+
+#[async_trait]
+impl ResolutionStrategy for ExternalIdStrategy {
+    fn can_handle(&self, cmd: &LogReviewCommand) -> bool {
+        cmd.external_metadata_id.is_some()
+    }
+
+    async fn resolve(
+        &self,
+        cmd: &LogReviewCommand,
+        deps: &MovieResolverDeps<'_>,
+    ) -> Result<Option<(Movie, bool)>, DomainError> {
+        let ext_id_str = cmd.external_metadata_id.as_deref().unwrap();
+        let tmdb_id = ExternalMetadataId::new(ext_id_str.to_string())?;
+
+        if let Some(m) = deps.repository.get_movie_by_external_id(&tmdb_id).await? {
+            return Ok(Some((m, false)));
+        }
+
+        match deps
+            .metadata_client
+            .fetch_movie_metadata(&MetadataSearchCriteria::ImdbId(tmdb_id))
+            .await
+        {
+            Ok(m) => Ok(Some((m, true))),
+            Err(e) => {
+                tracing::warn!(
+                    "Failed to fetch from TMDB, falling back to manual entry: {:?}",
+                    e
+                );
+                Ok(None)
+            }
+        }
+    }
+}
+
+#[async_trait]
+impl ResolutionStrategy for TitleSearchStrategy {
+    fn can_handle(&self, cmd: &LogReviewCommand) -> bool {
+        cmd.manual_title.is_some()
+    }
+
+    async fn resolve(
+        &self,
+        cmd: &LogReviewCommand,
+        deps: &MovieResolverDeps<'_>,
+    ) -> Result<Option<(Movie, bool)>, DomainError> {
+        let title = cmd.manual_title.as_deref().unwrap();
+        let criteria = MetadataSearchCriteria::Title {
+            title: title.to_string(),
+            year: cmd.manual_release_year,
+        };
+        match deps.metadata_client.fetch_movie_metadata(&criteria).await {
+            Ok(m) => Ok(Some((m, true))),
+            Err(e) => {
+                tracing::warn!("OMDb title search failed, falling back to manual: {:?}", e);
+                Ok(None)
+            }
+        }
+    }
+}
+
+#[async_trait]
+impl ResolutionStrategy for ManualMovieStrategy {
+    fn can_handle(&self, cmd: &LogReviewCommand) -> bool {
+        cmd.manual_title.is_some()
+    }
+
+    async fn resolve(
+        &self,
+        cmd: &LogReviewCommand,
+        deps: &MovieResolverDeps<'_>,
+    ) -> Result<Option<(Movie, bool)>, DomainError> {
+        let title_str = match &cmd.manual_title {
+            Some(t) => t,
+            None => return Ok(None),
+        };
+        let year_val = cmd.manual_release_year.ok_or_else(|| {
+            DomainError::ValidationError(
+                "Manual release year required if TMDB fetch fails or is omitted".into(),
+            )
+        })?;
+
+        let title = MovieTitle::new(title_str.clone())?;
+        let release_year = ReleaseYear::new(year_val)?;
+
+        let candidates = deps
+            .repository
+            .get_movies_by_title_and_year(&title, &release_year)
+            .await?;
+
+        let matched = candidates
+            .into_iter()
+            .find(|m| m.is_manual_match(&title, &release_year, cmd.manual_director.as_deref()));
+
+        if let Some(existing) = matched {
+            Ok(Some((existing, false)))
+        } else {
+            let new_movie =
+                Movie::new(None, title, release_year, cmd.manual_director.clone(), None);
+            Ok(Some((new_movie, true)))
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use chrono::NaiveDate;
+    use domain::{
+        errors::DomainError,
+        events::DomainEvent,
+        models::{DiaryEntry, DiaryFilter, Movie, Review, ReviewHistory, collections::Paginated},
+        ports::{MetadataSearchCriteria, MovieRepository},
+        value_objects::{
+            ExternalMetadataId, MovieId, MovieTitle, PosterUrl, ReleaseYear, ReviewId,
+        },
+    };
+
+    fn make_cmd(ext_id: Option<&str>, title: Option<&str>, year: Option<u16>) -> LogReviewCommand {
+        LogReviewCommand {
+            external_metadata_id: ext_id.map(String::from),
+            manual_title: title.map(String::from),
+            manual_release_year: year,
+            manual_director: None,
+            user_id: uuid::Uuid::new_v4(),
+            rating: 4,
+            comment: None,
+            watched_at: NaiveDate::from_ymd_opt(2024, 1, 1)
+                .unwrap()
+                .and_hms_opt(0, 0, 0)
+                .unwrap(),
+        }
+    }
+
+    fn make_movie() -> Movie {
+        Movie::new(
+            None,
+            MovieTitle::new("Inception".to_string()).unwrap(),
+            ReleaseYear::new(2010).unwrap(),
+            None,
+            None,
+        )
+    }
+
+    struct RepoWithExternalMovie(Movie);
+    struct RepoEmpty;
+    struct RepoWithTitleMatch(Movie);
+
+    #[async_trait]
+    impl MovieRepository for RepoWithExternalMovie {
+        async fn get_movie_by_external_id(
+            &self,
+            _: &ExternalMetadataId,
+        ) -> Result<Option<Movie>, DomainError> {
+            Ok(Some(self.0.clone()))
+        }
+        async fn get_movie_by_id(&self, _: &MovieId) -> Result<Option<Movie>, DomainError> {
+            panic!("unexpected")
+        }
+        async fn get_movies_by_title_and_year(
+            &self,
+            _: &MovieTitle,
+            _: &ReleaseYear,
+        ) -> Result<Vec<Movie>, DomainError> {
+            panic!("unexpected")
+        }
+        async fn upsert_movie(&self, _: &Movie) -> Result<(), DomainError> {
+            panic!("unexpected")
+        }
+        async fn save_review(&self, _: &Review) -> Result<DomainEvent, DomainError> {
+            panic!("unexpected")
+        }
+        async fn query_diary(
+            &self,
+            _: &DiaryFilter,
+        ) -> Result<Paginated<DiaryEntry>, DomainError> {
+            panic!("unexpected")
+        }
+        async fn get_review_history(&self, _: &MovieId) -> Result<ReviewHistory, DomainError> {
+            panic!("unexpected")
+        }
+        async fn get_review_by_id(
+            &self,
+            _: &ReviewId,
+        ) -> Result<Option<Review>, DomainError> {
+            panic!("unexpected")
+        }
+        async fn delete_review(&self, _: &ReviewId) -> Result<(), DomainError> {
+            panic!("unexpected")
+        }
+        async fn delete_movie(&self, _: &MovieId) -> Result<(), DomainError> {
+            panic!("unexpected")
+        }
+    }
+
+    #[async_trait]
+    impl MovieRepository for RepoEmpty {
+        async fn get_movie_by_external_id(
+            &self,
+            _: &ExternalMetadataId,
+        ) -> Result<Option<Movie>, DomainError> {
+            Ok(None)
+        }
+        async fn get_movie_by_id(&self, _: &MovieId) -> Result<Option<Movie>, DomainError> {
+            panic!("unexpected")
+        }
+        async fn get_movies_by_title_and_year(
+            &self,
+            _: &MovieTitle,
+            _: &ReleaseYear,
+        ) -> Result<Vec<Movie>, DomainError> {
+            Ok(vec![])
+        }
+        async fn upsert_movie(&self, _: &Movie) -> Result<(), DomainError> {
+            panic!("unexpected")
+        }
+        async fn save_review(&self, _: &Review) -> Result<DomainEvent, DomainError> {
+            panic!("unexpected")
+        }
+        async fn query_diary(
+            &self,
+            _: &DiaryFilter,
+        ) -> Result<Paginated<DiaryEntry>, DomainError> {
+            panic!("unexpected")
+        }
+        async fn get_review_history(&self, _: &MovieId) -> Result<ReviewHistory, DomainError> {
+            panic!("unexpected")
+        }
+        async fn get_review_by_id(
+            &self,
+            _: &ReviewId,
+        ) -> Result<Option<Review>, DomainError> {
+            panic!("unexpected")
+        }
+        async fn delete_review(&self, _: &ReviewId) -> Result<(), DomainError> {
+            panic!("unexpected")
+        }
+        async fn delete_movie(&self, _: &MovieId) -> Result<(), DomainError> {
+            panic!("unexpected")
+        }
+    }
+
+    #[async_trait]
+    impl MovieRepository for RepoWithTitleMatch {
+        async fn get_movie_by_external_id(
+            &self,
+            _: &ExternalMetadataId,
+        ) -> Result<Option<Movie>, DomainError> {
+            panic!("unexpected")
+        }
+        async fn get_movie_by_id(&self, _: &MovieId) -> Result<Option<Movie>, DomainError> {
+            panic!("unexpected")
+        }
+        async fn get_movies_by_title_and_year(
+            &self,
+            _: &MovieTitle,
+            _: &ReleaseYear,
+        ) -> Result<Vec<Movie>, DomainError> {
+            Ok(vec![self.0.clone()])
+        }
+        async fn upsert_movie(&self, _: &Movie) -> Result<(), DomainError> {
+            panic!("unexpected")
+        }
+        async fn save_review(&self, _: &Review) -> Result<DomainEvent, DomainError> {
+            panic!("unexpected")
+        }
+        async fn query_diary(
+            &self,
+            _: &DiaryFilter,
+        ) -> Result<Paginated<DiaryEntry>, DomainError> {
+            panic!("unexpected")
+        }
+        async fn get_review_history(&self, _: &MovieId) -> Result<ReviewHistory, DomainError> {
+            panic!("unexpected")
+        }
+        async fn get_review_by_id(
+            &self,
+            _: &ReviewId,
+        ) -> Result<Option<Review>, DomainError> {
+            panic!("unexpected")
+        }
+        async fn delete_review(&self, _: &ReviewId) -> Result<(), DomainError> {
+            panic!("unexpected")
+        }
+        async fn delete_movie(&self, _: &MovieId) -> Result<(), DomainError> {
+            panic!("unexpected")
+        }
+    }
+
+    struct MetaReturnsMovie(Movie);
+    struct MetaErrors;
+
+    #[async_trait]
+    impl MetadataClient for MetaReturnsMovie {
+        async fn fetch_movie_metadata(
+            &self,
+            _: &MetadataSearchCriteria,
+        ) -> Result<Movie, DomainError> {
+            Ok(self.0.clone())
+        }
+        async fn get_poster_url(
+            &self,
+            _: &ExternalMetadataId,
+        ) -> Result<Option<PosterUrl>, DomainError> {
+            panic!("unexpected")
+        }
+    }
+
+    #[async_trait]
+    impl MetadataClient for MetaErrors {
+        async fn fetch_movie_metadata(
+            &self,
+            _: &MetadataSearchCriteria,
+        ) -> Result<Movie, DomainError> {
+            Err(DomainError::InfrastructureError("metadata unavailable".into()))
+        }
+        async fn get_poster_url(
+            &self,
+            _: &ExternalMetadataId,
+        ) -> Result<Option<PosterUrl>, DomainError> {
+            panic!("unexpected")
+        }
+    }
+
+    // --- ExternalIdStrategy ---
+
+    #[test]
+    fn external_id_strategy_can_handle_cmd_with_id() {
+        let cmd = make_cmd(Some("tt123"), None, None);
+        assert!(ExternalIdStrategy.can_handle(&cmd));
+    }
+
+    #[test]
+    fn external_id_strategy_cannot_handle_cmd_without_id() {
+        let cmd = make_cmd(None, Some("Inception"), Some(2010));
+        assert!(!ExternalIdStrategy.can_handle(&cmd));
+    }
+
+    #[tokio::test]
+    async fn external_id_strategy_returns_cached_movie() {
+        let movie = make_movie();
+        let repo = RepoWithExternalMovie(movie.clone());
+        let meta = MetaErrors;
+        let deps = MovieResolverDeps {
+            repository: &repo,
+            metadata_client: &meta,
+        };
+        let cmd = make_cmd(Some("tt123"), None, None);
+        let result = ExternalIdStrategy.resolve(&cmd, &deps).await.unwrap();
+        assert!(matches!(result, Some((_, false))));
+    }
+
+    #[tokio::test]
+    async fn external_id_strategy_fetches_from_metadata_when_not_cached() {
+        let movie = make_movie();
+        let repo = RepoEmpty;
+        let meta = MetaReturnsMovie(movie);
+        let deps = MovieResolverDeps {
+            repository: &repo,
+            metadata_client: &meta,
+        };
+        let cmd = make_cmd(Some("tt123"), None, None);
+        let result = ExternalIdStrategy.resolve(&cmd, &deps).await.unwrap();
+        assert!(matches!(result, Some((_, true))));
+    }
+
+    #[tokio::test]
+    async fn external_id_strategy_falls_through_on_metadata_error() {
+        let repo = RepoEmpty;
+        let meta = MetaErrors;
+        let deps = MovieResolverDeps {
+            repository: &repo,
+            metadata_client: &meta,
+        };
+        let cmd = make_cmd(Some("tt123"), None, None);
+        let result = ExternalIdStrategy.resolve(&cmd, &deps).await.unwrap();
+        assert!(result.is_none());
+    }
+
+    // --- TitleSearchStrategy ---
+
+    #[test]
+    fn title_strategy_can_handle_cmd_with_title() {
+        let cmd = make_cmd(None, Some("Inception"), Some(2010));
+        assert!(TitleSearchStrategy.can_handle(&cmd));
+    }
+
+    #[test]
+    fn title_strategy_cannot_handle_cmd_without_title() {
+        let cmd = make_cmd(Some("tt123"), None, None);
+        assert!(!TitleSearchStrategy.can_handle(&cmd));
+    }
+
+    #[tokio::test]
+    async fn title_strategy_fetches_from_metadata() {
+        let movie = make_movie();
+        let repo = RepoEmpty;
+        let meta = MetaReturnsMovie(movie);
+        let deps = MovieResolverDeps {
+            repository: &repo,
+            metadata_client: &meta,
+        };
+        let cmd = make_cmd(None, Some("Inception"), Some(2010));
+        let result = TitleSearchStrategy.resolve(&cmd, &deps).await.unwrap();
+        assert!(matches!(result, Some((_, true))));
+    }
+
+    #[tokio::test]
+    async fn title_strategy_falls_through_on_metadata_error() {
+        let repo = RepoEmpty;
+        let meta = MetaErrors;
+        let deps = MovieResolverDeps {
+            repository: &repo,
+            metadata_client: &meta,
+        };
+        let cmd = make_cmd(None, Some("Inception"), Some(2010));
+        let result = TitleSearchStrategy.resolve(&cmd, &deps).await.unwrap();
+        assert!(result.is_none());
+    }
+
+    // --- ManualMovieStrategy ---
+
+    #[test]
+    fn manual_strategy_can_handle_cmd_with_title() {
+        let cmd = make_cmd(None, Some("Inception"), Some(2010));
+        assert!(ManualMovieStrategy.can_handle(&cmd));
+    }
+
+    #[test]
+    fn manual_strategy_cannot_handle_cmd_without_title() {
+        let cmd = make_cmd(Some("tt123"), None, None);
+        assert!(!ManualMovieStrategy.can_handle(&cmd));
+    }
+
+    #[tokio::test]
+    async fn manual_strategy_returns_existing_movie() {
+        let movie = make_movie();
+        let repo = RepoWithTitleMatch(movie.clone());
+        let meta = MetaErrors;
+        let deps = MovieResolverDeps {
+            repository: &repo,
+            metadata_client: &meta,
+        };
+        let cmd = make_cmd(None, Some("Inception"), Some(2010));
+        let result = ManualMovieStrategy.resolve(&cmd, &deps).await.unwrap();
+        assert!(matches!(result, Some((_, false))));
+    }
+
+    #[tokio::test]
+    async fn manual_strategy_creates_new_movie_when_no_match() {
+        let repo = RepoEmpty;
+        let meta = MetaErrors;
+        let deps = MovieResolverDeps {
+            repository: &repo,
+            metadata_client: &meta,
+        };
+        let cmd = make_cmd(None, Some("Inception"), Some(2010));
+        let result = ManualMovieStrategy.resolve(&cmd, &deps).await.unwrap();
+        assert!(matches!(result, Some((_, true))));
+    }
+
+    #[tokio::test]
+    async fn manual_strategy_errors_without_year() {
+        let repo = RepoEmpty;
+        let meta = MetaErrors;
+        let deps = MovieResolverDeps {
+            repository: &repo,
+            metadata_client: &meta,
+        };
+        let cmd = make_cmd(None, Some("Inception"), None);
+        assert!(ManualMovieStrategy.resolve(&cmd, &deps).await.is_err());
+    }
+
+    // --- MovieResolver pipeline ---
+
+    #[tokio::test]
+    async fn resolver_returns_error_when_no_strategy_matches() {
+        let repo = RepoEmpty;
+        let meta = MetaErrors;
+        let deps = MovieResolverDeps {
+            repository: &repo,
+            metadata_client: &meta,
+        };
+        let cmd = make_cmd(None, None, None);
+        let result = MovieResolver::default_pipeline().resolve(&cmd, &deps).await;
+        assert!(result.is_err());
+    }
+
+    #[tokio::test]
+    async fn resolver_uses_cached_movie_when_external_id_matches() {
+        let movie = make_movie();
+        let repo = RepoWithExternalMovie(movie.clone());
+        let meta = MetaErrors;
+        let deps = MovieResolverDeps {
+            repository: &repo,
+            metadata_client: &meta,
+        };
+        let cmd = make_cmd(Some("tt123"), None, None);
+        let (_, is_new) = MovieResolver::default_pipeline()
+            .resolve(&cmd, &deps)
+            .await
+            .unwrap();
+        assert!(!is_new);
+    }
+
+    #[tokio::test]
+    async fn resolver_falls_through_to_manual_when_external_and_title_both_fail() {
+        let repo = RepoEmpty;
+        let meta = MetaErrors;
+        let deps = MovieResolverDeps {
+            repository: &repo,
+            metadata_client: &meta,
+        };
+        let cmd = make_cmd(Some("tt123"), Some("Inception"), Some(2010));
+        let (_, is_new) = MovieResolver::default_pipeline()
+            .resolve(&cmd, &deps)
+            .await
+            .unwrap();
+        assert!(is_new);
+    }
+}

crates/application/src/use_cases/log_review.rs

@@ -2,18 +2,25 @@ use domain::{
     errors::DomainError,
     events::DomainEvent,
     models::{Movie, Review},
-    ports::MetadataSearchCriteria,
-    value_objects::{Comment, ExternalMetadataId, MovieTitle, Rating, ReleaseYear, UserId},
+    value_objects::{Comment, Rating, UserId},
 };
 
-use crate::{commands::LogReviewCommand, context::AppContext};
+use crate::{
+    commands::LogReviewCommand,
+    context::AppContext,
+    movie_resolver::{MovieResolver, MovieResolverDeps},
+};
 
 pub async fn execute(ctx: &AppContext, cmd: LogReviewCommand) -> Result<(), DomainError> {
     let rating = Rating::new(cmd.rating)?;
     let user_id = UserId::from_uuid(cmd.user_id);
     let comment = cmd.comment.clone().map(Comment::new).transpose()?;
 
-    let (movie, is_new_movie) = resolve_movie(ctx, &cmd).await?;
+    let deps = MovieResolverDeps {
+        repository: ctx.repository.as_ref(),
+        metadata_client: ctx.metadata_client.as_ref(),
+    };
+    let (movie, is_new_movie) = MovieResolver::default_pipeline().resolve(&cmd, &deps).await?;
 
     ctx.repository.upsert_movie(&movie).await?;
 
@@ -25,101 +32,6 @@ pub async fn execute(ctx: &AppContext, cmd: LogReviewCommand) -> Result<(), Doma
     Ok(())
 }
 
-async fn resolve_movie(
-    ctx: &AppContext,
-    cmd: &LogReviewCommand,
-) -> Result<(Movie, bool), DomainError> {
-    if let Some(ext_id_str) = &cmd.external_metadata_id {
-        if let Some(resolved) = resolve_external_movie(ctx, ext_id_str).await? {
-            return Ok(resolved);
-        }
-    }
-
-    if let Some(title) = &cmd.manual_title {
-        if let Some(resolved) = resolve_by_title(ctx, title, cmd.manual_release_year).await? {
-            return Ok(resolved);
-        }
-    }
-
-    resolve_manual_movie(ctx, cmd).await
-}
-
-async fn resolve_external_movie(
-    ctx: &AppContext,
-    ext_id_str: &str,
-) -> Result<Option<(Movie, bool)>, DomainError> {
-    let tmdb_id = ExternalMetadataId::new(ext_id_str.to_string())?;
-
-    if let Some(m) = ctx.repository.get_movie_by_external_id(&tmdb_id).await? {
-        return Ok(Some((m, false)));
-    }
-
-    match ctx
-        .metadata_client
-        .fetch_movie_metadata(&MetadataSearchCriteria::ImdbId(tmdb_id))
-        .await
-    {
-        Ok(m) => Ok(Some((m, true))),
-        Err(e) => {
-            tracing::warn!(
-                "Failed to fetch from TMDB, falling back to manual entry: {:?}",
-                e
-            );
-            Ok(None)
-        }
-    }
-}
-
-async fn resolve_by_title(
-    ctx: &AppContext,
-    title: &str,
-    year: Option<u16>,
-) -> Result<Option<(Movie, bool)>, DomainError> {
-    let criteria = MetadataSearchCriteria::Title { title: title.to_string(), year };
-    match ctx.metadata_client.fetch_movie_metadata(&criteria).await {
-        Ok(m) => Ok(Some((m, true))),
-        Err(e) => {
-            tracing::warn!("OMDb title search failed, falling back to manual: {:?}", e);
-            Ok(None)
-        }
-    }
-}
-
-async fn resolve_manual_movie(
-    ctx: &AppContext,
-    cmd: &LogReviewCommand,
-) -> Result<(Movie, bool), DomainError> {
-    let title_str = cmd.manual_title.as_ref().ok_or_else(|| {
-        DomainError::ValidationError(
-            "Manual title required if TMDB fetch fails or is omitted".into(),
-        )
-    })?;
-    let year_val = cmd.manual_release_year.ok_or_else(|| {
-        DomainError::ValidationError(
-            "Manual release year required if TMDB fetch fails or is omitted".into(),
-        )
-    })?;
-
-    let title = MovieTitle::new(title_str.clone())?;
-    let release_year = ReleaseYear::new(year_val)?;
-
-    let candidates = ctx
-        .repository
-        .get_movies_by_title_and_year(&title, &release_year)
-        .await?;
-
-    let matched_movie = candidates
-        .into_iter()
-        .find(|m| m.is_manual_match(&title, &release_year, cmd.manual_director.as_deref()));
-
-    if let Some(existing_movie) = matched_movie {
-        Ok((existing_movie, false))
-    } else {
-        let new_movie = Movie::new(None, title, release_year, cmd.manual_director.clone(), None);
-        Ok((new_movie, true))
-    }
-}
-
 async fn publish_events(
     ctx: &AppContext,
     movie: &Movie,