Source file queryAlbum.ml

(**********************************************************************************************)
(*                                                                                            *)
(* This file is part of shakuhachi: a music collection manager                                *)
(* Copyright (C) 2025 Yves Ndiaye                                                             *)
(*                                                                                            *)
(* shakuhachi is free software: you can redistribute it and/or modify it under the terms      *)
(* of the GNU General Public License as published by the Free Software Foundation,            *)
(* either version 3 of the License, or (at your option) any later version.                    *)
(*                                                                                            *)
(* shakuhachi is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;    *)
(* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR           *)
(* PURPOSE.  See the GNU General Public License for more details.                             *)
(* You should have received a copy of the GNU General Public License along with shakuhachi.   *)
(* If not, see <http://www.gnu.org/licenses/>.                                                *)
(*                                                                                            *)
(**********************************************************************************************)

include QueryUtil

let matches_node subfields (album, stats, participants) node =
  let id = SkhcDb.Album.id album in
  let album_name = SkhcDb.Album.name album in
  let sort_name = SkhcDb.Album.sort_name album in
  let flag = SkhcDb.Album.flag album in
  let year = SkhcDb.Album.year album in
  let rating = SkhcDb.Album.rating album in
  let genre = SkhcDb.Album.genre album in
  let cover_path = SkhcDb.Album.cover_path album in
  let duration = SkhcDb.Album.Stats.duration stats in
  let music_count = SkhcDb.Album.Stats.music_count stats in
  let play_count = SkhcDb.Album.Stats.play_count stats in
  let size = SkhcDb.Album.Stats.size stats in
  let avg_duration = SkhcDb.Album.Stats.avg_duration stats in
  let avg_rating = SkhcDb.Album.Stats.avg_rating stats in
  let avg_size = SkhcDb.Album.Stats.avg_size stats in
  match node with
  | Node.Substring s ->
      let fields = match_participants participants in
      let fields =
        Substring.(
          SubFields.(
            fields |> add STitle album_name |> add SAlbum album_name
            |> add_field_if_some SGenre genre
            |> add_field_if_some SSortName sort_name
            |> filter (fun key _ -> List.mem key subfields)
            |> bindings |> List.map snd
          )
        )
      in
      List.exists (matches ~insensible:true false s) fields
  | Field (FString s) -> (
      let regex = Field.String.regex s in
      let insensible = Field.String.insensible s in
      let field = Field.String.field s in
      match field with
      | Title falbum | Album falbum ->
          matches ~insensible regex falbum album_name
      | SortName fsort_name ->
          omatches ~insensible regex fsort_name sort_name
      | Artist fartist ->
          SkhcDb.Ids.Map.exists
            (fun _ (artist_name, roles) ->
              SkhcDb.Roles.mem Artist roles
              && matches ~insensible regex fartist artist_name
            )
            participants
      | AlbumArtist falbum_artist ->
          SkhcDb.Ids.Map.exists
            (fun _ (artist_name, roles) ->
              SkhcDb.Roles.mem AlbumArtist roles
              && matches ~insensible regex falbum_artist artist_name
            )
            participants
      | Composer fcomposer ->
          SkhcDb.Ids.Map.exists
            (fun _ (artist_name, roles) ->
              SkhcDb.Roles.mem Composer roles
              && matches ~insensible regex fcomposer artist_name
            )
            participants
      | Genre fgenre ->
          omatches ~insensible regex fgenre genre
      | Path _ ->
          false
      | FileExtension _ ->
          false
    )
  | Field (FBool b) -> (
      match b with
      | Art b ->
          let cover = Option.is_some cover_path in
          b = cover
      | Flag b ->
          flag = b
    )
  | Field (FInt i) -> (
      match i with
      | Id fid ->
          Range.matches fid id
      | Size fsize ->
          Range.matches fsize size
      | Year fyear ->
          year
          |> Option.map (Range.matches fyear)
          |> Option.value ~default:false
      | Plays fcount ->
          Range.matches fcount play_count
      | Length flength ->
          Range.matches flength duration
      | Rating frating ->
          rating
          |> Option.map (Range.matches frating)
          |> Option.value ~default:false
      | AlbumCount fcount ->
          Range.matches fcount music_count
      | Track _ ->
          false
      | Disc _ ->
          false
    )
  | Field (FFloat f) -> (
      match f with
      | AvgDuration favg_duration ->
          Range.matches favg_duration avg_duration
      | AvgRating favg_rating ->
          Range.matches favg_rating avg_rating
      | AvgSize favg_size ->
          Range.matches favg_size avg_size
    )