Source file playlist.ml

(*****************************************************************************)
(*                                                                           *)
(*  Copyright (C) 2026 Yves Ndiaye                                           *)
(*                                                                           *)
(* This Source Code Form is subject to the terms of the Mozilla Public       *)
(* License, v. 2.0. If a copy of the MPL was not distributed with this       *)
(* file, You can obtain one at https://mozilla.org/MPL/2.0/.                 *)
(*                                                                           *)
(*****************************************************************************)

type t = {
  id : int64;
  name : string;
  query : string;
  smart : bool;
  flag : bool;
  rating : int option;
  cover_path : string option;
  created_at : float;
  updated_at : float;
}
[@@deriving yojson]

let table_name = "playlists"

module Column = struct
  let id = "id"
  let name = "name"
  let query = "query"
  let smart = "smart"
  let flag = "flag"
  let rating = "rating"
  let cover_path = "cover_path"
  let created_at = "created_at"
  let updated_at = "updated_at"
end

module Stats = struct
  type t = {
    music_count : int;
    duration : int;
    play_count : int;
    size : int64;
    avg_duration : float;
    avg_rating : float;
    avg_size : float;
  }
  [@@deriving yojson]

  let init' ~music_count ~duration ~play_count ~size ~avg_duration ~avg_rating
      ~avg_size =
    {
      music_count;
      duration;
      play_count;
      size;
      avg_duration;
      avg_rating;
      avg_size;
    }

  let init ~music_count ~duration ~play_count ~size ~avg_rating =
    Util.Stats.init ~init' ~music_count ~duration ~play_count ~size ~avg_rating

  let column_query ~id ~play_count ~duration ~size ~rating =
    Util.Stats.column_query
      ~music_album_key:(MusicFile.table_name, MusicFile.Column.album_id)
      ~album_key:(table_name, Column.id) ~id ~play_count ~duration ~size ~rating

  let columns statement offset =
    let music_count = Sqlite3.column_int statement offset in
    let play_count = Sqlite3.column_int statement (offset + 1) in
    let duration = Sqlite3.column_int statement (offset + 2) in
    let size = Sqlite3.column_int64 statement (offset + 3) in
    let avg_duration = Sqlite3.column_double statement (offset + 4) in
    let avg_rating = Sqlite3.column_double statement (offset + 5) in
    let avg_size = Sqlite3.column_double statement (offset + 6) in
    ( init' ~music_count ~duration ~play_count ~size ~avg_duration ~avg_rating
        ~avg_size,
      offset + 7
    )

  let music_count t = t.music_count
  let duration t = t.duration
  let play_count t = t.play_count
  let size t = t.size
  let avg_duration t = t.avg_duration
  let avg_rating t = t.avg_rating
  let avg_size t = t.avg_size
end

module Prefix = struct
  let id = Printf.sprintf "%s.%s" table_name Column.id
end

let init ~name ~query ~smart ~flag ~rating ~cover_path =
  let created_at = Unix.time () in
  {
    id = Int64.zero;
    name;
    query;
    smart;
    flag;
    rating;
    cover_path;
    created_at;
    updated_at = created_at;
  }

let primary_key = Column.id

let sql_table =
  let open Column in
  Printf.sprintf
    {|CREATE TABLE IF NOT EXISTS %s (
    %s INTEGER PRIMARY KEY,
    %s TEXT NOT NULL UNIQUE,
    %s TEXT NOT NULL,
    %s BOOLEAN NOT NULL,
    %s BOOLEAN NOT NULL,
    %s INTEGER,
    %s TEXT,
    %s REAL NOT NULL,
    %s REAL NOT NULL
  );|}
    table_name primary_key name query smart flag rating cover_path created_at
    updated_at

let bind_names ?(exclude = []) t =
  let values =
    Sqlite3.Data.(
      Column.
        [
          (id, INT t.id);
          (name, TEXT t.name);
          (query, TEXT t.query);
          (smart, INT (Int64.of_int (Bool.to_int t.smart)));
          (flag, INT (Int64.of_int (Bool.to_int t.flag)));
          (created_at, FLOAT t.created_at);
          (updated_at, FLOAT t.updated_at);
        ]
    )
  in
  let values =
    match t.rating with
    | None ->
        values
    | Some rating ->
        (Column.rating, Sqlite3.Data.INT (Int64.of_int rating)) :: values
  in
  let values =
    match t.cover_path with
    | None ->
        values
    | Some cover_path ->
        (Column.cover_path, Sqlite3.Data.TEXT cover_path) :: values
  in
  (* The @ is part of the bind name. *)
  List.filter_map
    (fun (s, d) ->
      match not (List.mem s exclude) with
      | true ->
          Some (Printf.sprintf "@%s" s, d)
      | false ->
          None
    )
    values

let columns statement offset =
  let module D = Sqlite3.Data in
  let column_option conv statement offset =
    let data = Sqlite3.column statement offset in
    conv data
  in
  let id = Sqlite3.column_int64 statement offset in
  let name = Sqlite3.column_text statement (offset + 1) in
  let query = Sqlite3.column_text statement (offset + 2) in
  let smart = Sqlite3.column_bool statement (offset + 3) in
  let flag = Sqlite3.column_bool statement (offset + 4) in
  let rating = column_option D.to_int statement (offset + 5) in
  let cover_path = column_option D.to_string statement (offset + 6) in
  let created_at = Sqlite3.column_double statement (offset + 7) in
  let updated_at = Sqlite3.column_double statement (offset + 8) in
  ( { id; name; query; smart; flag; rating; cover_path; created_at; updated_at },
    9
  )

let filter_map database func =
  let request = Printf.sprintf "SELECT * from %s;;" table_name in
  let statement = Sqlite3.prepare database request in
  let queue = Queue.create () in
  let rc =
    Sqlite3.iter statement ~f:(fun _ ->
        (*HACK: use statement instead of data *)
        let music, _ = columns statement 0 in
        match func music with None -> () | Some music -> Queue.add music queue
    )
  in
  let musics = queue |> Queue.to_seq |> List.of_seq in
  Util.bind_ok database rc @@ fun () -> Ok musics

let find_from_id db id =
  let ( let* ) = Util.bind_ok db in
  let request =
    Printf.sprintf "SELECT * from %s where %s = ?;" table_name Column.id
  in
  let stmt = Sqlite3.prepare db request in
  let* () = Sqlite3.bind_int64 stmt 1 id in
  let queue = Queue.create () in
  let rc =
    Sqlite3.iter stmt ~f:(fun _ ->
        (*HACK: use statement instead of data *)
        let playlist, _ = columns stmt 0 in
        Queue.add playlist queue
    )
  in
  Util.bind_ok db rc @@ fun () -> Ok (Queue.take_opt queue)

let find_map database func =
  let rec loop stmt =
    match Sqlite3.step stmt with
    | Sqlite3.Rc.ROW -> (
        match func (fst @@ columns stmt 0) with
        | None ->
            loop stmt
        | Some t ->
            let _ = Sqlite3.finalize stmt in
            Ok (Some t)
      )
    | Sqlite3.Rc.DONE ->
        let _ = Sqlite3.finalize stmt in
        Ok None
    | rc ->
        let msg = Sqlite3.errmsg database in
        Error (rc, msg)
  in
  let request = Printf.sprintf "SELECT * from %s;;" table_name in
  let statement = Sqlite3.prepare database request in
  loop statement

let all database = filter_map database Option.some

let remove_id database id =
  let ( let* ) = Util.bind_ok database in
  let statement =
    Printf.sprintf "DELETE FROM %s WHERE %s = ?;" table_name Column.id
  in
  let statement = Sqlite3.prepare database statement in
  let* () = Sqlite3.bind_int64 statement 1 id in
  let* () = Sqlite3.step statement in
  let* () = Sqlite3.finalize statement in
  Ok ()

let remove_name database name =
  let ( let* ) = Util.bind_ok database in
  let request =
    Printf.sprintf "DELETE FROM %s WHERE %s = ?;" table_name Column.name
  in
  let statement = Sqlite3.prepare database request in
  let* () = Sqlite3.bind_text statement 1 name in
  let* () = Sqlite3.step statement in
  let* () = Sqlite3.finalize statement in
  Ok ()

let remove database t = remove_id database t.id

let insert database t =
  let ( let* ) = Util.bind_ok database in
  let request =
    let open Column in
    Printf.sprintf
      "INSERT INTO %s (%s, %s, %s, %s, %s, %s, %s, %s) VALUES (@%s, @%s, @%s, \
       @%s, @%s, @%s, @%s, @%s);"
      table_name name query smart flag rating cover_path created_at updated_at
      name query smart flag rating cover_path created_at updated_at
  in
  let values = bind_names ~exclude:Column.[ id ] t in
  let statement = Sqlite3.prepare database request in
  let* () = Sqlite3.bind_names statement values in
  let* () = Sqlite3.step statement in
  let* () = Sqlite3.finalize statement in
  let id = Sqlite3.last_insert_rowid database in
  Ok { t with id }

let update database t =
  let ( let* ) = Util.bind_ok database in
  let updated_at = Unix.time () in
  let t = { t with updated_at } in
  let request =
    let open Column in
    Printf.sprintf
      "UPDATE %s SET %s = @%s, %s = @%s, %s = @%s, %s = @%s, %s = @%s, %s = \
       @%s, %s = @%s, %s = @%s WHERE %s = @%s;"
      table_name name name query query smart smart flag flag rating rating
      cover_path cover_path created_at created_at updated_at updated_at id id
  in
  let values = bind_names t in
  let statement = Sqlite3.prepare database request in
  let* () = Sqlite3.bind_names statement values in
  let* () = Sqlite3.step statement in
  let* () = Sqlite3.finalize statement in
  Ok t

(* Getter *)
let id t = t.id
let name t = t.name
let query t = t.query
let smart t = t.smart
let flag t = t.flag
let rating t = t.rating
let cover_path t = t.cover_path
let created_at t = t.created_at
let updated_at t = t.updated_at

(* Setter *)
let set_id id t = { t with id }
let set_name name t = { t with name }
let set_flag flag t = { t with flag }
let set_query query t = { t with query }
let set_rating rating t = { t with rating }
let set_cover_path cover_path t = { t with cover_path }
let set_created_at created_at t = { t with created_at }
let set_updated_at updated_at t = { t with updated_at }

(* Test *)
let equal : t -> t -> bool = ( = )
let compare : t -> t -> int = Stdlib.compare

(* Pp *)
let to_string t = Yojson.Safe.to_string (to_yojson t)

let pp format t =
  Format.fprintf format "%a" (Yojson.Safe.pretty_print ?std:None) (to_yojson t)