Source file musicFile.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.t;
  path : string;
  album_id : Int64.t option;
  size : int;
  play_count : int;
  flag : bool;
  rating : int option;
  duration : int;
  bitrate : int; (* default to 0*)
  samplerate : int; (* default to 0*)
  channels : int; (* default to 0*)
  has_cover : bool;
  played_at : float option;
  created_at : float;
  updated_at : float;
}
[@@deriving yojson]

module Column = struct
  let id = "id"
  let path = "path"
  let album_id = "album_id"
  let size = "size"
  let play_count = "play_count"
  let flag = "flag"
  let rating = "rating"
  let duration = "duration"
  let bitrate = "bitrate"
  let samplerate = "samplerate"
  let channels = "channels"
  let has_cover = "has_cover"
  let played_at = "played_at"
  let created_at = "created_at"
  let updated_at = "updated_at"
end

let audioproperties (music : t) =
  Otaglibc.
    {
      bitrate = music.bitrate;
      channels = music.channels;
      length = music.duration;
      samplerate = music.samplerate;
    }

let init ~audioproperties ~album_id ~size ~flag ~rating ~has_cover path =
  let Otaglibc.{ bitrate; channels; length; samplerate } =
    match audioproperties with
    | Some a ->
        a
    | None ->
        { bitrate = 0; channels = 0; length = 0; samplerate = 0 }
  in

  let created_at = Unix.time () in
  {
    id = 0L;
    path;
    album_id;
    size;
    play_count = 0;
    flag;
    rating;
    duration = length;
    bitrate;
    samplerate;
    channels;
    has_cover;
    played_at = None;
    created_at;
    updated_at = created_at;
  }

let table_name = "music_files"
let primary_key = Column.id
let foreign_album_id = Column.album_id
let key_size = Column.size
let key_play_count = Column.play_count
let key_rating = Column.rating
let key_duration = Column.duration
let p_id = Printf.sprintf "%s.%s" table_name primary_key
let p_album_id = Printf.sprintf "%s.%s" table_name foreign_album_id
let p_size = Printf.sprintf "%s.%s" table_name key_size
let p_play_count = Printf.sprintf "%s.%s" table_name key_play_count
let p_rating = Printf.sprintf "%s.%s" table_name key_rating
let p_duration = Printf.sprintf "%s.%s" table_name key_duration

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 INTEGER,
      %s INTEGER NOT NULL,
      %s INTEGER NOT NULL,
      %s BOOLEAN NOT NULL,
      %s INTEGER,
      %s INTEGER NOT NULL,
      %s INTEGER NOT NULL,
      %s INTEGER NOT NULL,
      %s INTEGER NOT NULL,
      %s BOOLEAN NOT NULL,
      %s REAL,
      %s REAL NOT NULL,
      %s REAL NOT NULL,
      FOREIGN KEY (%s)
        REFERENCES %s (%s)
          ON UPDATE CASCADE
          ON DELETE SET NULL
    );|}
    table_name id path album_id size play_count flag rating duration bitrate
    samplerate channels has_cover played_at created_at updated_at album_id
    Album.table_name Album.primary_key

let stats database =
  let statement =
    Printf.sprintf "SELECT COUNT(*), SUM(%s), SUM(%s) FROM %s;" table_name
      Column.size Column.duration
  in
  let statement = Sqlite3.prepare database statement in
  match Sqlite3.step statement with
  | Sqlite3.Rc.OK | Sqlite3.Rc.ROW ->
      let count = Sqlite3.column_int64 statement 0 in
      let sum = Sqlite3.column_int64 statement 1 in
      let duration = Sqlite3.column_int64 statement 2 in
      let _ = Sqlite3.finalize statement in
      Ok (count, sum, duration)
  | rc ->
      let message = Sqlite3.errmsg database in
      Error (rc, message)

let columns statement offset =
  let module D = Sqlite3.Data in
  let column_option statement conv offset =
    let data = Sqlite3.column statement offset in
    conv data
  in
  let id = Sqlite3.column_int64 statement offset in
  let path = Sqlite3.column_text statement (offset + 1) in
  let album_id = column_option statement D.to_int64 (offset + 2) in
  let size = Sqlite3.column_int statement (offset + 3) in
  let play_count = Sqlite3.column_int statement (offset + 4) in
  let flag = Sqlite3.column_bool statement (offset + 5) in
  let rating = column_option statement D.to_int (offset + 6) in
  let duration = Sqlite3.column_int statement (offset + 7) in
  let bitrate = Sqlite3.column_int statement (offset + 8) in
  let samplerate = Sqlite3.column_int statement (offset + 9) in
  let channels = Sqlite3.column_int statement (offset + 10) in
  let has_cover = Sqlite3.column_bool statement (offset + 11) in
  let played_at = column_option statement D.to_float (offset + 12) in
  let created_at = Sqlite3.column_double statement (offset + 13) in
  let updated_at = Sqlite3.column_double statement (offset + 14) in
  ( {
      id;
      path;
      album_id;
      size;
      play_count;
      flag;
      rating;
      duration;
      bitrate;
      samplerate;
      channels;
      has_cover;
      played_at;
      created_at;
      updated_at;
    },
    offset + 15
  )

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 music, _ = columns stmt 0 in
        Queue.add music queue
    )
  in
  Util.bind_ok db rc @@ fun () -> Ok (Queue.take_opt queue)

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 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 primary_key
  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 database t = remove_id database t.id

(** [insert ?old database t] inserts [t] into [database]. if [old], [insert]
    will use [id], [play_count], [flag], [rating] and [created_at] fields of
    [old] to insert and returns the value.

    @since 0.3.1 [played_at] field is also taken from [old] *)
