Source file artist.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;
  name : string;
  sort_name : string option;
  description : string option;
  artwork : string option;
  flag : bool;
  rating : int option;
  created_at : float;
  updated_at : float;
}
[@@deriving yojson]

module Column = struct
  let id = "id"
  let name = "name"
  let sort_name = "sort_name"
  let description = "description"
  let artwork = "artwork"
  let flag = "flag"
  let rating = "rating"
  let created_at = "created_at"
  let updated_at = "updated_at"

  let all =
    [
      id;
      name;
      sort_name;
      description;
      artwork;
      flag;
      rating;
      created_at;
      updated_at;
    ]
end

let init ~sort_name ~description ~artwork ~flag ~rating name =
  let created_at = Unix.time () in
  {
    id = 0L;
    name;
    sort_name;
    description;
    artwork;
    flag;
    rating;
    created_at;
    updated_at = created_at;
  }

let table_name = "artists"
let primary_key = Column.id
let p_id = Printf.sprintf "%s.%s" table_name primary_key
let p_name = Printf.sprintf "%s.%s" table_name Column.name

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

  let init' ~music_count ~duration ~play_count ~size ~avg_duration ~avg_rating
      ~avg_size
      (* we but album_count and played_at in this order to use Util.Stats.init *)
      ~album_count ~played_at =
    {
      music_count;
      album_count;
      duration;
      play_count;
      size;
      avg_duration;
      avg_rating;
      avg_size;
      played_at;
    }

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

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

  let column_query ~music_count ~album_count ~duration ~play_count ~size
      ~avg_rating ~played_at =
    let avg_duration = duration in
    let avg_size = size in
    Printf.sprintf
      {|
  COUNT(%s)
  ,COUNT(DISTINCT %s)
  ,SUM(%s)
  ,SUM(%s)
  ,SUM(%s)
  ,AVG(%s)
  ,AVG(%s)
  ,AVG(%s)
  ,MAX(%s)
  |}
      music_count album_count duration play_count size avg_duration avg_rating
      avg_size played_at

  let music_count t = t.music_count
  let album_count t = t.album_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
  let played_at t = t.played_at
end

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

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 name = Sqlite3.column_text statement (offset + 1) in
  let sort_name = column_option statement D.to_string (offset + 2) in
  let description = column_option statement D.to_string (offset + 3) in
  let artwork = column_option statement D.to_string (offset + 4) in
  let flag = Sqlite3.column_bool statement (offset + 5) in
  let rating = column_option statement D.to_int (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;
      sort_name;
      description;
      artwork;
      flag;
      rating;
      created_at;
      updated_at;
    },
    offset + 9
  )

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 artist, _ = columns stmt 0 in
        Queue.add artist 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 artist, _ = columns statement 0 in
        match func artist with
        | None ->
            ()
        | Some artist ->
            Queue.add artist queue
    )
  in
  let artists = queue |> Queue.to_seq |> List.of_seq in
  Util.bind_ok database rc @@ fun () -> Ok artists

let all database = filter_map database Option.some

let count database =
  let statement = Printf.sprintf "SELECT COUNT(*) from %s" table_name 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 _ = Sqlite3.finalize statement in
      Ok count
  | rc ->
      let message = Sqlite3.errmsg database in
      Error (rc, message)

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

let update database t =
  let ( let* ) = Util.bind_ok database in
  let bind_option = Util.bind_option in
  let updated_at = Unix.time () in
  let t = { t with updated_at } in
  let statement =
    Printf.sprintf
      "UPDATE %s SET %s = ?, %s = ?, %s = ?, %s = ?, %s = ?, %s = ?, %s = ? \
       WHERE %s = ?;"
      table_name Column.name Column.sort_name Column.description Column.artwork
      Column.flag Column.rating Column.updated_at Column.id
  in
  let statement = Sqlite3.prepare database statement in
  let* () = Sqlite3.bind_text statement 1 t.name in
  let* () = bind_option Sqlite3.bind_text statement 2 t.sort_name in
  let* () = bind_option Sqlite3.bind_text statement 3 t.description in
  let* () = bind_option Sqlite3.bind_text statement 4 t.artwork in
  let* () = Sqlite3.bind_bool statement 5 t.flag in
  let* () = bind_option Sqlite3.bind_int statement 6 t.rating in
  let* () = Sqlite3.bind_double statement 7 t.updated_at in
  let* () = Sqlite3.bind_int64 statement 8 t.id in
  let* () = Sqlite3.step statement in
  let* () = Sqlite3.finalize statement in
  Ok t

let insert database t =
  let ( let* ) = Util.bind_ok database in
  let bind_option = Util.bind_option in
  let statement' =
    Printf.sprintf
      "INSERT INTO %s (%s, %s, %s, %s, %s, %s, %s, %s) VALUES (?, ?, ?, ?, ?, \
       ?, ?, ?);"
      table_name Column.name Column.sort_name Column.description Column.artwork
      Column.flag Column.rating Column.created_at Column.updated_at
  in
  let statement = Sqlite3.prepare database statement' in
  (* Sqlite bind index are 1-based *)
  let* () = Sqlite3.bind_text statement 1 t.name in
  let* () = bind_option Sqlite3.bind_text statement 2 t.sort_name in
  let* () = bind_option Sqlite3.bind_text statement 3 t.description in
  let* () = bind_option Sqlite3.bind_text statement 4 t.artwork in
  let* () = Sqlite3.bind_bool statement 5 t.flag in
  let* () = bind_option Sqlite3.bind_int statement 6 t.rating in
  let* () = Sqlite3.bind_double statement 7 t.created_at in
  let* () = Sqlite3.bind_double statement 8 t.updated_at in
  let* () = Sqlite3.step statement in
  let* () = Sqlite3.finalize statement in
  let id = Sqlite3.last_insert_rowid database in
  Ok { t with id }

let find_or database t f =
  let ( let* ) = Result.bind in
  let* artists =
    filter_map database (fun artist ->
        if artist.name = t.name then
          Some artist
        else
          None
    )
  in
  match artists with
  | t :: _ ->
      Ok (t, true)
  | [] ->
      Result.map (fun r -> (r, false)) @@ f database t

let find_or_insert database t = find_or database t insert
let find_or_update database t = find_or database t update

(* Getter  *)
let id t = t.id
let name t = t.name
let sort_name t = t.sort_name
let description t = t.description
let artwork t = t.artwork
let flag t = t.flag
let rating t = t.rating
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_sort_name sort_name t = { t with sort_name }
let set_description description t = { t with description }
let set_artwork artwork t = { t with artwork }
let set_flag flag t = { t with flag }
let set_rating rating t = { t with rating }
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)