Source file album.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;
  year : int option;
  compilation : bool;
  flag : bool;
  rating : int option;
  comment : string option;
  genre : string option;
  cover_path : string option;
  created_at : float;
  updated_at : float;
}
[@@deriving yojson]

type (_, _) field =
  | Id : ('a, 'b) field -> (Int64.t -> 'a, 'b) field
  | Name : ('a, 'b) field -> (string -> 'a, 'b) field
  | SortName : ('a, 'b) field -> (string option -> 'a, 'b) field
  | Year : ('a, 'b) field -> (int option -> 'a, 'b) field
  | Compilation : ('a, 'b) field -> (bool -> 'a, 'b) field
  | Flag : ('a, 'b) field -> (bool -> 'a, 'b) field
  | Rating : ('a, 'b) field -> (int option -> 'a, 'b) field
  | Comment : ('a, 'b) field -> (string option -> 'a, 'b) field
  | Genre : ('a, 'b) field -> (string option -> 'a, 'b) field
  | CoverPath : ('a, 'b) field -> (string option -> 'a, 'b) field
  | CreatedAt : ('a, 'b) field -> (float -> 'a, 'b) field
  | UpdatedAt : ('a, 'b) field -> (float -> 'a, 'b) field
  | End : ('b, 'b) field

module Column = struct
  let id = "id"
  let name = "name"
  let sort_name = "sort_name"
  let year = "year"
  let compilation = "compilation"
  let flag = "flag"
  let rating = "rating"
  let comment = "comment"
  let genre = "genre"
  let cover_path = "cover_path"
  let created_at = "created_at"
  let updated_at = "updated_at"
end

let table_name = "albums"
let primary_key = Column.id
let p_id = Printf.sprintf "%s.%s" table_name primary_key

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 ~music_album_key ~id ~play_count ~duration ~size ~rating =
    Util.Stats.column_query ~music_album_key ~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

let init ~sort_name ~year ~compilation ~flag ~rating ~comment ~genre ~cover_path
    name =
  let created_at = Unix.time () in
  let updated_at = created_at in
  {
    id = 0L;
    name;
    sort_name;
    year;
    compilation;
    flag;
    rating;
    comment;
    genre;
    cover_path;
    created_at;
    updated_at;
  }

let rec fields : type a b. string list -> (a, b) field -> string list =
 fun fls field ->
  match field with
  | Id next ->
      fields (Column.id :: fls) next
  | Name next ->
      fields (Column.name :: fls) next
  | SortName next ->
      fields (Column.sort_name :: fls) next
  | Year next ->
      fields (Column.year :: fls) next
  | Compilation next ->
      fields (Column.compilation :: fls) next
  | Flag next ->
      fields (Column.flag :: fls) next
  | Rating next ->
      fields (Column.rating :: fls) next
  | Comment next ->
      fields (Column.comment :: fls) next
  | Genre next ->
      fields (Column.genre :: fls) next
  | CoverPath next ->
      fields (Column.cover_path :: fls) next
  | CreatedAt next ->
      fields (Column.created_at :: fls) next
  | UpdatedAt next ->
      fields (Column.updated_at :: fls) next
  | End ->
      List.rev fls

let rec select : type a b. Sqlite3.stmt -> int -> (a, b) field -> a -> b =
 fun stmt i field f ->
  match field with
  | Id next ->
      let id = Sqlite3.column_int64 stmt i in
      select stmt (i + 1) next (f id)
  | Name next ->
      let name = Sqlite3.column_text stmt i in
      select stmt (i + 1) next (f name)
  | SortName next ->
      let data = Sqlite3.column stmt i in
      let sort_name = Sqlite3.Data.to_string data in
      select stmt (i + 1) next (f sort_name)
  | Year next ->
      let data = Sqlite3.column stmt i in
      let year = Sqlite3.Data.to_int data in
      select stmt (i + 1) next (f year)
  | Rating next ->
      let data = Sqlite3.column stmt i in
      let rating = Sqlite3.Data.to_int data in
      select stmt (i + 1) next (f rating)
  | Compilation next ->
      let compilation = Sqlite3.column_bool stmt i in
      select stmt (i + 1) next (f compilation)
  | Flag next ->
      let flag = Sqlite3.column_bool stmt i in
      select stmt (i + 1) next (f flag)
  | Comment next ->
      let data = Sqlite3.column stmt i in
      let comment = Sqlite3.Data.to_string data in
      select stmt (i + 1) next (f comment)
  | Genre next ->
      let data = Sqlite3.column stmt i in
      let genre = Sqlite3.Data.to_string data in
      select stmt (i + 1) next (f genre)
  | CoverPath next ->
      let data = Sqlite3.column stmt i in
      let cover = Sqlite3.Data.to_string data in
      select stmt (i + 1) next (f cover)
  | CreatedAt next ->
      let create_at = Sqlite3.column_double stmt i in
      select stmt (i + 1) next (f create_at)
  | UpdatedAt next ->
      let updated_at = Sqlite3.column_double stmt i in
      select stmt (i + 1) next (f updated_at)
  | End ->
      f

let select stmt = select stmt 0

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 INTEGER,
    %s BOOLEAN NOT NULL,
    %s BOOLEAN NOT NULL,
    %s INTEGER,
    %s TEXT,
    %s TEXT,
    %s TEXT,
    %s REAL NOT NULL,
    %s REAL NOT NULL
  );|}
    table_name primary_key name sort_name year compilation flag rating comment
    genre cover_path created_at updated_at