let insert ?old database t =
  let ( let* ) = Util.bind_ok database in
  let bind_option = Util.bind_option in
  let id_field, bind_field, t =
    match old with
    | None ->
        (String.empty, String.empty, t)
    | Some old ->
        let t =
          {
            t with
            id = old.id;
            play_count = old.play_count;
            played_at = old.played_at;
            created_at = old.created_at;
            rating = old.rating;
            flag = old.flag;
          }
        in
        (Printf.sprintf "%s, " primary_key, Printf.sprintf "?, ", t)
  in
  let statement =
    let open Column in
    Printf.sprintf
      "INSERT INTO %s (%s %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, \
       %s) VALUES (%s ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);"
      table_name id_field path album_id size play_count flag rating duration
      bitrate samplerate channels has_cover played_at created_at updated_at
      bind_field
  in
  let statement = Sqlite3.prepare database statement in
  let offset =
    if Option.is_none old then
      0
    else
      1
  in
  let* () =
    match old with
    | None ->
        Sqlite3.Rc.OK
    | Some old ->
        Sqlite3.bind_int64 statement 1 old.id
  in
  let* () = Sqlite3.bind_text statement (offset + 1) t.path in
  let* () = bind_option Sqlite3.bind_int64 statement (offset + 2) t.album_id in
  let* () = Sqlite3.bind_int statement (offset + 3) t.size in
  let* () = Sqlite3.bind_int statement (offset + 4) t.play_count in
  let* () = Sqlite3.bind_bool statement (offset + 5) t.flag in
  let* () = bind_option Sqlite3.bind_int statement (offset + 6) t.rating in
  let* () = Sqlite3.bind_int statement (offset + 7) t.duration in
  let* () = Sqlite3.bind_int statement (offset + 8) t.bitrate in
  let* () = Sqlite3.bind_int statement (offset + 9) t.samplerate in
  let* () = Sqlite3.bind_int statement (offset + 10) t.channels in
  let* () = Sqlite3.bind_bool statement (offset + 11) t.has_cover in
  let* () =
    bind_option Sqlite3.bind_double statement (offset + 12) t.played_at
  in
  (* if old t.created_at is old.created_at *)
  let* () = Sqlite3.bind_double statement (offset + 13) t.created_at in
  let* () = Sqlite3.bind_double statement (offset + 14) t.updated_at in
  let* () = Sqlite3.step statement in
  let* () = Sqlite3.finalize statement in
  (*No need to also extract created_at from old since if old, t.created_at
    old.created.
   *)
  let id =
    match old with
    | None ->
        Sqlite3.last_insert_rowid database
    | Some old ->
        old.id
  in
  Ok { t with id }

let update_bind database statement t =
  let ( let* ) = Util.bind_ok database in
  let bind_option = Util.bind_option in
  let* () = Sqlite3.bind_text statement 1 t.path in
  let* () = bind_option Sqlite3.bind_int64 statement 2 t.album_id in
  let* () = Sqlite3.bind_int statement 3 t.size in
  let* () = Sqlite3.bind_int statement 4 t.play_count in
  let* () = Sqlite3.bind_bool statement 5 t.flag in
  let* () = bind_option Sqlite3.bind_int statement 6 t.rating in
  let* () = Sqlite3.bind_int statement 7 t.duration in
  let* () = Sqlite3.bind_int statement 8 t.bitrate in
  let* () = Sqlite3.bind_int statement 9 t.samplerate in
  let* () = Sqlite3.bind_int statement 10 t.channels in
  let* () = Sqlite3.bind_bool statement 11 t.has_cover in
  let* () = bind_option Sqlite3.bind_double statement 12 t.played_at in
  let* () = Sqlite3.bind_double statement 13 t.created_at in
  let* () = Sqlite3.bind_double statement 14 t.updated_at in
  let* () = Sqlite3.bind_int64 statement 15 t.id in
  Ok statement

let update database t =
  let ( let** ) = Util.bind_ok database in
  let ( let* ) = Result.bind in
  let updated_at = Unix.time () in
  let t = { t with updated_at } in
  let statement =
    let open Column in
    Printf.sprintf
      "UPDATE %s SET %s = ?, %s = ?, %s = ?, %s = ?, %s = ?, %s = ?, %s = ?, \
       %s = ?, %s = ?, %s = ?, %s = ?, %s = ?, %s = ?, %s = ? WHERE %s = ?;"
      table_name path album_id size play_count flag rating duration bitrate
      samplerate channels has_cover played_at created_at updated_at id
  in
  let statement = Sqlite3.prepare database statement in
  let* statement = update_bind database statement t in
  let** () = Sqlite3.step statement in
  let** () = Sqlite3.finalize statement in
  Ok t

let id t = t.id
let path t = t.path
let album_id t = t.album_id
let size t = t.size
let play_count t = t.play_count
let flag t = t.flag
let rating t = t.rating
let duration t = t.duration
let bitrate t = t.bitrate
let samplerate t = t.samplerate
let channels t = t.channels
let has_cover t = t.has_cover
let played_at t = t.played_at
let created_at t = t.created_at
let updated_at t = t.updated_at
let set_id id t = { t with id }
let set_path path t = { t with path }
let set_album_id album_id t = { t with album_id }
let set_size size t = { t with size }
let set_play_count play_count t = { t with play_count }
let set_flag flag t = { t with flag }
let set_rating rating t = { t with rating }
let set_duration duration t = { t with duration }
let set_bitrate bitrate t = { t with bitrate }
let set_samplerate samplerate t = { t with samplerate }
let set_channels channels t = { t with channels }
let set_has_cover has_cover t = { t with has_cover }
let set_played_at played_at t = { t with played_at }
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)