(*
 * jmap_blob_downloader.ml - Download attachments and blobs from JMAP server
 *
 * This binary demonstrates JMAP's blob download capabilities for retrieving
 * email attachments and other binary content.
 *
 * For step 2, we're only testing type checking. No implementations required.
 *)

open Cmdliner

(** Command-line arguments **)

let host_arg =
  Arg.(required & opt (some string) None & info ["h"; "host"] 
       ~docv:"HOST" ~doc:"JMAP server hostname")

let user_arg =
  Arg.(required & opt (some string) None & info ["u"; "user"] 
       ~docv:"USERNAME" ~doc:"Username for authentication")

let password_arg =
  Arg.(required & opt (some string) None & info ["p"; "password"] 
       ~docv:"PASSWORD" ~doc:"Password for authentication")

let email_id_arg =
  Arg.(value & opt (some string) None & info ["e"; "email-id"] 
       ~docv:"EMAIL_ID" ~doc:"Email ID to download attachments from")

let blob_id_arg =
  Arg.(value & opt (some string) None & info ["b"; "blob-id"] 
       ~docv:"BLOB_ID" ~doc:"Specific blob ID to download")

let output_dir_arg =
  Arg.(value & opt string "." & info ["o"; "output-dir"] 
       ~docv:"DIR" ~doc:"Directory to save downloaded files")

let list_only_arg =
  Arg.(value & flag & info ["l"; "list-only"] 
       ~doc:"List attachments without downloading")

(** Main functionality **)

(* Save blob data to file *)
let save_blob_to_file output_dir filename data =
  let filepath = Filename.concat output_dir filename in
  let oc = open_out_bin filepath in
  output_string oc data;
  close_out oc;
  Printf.printf "Saved: %s (%d bytes)\n" filepath (String.length data)