let field_all =
  Id
    (Name
       (SortName
          (Year
             (Compilation
                (Flag
                   (Rating
                      (Comment (Genre (CoverPath (CreatedAt (UpdatedAt End)))))
                   )
                )
             )
          )
       )
    )

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 year = column_option statement D.to_int (offset + 3) in
  let compilation = Sqlite3.column_bool 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 comment = column_option statement D.to_string (offset + 7) in
  let genre = column_option statement D.to_string (offset + 8) in
  let cover_path = column_option statement D.to_string (offset + 9) in
  let created_at = Sqlite3.column_double statement (offset + 10) in
  let updated_at = Sqlite3.column_double statement (offset + 11) in
  ( {
      id;
      name;
      sort_name;
      year;
      compilation;
      flag;
      rating;
      comment;
      genre;
      cover_path;
      created_at;
      updated_at;
    },
    offset + 12
  )

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

let all database = filter_map database Option.some

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

let filter_map' database combine field f =
  let rec sql_loop acc stmt =
    match Sqlite3.step stmt with
    | Sqlite3.Rc.ROW -> (
        match combine @@ select stmt field f with
        | None ->
            sql_loop acc stmt
        | Some t ->
            sql_loop (t :: acc) stmt
      )
    | Sqlite3.Rc.DONE as rc ->
        (rc, List.rev acc)
    | rc ->
        (rc, List.rev acc)
  in
  let fields' = fields [] field in
  let fields =
    match fields' with [] -> fields [] field_all | _ :: _ as f -> f
  in
  let fields = String.concat ", " fields in
  let sql = Printf.sprintf "SELECT (%s) from %s;" fields table_name in
  let stmt = Sqlite3.prepare database sql in
  sql_loop [] stmt

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 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 = ?2, %s = ?3, %s = ?4, %s = ?5, %s = ?11, %s = ?6, %s \
       = ?7, %s = ?8, %s = ?9, %s = ?10 WHERE %s = ?1;"
      table_name Column.name Column.sort_name Column.year Column.compilation
      Column.flag Column.rating Column.comment Column.genre Column.cover_path
      Column.updated_at Column.id
  in
  let statement = Sqlite3.prepare database statement in
  let* () = Sqlite3.bind_int64 statement 1 t.id in
  let* () = Sqlite3.bind_text statement 2 t.name in
  let* () = bind_option Sqlite3.bind_text statement 3 t.sort_name in
  let* () = bind_option Sqlite3.bind_int statement 4 t.year in
  let* () = Sqlite3.bind_bool statement 5 t.compilation in
  let* () = bind_option Sqlite3.bind_int statement 6 t.rating in
  let* () = bind_option Sqlite3.bind_text statement 7 t.comment in
  let* () = bind_option Sqlite3.bind_text statement 8 t.genre in
  let* () = bind_option Sqlite3.bind_text statement 9 t.cover_path in
  let* () = Sqlite3.bind_double statement 10 t.updated_at in
  let* () = Sqlite3.bind_bool statement 11 t.flag in
  let* () = Sqlite3.step statement in
  let* () = Sqlite3.finalize statement in
  Ok t

let remove_id database id =
  let ( let* ) rc f =
    match rc with
    | Sqlite3.Rc.OK | Sqlite3.Rc.DONE ->
        f ()
    | rc ->
        let message = Sqlite3.errmsg database in
        Error (rc, message)
  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 insert database t =
  let ( let* ) = Util.bind_ok database in
  let bind_option = Util.bind_option in
  let statement' =
    let open Column in
    Printf.sprintf
      "INSERT INTO %s (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s) VALUES (?, \
       ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);"
      table_name name sort_name year compilation flag rating comment genre
      cover_path created_at 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_int statement 3 t.year in
  let* () = Sqlite3.bind_bool statement 4 t.compilation in
  let* () = Sqlite3.bind_bool statement 5 t.flag in
  let* () = bind_option Sqlite3.bind_int statement 6 t.rating in
  let* () = bind_option Sqlite3.bind_text statement 7 t.comment in
  let* () = bind_option Sqlite3.bind_text statement 8 t.genre in
  let* () = bind_option Sqlite3.bind_text statement 9 t.cover_path in
  let* () = Sqlite3.bind_double statement 10 t.created_at in
  let* () = Sqlite3.bind_double statement 11 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_insert database t =
  let { id = _; name; _ } = t in
  let _, albums =
    filter_map' database
      (fun album ->
        if album.name = name then
          Some album
        else
          None
      )
      field_all
      (fun id
           name
           sort_name
           year
           compilation
           flag
           rating
           comment
           genre
           cover_path
           created_at
           updated_at
         ->
        {
          id;
          name;
          sort_name;
          compilation;
          flag;
          year;
          rating;
          genre;
          comment;
          cover_path;
          created_at;
          updated_at;
        }
      )
  in
  match albums with t :: _ -> Ok t | [] -> insert database t

(* Getter *)
let id t = t.id
let name t = t.name
let sort_name t = t.sort_name
let year t = t.year
let compilation t = t.compilation
let flag t = t.flag
let rating t = t.rating
let comment t = t.comment
let genre t = t.genre
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_sort_name sort_name t = { t with sort_name }
let set_year year t = { t with year }
let set_compilation compilation t = { t with compilation }
let set_flag flag t = { t with flag }
let set_rating rating t = { t with rating }
let set_comment comment t = { t with comment }
let set_genre genre t = { t with genre }
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 *)
(* test : Issue when float is NaN. *)
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)