defmodule Pdf.Reader.XMP do
  @moduledoc """
  XMP RDF/XML metadata parser.

  Extracts a flat `%{String.t() => String.t()}` map keyed by /Info-compatible
  names ("Title", "Author", "Subject", "Description", "Creator", "Producer",
  "CreationDate", "ModDate", "Keywords") from a catalog `/Metadata` XMP packet.

  ## Recognized namespaces (URI-based, not prefix-based)

  - `http://purl.org/dc/elements/1.1/` (dc) — Dublin Core
  - `http://ns.adobe.com/xap/1.0/` (xmp) — XMP Basic
  - `http://ns.adobe.com/pdf/1.3/` (pdf) — PDF
  - `http://www.w3.org/1999/02/22-rdf-syntax-ns#` (rdf) — RDF containers

  ## Mapping to /Info keys

  - dc:title → "Title"
  - dc:creator (rdf:Bag, **first element only**) → "Author"
  - dc:subject (rdf:Bag, first element) → "Subject"
  - dc:description (rdf:Alt) → **"Description"** (distinct from "Subject")
  - xmp:CreateDate → "CreationDate"
  - xmp:ModifyDate → "ModDate"
  - xmp:CreatorTool → "Creator"
  - pdf:Producer → "Producer"
  - pdf:Keywords → "Keywords"

  ## Error handling

  Malformed XML returns `{:error, :malformed_xmp}` — never raises. Empty
  rdf:RDF document returns `{:ok, %{}}`.

  ## Spec references
  - PDF 1.7 (ISO 32000-1) § 14.3.2 — Metadata Streams:
    https://opensource.adobe.com/dc-acrobat-sdk-docs/standards/pdfstandards/pdf/PDF32000_2008.pdf
  - XMP Specification Part 1 (data model, serialization):
    https://github.com/adobe/xmp-docs/raw/master/XMPSpecificationPart1.pdf
  - W3C RDF/XML Syntax Specification:
    https://www.w3.org/TR/rdf-syntax-grammar/
  """

  require Record

  # ---------------------------------------------------------------------------
  # Erlang :xmerl record definitions
  # ---------------------------------------------------------------------------

  Record.defrecordp(:xmlElement, Record.extract(:xmlElement, from_lib: "xmerl/include/xmerl.hrl"))
  Record.defrecordp(:xmlText, Record.extract(:xmlText, from_lib: "xmerl/include/xmerl.hrl"))

  Record.defrecordp(
    :xmlAttribute,
    Record.extract(:xmlAttribute, from_lib: "xmerl/include/xmerl.hrl")
  )

  # ---------------------------------------------------------------------------
  # Namespace URI constants (atoms — xmerl uses atoms for namespace URIs when
  # namespace_conformant: true is passed to :xmerl_scan.string/2)
  # ---------------------------------------------------------------------------

  @dc :"http://purl.org/dc/elements/1.1/"
  @xmp :"http://ns.adobe.com/xap/1.0/"
  @pdf :"http://ns.adobe.com/pdf/1.3/"
  @rdf :"http://www.w3.org/1999/02/22-rdf-syntax-ns#"

  # ---------------------------------------------------------------------------
  # Public API
  # ---------------------------------------------------------------------------

  @spec parse(binary()) :: {:ok, %{String.t() => String.t()}} | {:error, :malformed_xmp}
  def parse(xml_binary) when is_binary(xml_binary) do
    try do
      {doc, _rest} =
        :xmerl_scan.string(
          :binary.bin_to_list(xml_binary),
          document: true,
          quiet: true,
          namespace_conformant: true
        )

      {:ok, extract_from_document(doc)}
    rescue
      _ -> {:error, :malformed_xmp}
    catch
      :exit, _ -> {:error, :malformed_xmp}
    end
  end

  # ---------------------------------------------------------------------------
  # Document-level extraction
  # ---------------------------------------------------------------------------

  # xmlDocument is a 2-tuple {:xmlDocument, [root_element]}
  defp extract_from_document({:xmlDocument, children}) do
    children
    |> Enum.filter(fn node -> elem(node, 0) == :xmlElement end)
    |> Enum.reduce(%{}, fn root, acc -> Map.merge(acc, walk(root)) end)
  end

  defp extract_from_document(_), do: %{}

  # ---------------------------------------------------------------------------
  # Tree walker — recurse depth-first; accumulate key/value pairs on the way
  # ---------------------------------------------------------------------------

  defp walk(xmlElement(expanded_name: {@rdf, :RDF}, content: content)) do
    # rdf:RDF — walk into rdf:Description children
    content
    |> filter_elements()
    |> Enum.reduce(%{}, fn child, acc -> Map.merge(acc, walk(child)) end)
  end

  defp walk(xmlElement(expanded_name: {@rdf, :Description}, content: content)) do
    # rdf:Description — walk into property children
    content
    |> filter_elements()
    |> Enum.reduce(%{}, fn child, acc -> Map.merge(acc, walk(child)) end)
  end

  # dc:title → "Title" (rdf:Alt — return x-default or first)
  defp walk(xmlElement(expanded_name: {@dc, :title}, content: content)) do
    extract_property("Title", content, :alt)
  end

  # dc:creator → "Author" (rdf:Bag or rdf:Seq — first element only)
  defp walk(xmlElement(expanded_name: {@dc, :creator}, content: content)) do
    extract_property("Author", content, :first)
  end

  # dc:subject → "Subject" (rdf:Bag — first element)
  defp walk(xmlElement(expanded_name: {@dc, :subject}, content: content)) do
    extract_property("Subject", content, :first)
  end

  # dc:description → "Description" (rdf:Alt — distinct from subject)
  defp walk(xmlElement(expanded_name: {@dc, :description}, content: content)) do
    extract_property("Description", content, :alt)
  end

  # xmp:CreateDate → "CreationDate" (simple text)
  defp walk(xmlElement(expanded_name: {@xmp, :CreateDate}, content: content)) do
    extract_simple("CreationDate", content)
  end

  # xmp:ModifyDate → "ModDate" (simple text)
  defp walk(xmlElement(expanded_name: {@xmp, :ModifyDate}, content: content)) do
    extract_simple("ModDate", content)
  end

  # xmp:CreatorTool → "Creator" (simple text)
  defp walk(xmlElement(expanded_name: {@xmp, :CreatorTool}, content: content)) do
    extract_simple("Creator", content)
  end

  # pdf:Producer → "Producer" (simple text)
  defp walk(xmlElement(expanded_name: {@pdf, :Producer}, content: content)) do
    extract_simple("Producer", content)
  end

  # pdf:Keywords → "Keywords" (simple text)
  defp walk(xmlElement(expanded_name: {@pdf, :Keywords}, content: content)) do
    extract_simple("Keywords", content)
  end

  # x:xmpmeta wrapper — skip past it into children
  defp walk(xmlElement(content: content)) do
    content
    |> filter_elements()
    |> Enum.reduce(%{}, fn child, acc -> Map.merge(acc, walk(child)) end)
  end

  # ---------------------------------------------------------------------------
  # Property extraction helpers
  # ---------------------------------------------------------------------------

  # Extract a property whose value is a container (rdf:Alt, rdf:Bag, rdf:Seq).
  # :alt — x-default first, else first li
  # :first — first li text only
  defp extract_property(key, content, mode) do
    container = content |> filter_elements() |> List.first()

    value =
      case container do
        nil ->
          # No container — try treating content as simple text
          extract_text_value(content)

        xmlElement(expanded_name: {@rdf, tag}, content: li_content)
        when tag in [:Alt, :Bag, :Seq] ->
          li_elements = filter_elements(li_content)

          case mode do
            :alt ->
              # Prefer x-default lang attribute, else first
              xdefault =
                Enum.find(li_elements, fn li ->
                  attrs = xmlElement(li, :attributes)

                  Enum.any?(attrs, fn attr ->
                    xmlAttribute(attr, :value) == ~c"x-default"
                  end)
                end)

              target = xdefault || List.first(li_elements)
              if target, do: extract_text_value(xmlElement(target, :content)), else: nil

            :first ->
              first_li = List.first(li_elements)
              if first_li, do: extract_text_value(xmlElement(first_li, :content)), else: nil
          end

        _ ->
          nil
      end

    if value, do: %{key => value}, else: %{}
  end

  # Extract a simple text node (no container)
  defp extract_simple(key, content) do
    case extract_text_value(content) do
      nil -> %{}
      value -> %{key => value}
    end
  end

  # ---------------------------------------------------------------------------
  # Text value extraction
  # ---------------------------------------------------------------------------

  defp extract_text_value(content) do
    content
    |> Enum.filter(fn node -> elem(node, 0) == :xmlText end)
    |> Enum.map(fn text_node ->
      xmlText(text_node, :value)
      |> :unicode.characters_to_binary()
      |> case do
        bin when is_binary(bin) -> String.trim(bin)
        _ -> nil
      end
    end)
    |> Enum.reject(fn v -> is_nil(v) or v == "" end)
    |> List.first()
  end

  # ---------------------------------------------------------------------------
  # Helpers
  # ---------------------------------------------------------------------------

  defp filter_elements(nodes) do
    Enum.filter(nodes, fn node -> elem(node, 0) == :xmlElement end)
  end
end