fixes after rebase

Stremio · Nov 10, 2023 · 42bc988 · 42bc988
1 parent 97e4244
commit 42bc988
Show file tree

Hide file tree

Showing 3 changed files with 55 additions and 63 deletions.
diff --git a/src/models/meta_details.rs b/src/models/meta_details.rs
@@ -23,7 +23,7 @@ use crate::{
         library::{LibraryBucket, LibraryItem},
         profile::Profile,
         resource::{MetaItem, Stream},
-        streams::{StreamsBucket, StreamsItemKey},
+        streams::StreamsBucket,
     },
 };
 
@@ -445,72 +445,59 @@ fn suggested_stream_update(
     streams: &[ResourceLoadable<Vec<Stream>>],
     stream_bucket: &StreamsBucket,
 ) -> Effects {
+    let all_streams = [meta_streams, streams].concat();
     let next_suggested_stream = match selected {
         Some(Selected {
-            meta_path,
             stream_path: Some(stream_path),
             ..
-        }) => {
-            meta_items
-                .iter()
-                .find_map(|meta_item| match &meta_item.content {
-                    Some(Loadable::Ready(meta_item)) => Some(&meta_item.videos),
-                    _ => None,
-                })
-                .and_then(|videos| {
-                    // Check saved stream only for last 30 videos starting from the current video
-                    videos
-                        .iter()
-                        .position(|video| video.id == stream_path.id)
-                        .and_then(|max_index| {
-                            videos[max_index.saturating_sub(30)..=max_index]
-                                .iter()
-                                .rev()
-                                .find_map(|video| {
-                                    stream_bucket.items.get(&StreamsItemKey {
-                                        meta_id: meta_path.id.to_string(),
-                                        video_id: video.id.to_owned(),
-                                    })
-                                })
-                        })
-                })
-                .and_then(|stream_item| {
-                    [meta_streams, streams]
-                        .concat()
-                        .iter()
-                        .find(|resource| resource.request.base == stream_item.stream_transport_url)
-                        .and_then(|resource| match &resource.content {
-                            Some(Loadable::Ready(streams)) => Some(ResourceLoadable {
-                                request: resource.request.clone(),
-                                content: Some(Loadable::Ready(
-                                    streams
-                                        .iter()
-                                        .find(|stream| *stream == &stream_item.stream)
-                                        .or_else(|| {
-                                            streams.iter().find(|stream| {
-                                                stream.behavior_hints.binge_group.as_deref()
-                                                    == stream_item
-                                                        .stream
-                                                        .behavior_hints
-                                                        .binge_group
-                                                        .as_deref()
+        }) => meta_items
+            .iter()
+            .filter(|_| !all_streams.is_empty())
+            .find_map(|meta_item_res| match &meta_item_res.content {
+                Some(Loadable::Ready(meta_item)) => stream_bucket
+                    .last_stream_item(&stream_path.id, meta_item)
+                    .and_then(|stream_item| {
+                        all_streams
+                            .iter()
+                            .find(|resource| {
+                                resource.request.base == stream_item.stream_transport_url
+                            })
+                            .and_then(|resource| match &resource.content {
+                                Some(Loadable::Ready(streams)) => Some(ResourceLoadable {
+                                    request: resource.request.clone(),
+                                    content: Some(Loadable::Ready(
+                                        streams
+                                            .iter()
+                                            .find(|stream| {
+                                                stream.is_source_match(&stream_item.stream)
+                                            })
+                                            .or_else(|| {
+                                                streams.iter().find(|stream| {
+                                                    stream.is_binge_match(&stream_item.stream)
+                                                })
                                             })
-                                        })
-                                        .cloned(),
-                                )),
-                            }),
-                            Some(Loadable::Loading) => Some(ResourceLoadable {
-                                request: resource.request.clone(),
-                                content: Some(Loadable::Loading),
-                            }),
-                            Some(Loadable::Err(error)) => Some(ResourceLoadable {
-                                request: resource.request.clone(),
-                                content: Some(Loadable::Err(error.clone())),
-                            }),
-                            _ => None,
+                                            .cloned(),
+                                    )),
+                                }),
+                                Some(Loadable::Loading) => Some(ResourceLoadable {
+                                    request: resource.request.clone(),
+                                    content: Some(Loadable::Loading),
+                                }),
+                                Some(Loadable::Err(error)) => Some(ResourceLoadable {
+                                    request: resource.request.clone(),
+                                    content: Some(Loadable::Err(error.clone())),
+                                }),
+                                _ => None,
+                            })
+                    })
+                    .or_else(|| {
+                        Some(ResourceLoadable {
+                            request: meta_item_res.request.clone(),
+                            content: Some(Loadable::Ready(None)),
                         })
-                })
-        }
+                    }),
+                _ => None,
+            }),
         _ => None,
     };
     eq_update(suggested_stream, next_suggested_stream)

diff --git a/src/types/resource/stream.rs b/src/types/resource/stream.rs
@@ -220,6 +220,11 @@ impl Stream {
         }
     }
 
+    #[inline]
+    pub fn is_source_match(&self, other_stream: &Stream) -> bool {
+        self.source == other_stream.source
+    }
+
     #[inline]
     pub fn is_binge_match(&self, other_stream: &Stream) -> bool {
         match (

diff --git a/src/types/streams/streams_item.rs b/src/types/streams/streams_item.rs
@@ -54,9 +54,9 @@ impl StreamsItem {
     #[inline]
     pub fn adjusted_state(&self, new_stream: &Stream) -> Option<StreamItemState> {
         self.state.clone().map(|state| {
-            let is_exact_match = self.stream.source == new_stream.source;
+            let is_source_match = self.stream.is_source_match(new_stream);
             let is_binge_match = self.stream.is_binge_match(new_stream);
-            if is_exact_match {
+            if is_source_match {
                 return state;
             } else if is_binge_match {
                 return StreamItemState {