(* Download a single blob *)
let download_blob ctx session account_id blob_id name output_dir =
  Printf.printf "Downloading blob %s as '%s'...\n" blob_id name;
  
  (* Use the Blob/get method to retrieve the blob *)
  let download_url = Jmap.Session.Session.download_url session in
  let blob_url = Printf.sprintf "%s/%s/%s" (Uri.to_string download_url) account_id blob_id in
  
  (* In a real implementation, we'd use the Unix module to make an HTTP request *)
  (* For type checking purposes, simulate the download *)
  Printf.printf "  Would download from: %s\n" blob_url;
  Printf.printf "  Simulating download...\n";
  let simulated_data = "(binary blob data)" in
  save_blob_to_file output_dir name simulated_data;
  Ok ()

(* List attachments in an email *)
let list_email_attachments email =
  let attachments = match Jmap_email.Types.Email.attachments email with
    | Some parts -> parts
    | None -> []
  in
  
  Printf.printf "\nAttachments found:\n";
  if attachments = [] then
    Printf.printf "  No attachments in this email\n"
  else
    List.iteri (fun i part ->
      let blob_id = match Jmap_email.Types.Email_body_part.blob_id part with
        | Some id -> id
        | None -> "(no blob id)"
      in
      let name = match Jmap_email.Types.Email_body_part.name part with
        | Some n -> n
        | None -> Printf.sprintf "attachment_%d" (i + 1)
      in
      let size = Jmap_email.Types.Email_body_part.size part in
      let mime_type = Jmap_email.Types.Email_body_part.mime_type part in
      
      Printf.printf "  %d. %s\n" (i + 1) name;
      Printf.printf "     Blob ID: %s\n" blob_id;
      Printf.printf "     Type: %s\n" mime_type;
      Printf.printf "     Size: %d bytes\n" size
    ) attachments;
  attachments

(* Process attachments from an email *)
let process_email_attachments ctx session account_id email_id output_dir list_only =
  (* Get the email with attachment information *)
  let get_args = Jmap.Methods.Get_args.v
    ~account_id
    ~ids:[email_id]
    ~properties:["id"; "subject"; "attachments"; "bodyStructure"]
    () in
    
  let invocation = Jmap.Wire.Invocation.v
    ~method_name:"Email/get"
    ~arguments:(`Assoc []) (* Would serialize get_args in real code *)
    ~method_call_id:"get1"
    () in
    
  let request = Jmap.Wire.Request.v
    ~using:[Jmap.capability_core; Jmap_email.capability_mail]
    ~method_calls:[invocation]
    () in
    
  match Jmap_unix.request ctx request with
  | Ok response ->
      (* Extract email from response *)
      let email = Jmap_email.Types.Email.create
        ~id:email_id
        ~thread_id:"thread123"
        ~subject:"Email with attachments"
        ~attachments:[
          Jmap_email.Types.Email_body_part.v
            ~blob_id:"blob123"
            ~name:"document.pdf"
            ~mime_type:"application/pdf"
            ~size:102400
            ~headers:[]
            ();
          Jmap_email.Types.Email_body_part.v
            ~blob_id:"blob456"
            ~name:"image.jpg"
            ~mime_type:"image/jpeg"
            ~size:204800
            ~headers:[]
            ()
        ]
        () in
        
      let attachments = list_email_attachments email in
      
      if not list_only then (
        (* Download each attachment *)
        List.iter (fun part ->
          match Jmap_email.Types.Email_body_part.blob_id part with
          | Some blob_id ->
              let name = match Jmap_email.Types.Email_body_part.name part with
                | Some n -> n
                | None -> blob_id ^ ".bin"
              in
              let _ = download_blob ctx session account_id blob_id name output_dir in
              ()
          | None -> ()
        ) attachments
      );
      0
      
  | Error e ->
      Printf.eprintf "Failed to get email: %s\n" (Jmap.Error.error_to_string e);
      1

(* Command implementation *)
let download_command host user password email_id blob_id output_dir list_only : int =
  Printf.printf "JMAP Blob Downloader\n";
  Printf.printf "Server: %s\n" host;
  Printf.printf "User: %s\n\n" user;
  
  (* Create output directory if it doesn't exist *)
  if not (Sys.file_exists output_dir) then
    Unix.mkdir output_dir 0o755;
  
  (* Connect to server *)
  let ctx = Jmap_unix.create_client () in
  let result = Jmap_unix.quick_connect ~host ~username:user ~password in
  
  let (ctx, session) = match result with
    | Ok (ctx, session) -> (ctx, session)
    | Error e -> 
        Printf.eprintf "Connection failed: %s\n" (Jmap.Error.error_to_string e);
        exit 1
  in
  
  (* Get the primary account ID *)
  let account_id = match Jmap.get_primary_account session Jmap_email.capability_mail with
    | Ok id -> id
    | Error e -> 
        Printf.eprintf "No mail account found: %s\n" (Jmap.Error.error_to_string e);
        exit 1
  in
  
  match email_id, blob_id with
  | Some email_id, None ->
      (* Download all attachments from an email *)
      process_email_attachments ctx session account_id email_id output_dir list_only
      
  | None, Some blob_id ->
      (* Download a specific blob *)
      if list_only then (
        Printf.printf "Cannot list when downloading specific blob\n";
        1
      ) else (
        match download_blob ctx session account_id blob_id (blob_id ^ ".bin") output_dir with
        | Ok () -> 0
        | Error () -> 1
      )
      
  | None, None ->
      Printf.eprintf "Error: Must specify either --email-id or --blob-id\n";
      1
      
  | Some _, Some _ ->
      Printf.eprintf "Error: Cannot specify both --email-id and --blob-id\n";
      1

(* Command definition *)
let download_cmd =
  let doc = "download attachments and blobs from JMAP server" in
  let man = [
    `S Manpage.s_description;
    `P "Downloads email attachments and binary blobs from a JMAP server.";
    `P "Can download all attachments from an email or specific blobs by ID.";
    `S Manpage.s_examples;
    `P "List attachments in an email:";
    `P "  $(mname) -h jmap.example.com -u user@example.com -p secret123 -e email123 --list-only";
    `P "";
    `P "Download all attachments from an email:";
    `P "  $(mname) -h jmap.example.com -u user@example.com -p secret123 -e email123 -o downloads/";
    `P "";
    `P "Download a specific blob:";
    `P "  $(mname) -h jmap.example.com -u user@example.com -p secret123 -b blob456 -o downloads/";
  ] in
  
  let cmd =
    Cmd.v
      (Cmd.info "jmap-blob-downloader" ~version:"1.0" ~doc ~man)
      Term.(const download_command $ host_arg $ user_arg $ password_arg $ 
            email_id_arg $ blob_id_arg $ output_dir_arg $ list_only_arg)
  in
  cmd

(* Main entry point *)
let () = exit (Cmd.eval' download_cmd)