--
-- Copyright (c) 2021-2025 Zeping Lee
-- Released under the MIT license.
-- Repository: https://github.com/zepinglee/citeproc-lua
--

local engine = {}

local dom
local context
local element
local nodes
local node_locale
local node_style
local output
local util

local using_luatex, _ = pcall(require, "kpse")
if using_luatex then
 dom = require("luaxml-domobject")
 context = require("citeproc-context")
 element = require("citeproc-element")
 nodes = require("citeproc-nodes")
 node_locale = require("citeproc-node-locale")
 node_style = require("citeproc-node-style")
 output = require("citeproc-output")
 util = require("citeproc-util")
else
 dom = require("citeproc.luaxml.domobject")
 context = require("citeproc.context")
 element = require("citeproc.element")
 nodes = require("citeproc.nodes")
 node_locale = require("citeproc.node-locale")
 node_style = require("citeproc.node-style")
 output = require("citeproc.output")
 util = require("citeproc.util")
end

local Element = element.Element
local Style = node_style.Style
local Locale = node_locale.Locale
local Context = context.Context
local IrState = context.IrState
local LatexWriter = output.LatexWriter
local HtmlWriter = output.HtmlWriter
local SortStringFormat = output.SortStringFormat

local Position = util.Position


---@alias CitationId string
---@alias ItemId string | number
---@alias NoteIndex integer
---@alias ChapterIndex number

---@class CitationData
---@field citationID CitationId
---@field citationItems CitationItem[]
---@field properties CitationProperties
---@field citation_index integer
---@field sorted_items CitationItem[]

---@class CitationItem
---@field id CiteId
---@field prefix string?
---@field suffix string?
---@field locator string?
---@field label string?
---@field position_level Position?
---@field near_note boolean?
---@field num_citations integer?

---@class CitationProperties
---@field noteIndex NoteIndex,
---@field chapterIndex ChapterIndex,
---@field mode string?
---@field prefix string?
---@field suffix string?
---@field unsorted boolean?


---@class NameVariable
---@field family string?
---@field given string?
---@field dropping-particle string?
---@field non-dropping-particle string?
---@field suffix string?
---@field comma-suffix string | number | boolean?
---@field static-ordering string | number | boolean?
---@field literal string | number | boolean?
---@field parse-names string | number | boolean?

---@class DateVariable
---@field date-parts (string | number)[][]
---@field season (string | number)
---@field circa (string | number | boolean)
---@field literal string
---@field raw string

---@alias ItemData { id: ItemId, type: string, language: string?, [string]: string | number | NameVariable[] | DateVariable }


---@class Registry
---@field citations_by_id table<ItemId, CitationData>
---@field citation_list CitationData[]
---@field citations_by_item_id table<ItemId, CitationData[]>
---@field registry table<ItemId, ItemData>
---@field reflist ItemId[]
---@field uncited_list ItemId[]
---@field previous_citation CitationData?
---@field requires_sorting boolean
---@field widest_label string
---@field maxoffset integer
---@field second_field_align string | boolean
local Registry = {}


---@class CiteProc
---@field style Style
---@field sys CiteProcSys
---@field locales table<LanguageCode, Locale>
---@field system_locales table<LanguageCode, Locale>
---@field lang LanguageCode
---@field output_format OutputFormat
---@field opt table
---@field registry Registry
---@field cite_first_note_numbers table<ItemId, NoteIndex>
---@field cite_last_note_numbers table<ItemId, NoteIndex>
---@field tainted_item_ids table<ItemId, boolean>
---@field disam_irs IrNode[]
---@field cite_irs_by_output table<string, IrNode[]>
---@field person_names PersonNameIr[]
---@field person_names_by_output table<string, PersonNameIr[]>
---@field locale_tags_info_dict table<LanguageCode, table>
local CiteProc = {}

---@class CiteProcSys
---@field retrieveLocale fun(LanguageCode): string?
---@field retrieveItem fun(ItemId): ItemData?

---@param sys table
---@param style string
---@param lang string?
---@param force_lang boolean?
---@return CiteProc
function CiteProc.new(sys, style, lang, force_lang)
 if not sys then
   error("\"citeprocSys\" required")
 end
 if sys.retrieveLocale == nil then
   error("\"citeprocSys.retrieveLocale\" required")
 end
 if sys.retrieveItem == nil then
   error("\"citeprocSys.retrieveItem\" required")
 end
 local parsed_style = Style:parse(style)
 local engine_lang = parsed_style.default_locale
 if not engine_lang or force_lang then
   engine_lang = lang or "en-US"
 end
 ---@type CiteProc
 local o = {
   style = parsed_style,
   sys = sys,
   locales = {},
   system_locales = {},
   lang = engine_lang,
   output_format = LatexWriter:new(),
   opt = {
     -- Similar to citeproc-js's development_extensions.wrap_url_and_doi
     wrap_url_and_doi = false,
     citation_link = false,
     title_link = false,
   },
   registry = {
     citations_by_id = {},  -- A map
     citation_list = {},  -- A list
     citations_by_item_id = {},  -- A map from item id to a map of citations
     registry = {},  -- A map of bibliographic meta data
     reflist = {},  -- list of cited ids
     uncited_list = {},
     previous_citation = nil,
     requires_sorting = false,
     widest_label = "",
     maxoffset = 0,
     second_field_align = false,
   },

   cite_first_note_numbers = {},
   cite_last_note_numbers = {},

   tainted_item_ids = {},

   disam_irs = {},
   -- { <ir1>, <ir2>, ...  }

   cite_irs_by_output = {},
   -- {
   --   ["Roe, J"] = {<ir1>},
   --   ["Doe, J"] = {<ir2>, <ir3>},
   --   ["Doe, John"] = {<ir2>},
   --   ["Doe, Jack"] = {<ir2>},
   -- }

   person_names = {},
   person_names_by_output = {},

   locale_tags_info_dict = {},
 }

 setmetatable(o, {__index = CiteProc})
 return o
end

---@return boolean
function CiteProc:is_dependent_style()
 return self.style.info.independent_parent ~= nil
end

---@return string?
function CiteProc:get_independent_parent()
 return self.style.info.independent_parent
end

---@param ids CiteId[]
function CiteProc:updateItems(ids)
 self.registry.reflist = {}
 self.registry.registry = {}
 self.person_names = {}
 self.person_names_by_output = {}
 self.disam_irs = {}
 self.cite_irs_by_output = {}

 local cite_items = {}
 local loaded_ids = {}

 for _, id in ipairs(ids) do
   if not loaded_ids[id] then
     table.insert(cite_items, {id = id})
     loaded_ids[id] = true
   end
 end
 for _, id in ipairs(self.registry.uncited_list) do
   if not loaded_ids[id] then
     table.insert(cite_items, {id = id})
     loaded_ids[id] = true
   end
 end

 -- Clean the first note number to reset all the positions
 self.cite_first_note_numbers = {}

 -- TODO: optimize this
 self:makeCitationCluster(cite_items)

 self.registry.previous_citation = nil
 self.cite_first_note_numbers = {}
 self.cite_last_note_numbers = {}

 for _, item in ipairs(self.registry.registry) do
   item.year_suffix_number = nil
   item["year-suffix"] = nil
 end
end

function CiteProc:updateUncitedItems(uncited_ids)
 -- self.registry.reflist = {}
 self.registry.registry = {}
 self.registry.uncited_list = {}
 self.person_names = {}
 self.person_names_by_output = {}
 self.disam_irs = {}
 self.cite_irs_by_output = {}

 local cite_items = {}
 local loaded_ids = {}

 for _, id in ipairs(self.registry.reflist) do
   if not loaded_ids[id] then
     table.insert(cite_items, {id = id})
     loaded_ids[id] = true
   end
 end
 self.registry.reflist = {}

 for _, id in ipairs(uncited_ids) do
   if not loaded_ids[id] then
     table.insert(cite_items, {id = id})
     loaded_ids[id] = true
   end
 end

 loaded_ids = {}
 for _, id in ipairs(uncited_ids) do
   if not loaded_ids[id] then
     table.insert(self.registry.uncited_list, id)
     loaded_ids[id] = true
   end
 end

 -- TODO: optimize this
 self:makeCitationCluster(cite_items)

 self.registry.previous_citation = nil
 self.cite_first_note_numbers = {}
 self.cite_last_note_numbers = {}
end


---@alias PreCitation [CitationId, NoteIndex, ChapterIndex?]
---@alias PostCitation [CitationId, NoteIndex, ChapterIndex?]

---@param citation CitationData
---@param citations_pre PreCitation[]
---@param citations_post PostCitation[]
---@return [table, [integer, string, CitationId][]]
function CiteProc:processCitationCluster(citation, citations_pre, citations_post)
 self:_check_valid_citation_element()
 citation = self:_normalize_citation_input(citation)
 self:_check_input(citation, citations_pre, citations_post)

 local citation_list, item_ids = self:_build_reconstituted_citation_list(citation, citations_pre, citations_post)
 self:updateItems(item_ids)
 if #citation.sorted_items > 1 and self.style.citation.sort and not citation.properties.unsorted then
   citation.sorted_items = self.style.citation:sorted_citation_items(citation.citationItems, self)
 end

 local tainted_citation_ids = self:_set_positions(citation_list)

 tainted_citation_ids[citation.citationID] = true

 local params = {
   bibchange = false,
   citation_errors = {},
 }
 -- TODO: evaluate params.bibchange

 local result = self:_rerun_changed_cites(tainted_citation_ids)

 return {params, result}
end

-- A variant of processCitationCluster() for easy use with LaTeX.
-- It should be run after refreshing the registry (updateItems()) with all items
---@param citation CitationData
---@return string
function CiteProc:process_citation(citation)
 self:_check_valid_citation_element()
 citation = self:_normalize_citation_input(citation)

 local citations_pre = {}
 for _, citation_ in ipairs(self.registry.citation_list) do
   table.insert(citations_pre, {citation_.citationID, citation_.properties.noteIndex})
 end
 self:_check_input(citation, citations_pre, {})

 local citation_list, item_ids = self:_build_reconstituted_citation_list(citation, citations_pre, {})
 -- self:updateItems(item_ids)
 for _, cite_item in ipairs(citation.citationItems) do
   self:get_item(cite_item.id)
 end
 if #citation.sorted_items > 1 and self.style.citation.sort and not citation.properties.unsorted then
   citation.sorted_items = self.style.citation:sorted_citation_items(citation.citationItems, self)
 end

 self:_set_positions(citation_list)
 local tainted_citation_ids = {[citation.citationID] = true}
 local result = self:_rerun_changed_cites(tainted_citation_ids)
 return result[1][2]
end

function CiteProc:makeCitationCluster(citation_items)
 local special_form = nil
 local items = {}

 for i, cite_item in ipairs(citation_items) do
   cite_item = self:_normalize_cite_item(cite_item)
   local item_data = self:get_item(cite_item.id)

   -- Create a wrapper of the orignal item from registry so that
   -- it may hold different `locator` or `position` values for cites.
   local cite_item = setmetatable(cite_item, {__index = item_data})

   if not special_form then
     for _, form in ipairs({"author-only", "suppress-author", "coposite"}) do
       if cite_item[form] then
         special_form = form
       end
     end
   end

   -- Set "first-reference-note-number" variable when called from
   -- processCitationCluster() > updateItems()
   local citations = self.registry.citations_by_item_id[cite_item.id]
   if citations and #citations > 0 then
     cite_item["first-reference-note-number"] = citations[1].properties.noteIndex
   end

   cite_item.position_level = Position.First
   if self.cite_first_note_numbers[cite_item.id] then
     cite_item.position_level = Position.Subsequent
   else
     self.cite_first_note_numbers[cite_item.id] = 0
   end

   local preceding_cite
   if i == 1 then
     local previous_citation = self.registry.previous_citation
     if previous_citation then
       if #previous_citation.citationItems == 1 and previous_citation.citationItems[1].id == cite_item.id then
         preceding_cite = previous_citation.citationItems[1]
       end
     end
   elseif citation_items[i - 1].id == cite_item.id then
     preceding_cite = citation_items[i - 1]
   end

   if preceding_cite then
     cite_item.position_level = self:_get_ibid_position(cite_item, preceding_cite)
   end

   table.insert(items, cite_item)
 end

 if self.registry.requires_sorting then
   self:sort_bibliography()
 end

 self:_check_valid_citation_element()
 local citation_element = self.style.citation
 if special_form == "author-only" and self.style.intext then
   citation_element = self.style.intext
 end

 if #items > 1 and self.style.citation.sort then
   items = self.style.citation:sorted_citation_items(items, self)
 end
 local res = citation_element:build_cluster(items, self)

 -- local context = {
 --   build = {},
 --   engine=self,
 -- }
 -- local res = self.style:render_citation(items, context)

 self.registry.previous_citation = {
   citationID = "pseudo-citation",
   citationItems = items,
   properties = {
     noteIndex = 0,
   },
 }
 return res
end

---@param bibsection any
---@return [{[string]: string | number | boolean}, string[]]
function CiteProc:makeBibliography(bibsection)
 -- The bibsection works as a filter described in
 -- <https://citeproc-js.readthedocs.io/en/latest/running.html#selective-output-with-makebibliography>.
 if not self.style.bibliography then
   return {{}, {}}
 end

 local res = {}

 self.registry.widest_label = ""
 self.registry.maxoffset = 0

 local ids = self:_get_sorted_refs()
 local excluded_ids
 if bibsection then
   ids, excluded_ids = self:_filter_with_bibsection(ids, bibsection)
 end
 for _, id in ipairs(ids) do
   local str = self.style.bibliography:build_bibliography_str(id, self)
   table.insert(res, str)
 end

 local bib_start = self.output_format.markups["bibstart"]
 local bib_end = self.output_format.markups["bibend"]
 if type(bib_start) == "function" then
   bib_start = bib_start(self)
 end
 if type(bib_end) == "function" then
   bib_end = bib_end(self)
 end

 local params = {
   hangingindent = self.style.bibliography.hanging_indent,
   ["second-field-align"] = self.style.bibliography.second_field_align or self.registry.second_field_align or false,
   linespacing = self.style.bibliography.line_spacing,
   entryspacing = self.style.bibliography.entry_spacing,
   maxoffset = self.registry.maxoffset,
   widest_label = self.registry.widest_label,
   bibstart = bib_start,
   bibend = bib_end,
   entry_ids = ids,
   excluded_ids = excluded_ids,
 }

 return {params, res}
end

function CiteProc:_check_valid_citation_element()
 if not self.style.citation then
   if self.style.info and self.style.info.independent_parent then
     util.error(string.format("This is a dependent style linked to '%s'.", self.style.info.independent_parent))
   else
     util.error("No <citation> in style.")
   end
 end
end

---@param citation CitationData
---@return CitationData
function CiteProc:_normalize_citation_input(citation)
 citation = util.deep_copy(citation)

 if not citation.citationID then
   citation.citationID = "CITATION-" .. tostring(#self.registry.citation_list)
 end

 if not citation.citationItems then
   citation.citationItems = {}
 end
 for i, cite_item in ipairs(citation.citationItems) do
   citation.citationItems[i] = self:_normalize_cite_item(cite_item)
 end

 -- Fix missing noteIndex: sort_CitationNumberPrimaryAscendingViaMacroCitation.txt
 if not citation.properties then
   citation.properties = {}
 end
 if not citation.properties.noteIndex then
   citation.properties.noteIndex = 0
 end
 if not citation.properties.chapterIndex then
   citation.properties.chapterIndex = 0
 end

 citation.sorted_items = util.clone(citation.citationItems)

 return citation
end

---@param cite_item CitationItem
---@return CitationItem
function CiteProc:_normalize_cite_item(cite_item)
 -- Shallow copy
 cite_item = util.clone(cite_item)
 cite_item.id = tostring(cite_item.id)

 -- Use "page" as locator label if missing
 -- label_PluralWithAmpersand.txt
 if cite_item.locator and not cite_item.label then
   cite_item.label = "page"
 end

 local the_context = Context:new()
 the_context.engine = self
 the_context.style = self.style
 the_context.area = self
 the_context.in_bibliography = false
 the_context.lang = self.lang
 the_context.locale = self:get_locale(self.lang)
 the_context.format = self.output_format

 if cite_item.prefix then
   -- Assert CSL rich-text or HTML-like tagged string
   if cite_item.prefix == "" then
     cite_item.prefix = nil
   end
 end
 if cite_item.suffix then
   if cite_item.suffix == "" then
     cite_item.suffix = nil
   end
 end

 return cite_item
end

---@param citation CitationData
---@param citations_pre PreCitation[]
---@param citations_post PostCitation[]
function CiteProc:_check_input(citation, citations_pre, citations_post)
 local citation_info_list = {}
 do
   for i, pre_citation in ipairs(citations_pre) do
     local citation_id = pre_citation[1]
     local note_index = pre_citation[2]
     local chapter_number = pre_citation[3] or self.registry.citations_by_id[citation_id].properties.chapterIndex or 0
     local name = string.format("citationsPre[%d]", i)
     table.insert(citation_info_list, {citation_id, note_index, chapter_number, name})
   end
   table.insert(citation_info_list,
     {citation.citationID, citation.properties.noteIndex, citation.properties.chapterIndex or 0, "citation"})
   for i, post_citation in ipairs(citations_post) do
     local citation_id = post_citation[1]
     local note_index = post_citation[2]
     local chapter_number = post_citation[3] or self.registry.citations_by_id[citation_id].properties.chapterIndex or
         0
     local name = string.format("citationsPost[%d]", i)
     table.insert(citation_info_list, {citation_id, note_index, chapter_number, name})
   end
 end

 ---@type table<CitationId, boolean>
 local citation_dict = {}
 local last_note_number = 0
 local last_chapter_number = 0

 for _, citation_info in ipairs(citation_info_list) do
   local citation_id, note_index, chapter_number, name = table.unpack(citation_info)
   if citation_dict[citation_id] then
     error(string.format("Previously referenced citationID '%s' encountered at %s", name))
   end
   citation_dict[citation_id] = true
   if chapter_number and chapter_number > 0 then
     if chapter_number < last_chapter_number then
       util.warning(string.format("Chapter index sequence is not sane at %s", name))
     end
     if chapter_number ~= last_chapter_number then
       last_note_number = 0
     end
     last_chapter_number = chapter_number
   end
   if note_index > 0 then
     if note_index < last_note_number then
       util.warning(string.format("Note index sequence is not sane at %s", name))
     end
     last_note_number = note_index
   end
 end

end

---@param citation CitationData
---@param citations_pre PreCitation[]
---@param citations_post PostCitation[]
---@return CitationData[]
---@return CiteId[]
function CiteProc:_build_reconstituted_citation_list(citation, citations_pre, citations_post)
 self.registry.citations_by_id[citation.citationID] = citation

 ---@type [CitationId, NoteIndex][]
 local citation_note_pairs = {}
 util.extend(citation_note_pairs, citations_pre)
 table.insert(citation_note_pairs, {citation.citationID, citation.properties.noteIndex})
 util.extend(citation_note_pairs, citations_post)

 ---@type CiteId[]
 local item_ids = {}
 ---@type table<ItemId, boolean>
 local item_id_dict = {}
 ---@type CitationData[]
 local citation_list = {}
 ---@type table<CitationId, CitationData>
 local citations_by_id = {}
 -- TODO: Remove citations_by_item_id
 ---@type table<ItemId, CitationData[]>
 local citations_by_item_id = {}

 for citation_index, pair in ipairs(citation_note_pairs) do
   local citation_id, note_index = table.unpack(pair)
   local citation_ = self.registry.citations_by_id[citation_id]
   if not citation_ then
     util.error("Citation not in registry.")
   end
   citation_.citation_index = citation_index
   citation_.properties.noteIndex = note_index

   table.insert(citation_list, citation_)
   citations_by_id[citation_.citationID] = citation_
   for _, cite_item in ipairs(citation_.citationItems) do
     if not item_id_dict[cite_item.id] then
       item_id_dict[cite_item.id] = true
       table.insert(item_ids, cite_item.id)
       citations_by_item_id[cite_item.id] = {}
     end
     table.insert(citations_by_item_id[cite_item.id], citation_)
   end
 end
 self.registry.citation_list = citation_list
 self.registry.citations_by_id = citations_by_id
 self.registry.citations_by_item_id = citations_by_item_id
 return citation_list, item_ids
end

---@param citation_list CitationData[]
---@return table<CitationId, boolean>
function CiteProc:_set_positions(citation_list)
 ---@type table<CitationId, boolean>
 local tainted_citation_ids = {}

 ---@type {[integer]: CitationData[]}
 local chapter_citations = {}
 for _, citation in ipairs(citation_list) do
   local chapter_number = citation.properties.chapterIndex
   if not chapter_citations[chapter_number] then
     chapter_citations[chapter_number] = {}
   end
   table.insert(chapter_citations[chapter_number], citation)
 end

 for _, citations in pairs(chapter_citations) do
   self:_update_chapter_positions(citations, tainted_citation_ids)
 end

 -- Update tainted citation ids because of citation-number's change
 -- The self.tainted_item_ids were added in the sort_bibliography() procedure.
 for item_id, _ in pairs(self.tainted_item_ids) do
   if self.registry.citations_by_item_id[item_id] then
     for _, citation in ipairs(self.registry.citations_by_item_id[item_id]) do
       tainted_citation_ids[citation.citationID] = true
     end
   end
 end

 return tainted_citation_ids
end

---@param citation_list CitationData[]
---@param tainted_citation_ids table<CitationId, boolean>
---@return table<string, boolean>
function CiteProc:_update_chapter_positions(citation_list, tainted_citation_ids)
 ---@type CitationData[]
 local in_text_citations = {}
 ---@type CitationData[]
 local note_citations = {}
 for _, citation in ipairs(citation_list) do
   if citation.properties.noteIndex == 0 then
     table.insert(in_text_citations, citation)
   else
     table.insert(note_citations, citation)
   end
 end

 for _, citations in ipairs({in_text_citations, note_citations}) do
   ---@type table<CiteId, NoteIndex>
   local first_ref = {}
   ---@type table<CiteId, NoteIndex>
   local last_ref = {}
   ---@type table<NoteIndex, CitationId[]>
   local num_citations_in_note = {}

   for _, citation in ipairs(citations) do
     local note_index = citation.properties.noteIndex
     if not num_citations_in_note[note_index] then
       num_citations_in_note[note_index] = {}
     end
     table.insert(num_citations_in_note[note_index], citation.citationID)
   end

   local previous_citation
   for _, citation in ipairs(citations) do
     local mode = citation.properties.mode
     local note_index = citation.properties.noteIndex
     local previous_cite
     for _, cite_item in ipairs(citation.sorted_items) do
       local position_properties = {
         position_level = cite_item.position_level,
         ["first-reference-note-number"] = cite_item["first-reference-note-number"],
         near_note = cite_item.near_note,
       }

       self:_set_cite_item_position(cite_item, note_index, previous_cite, previous_citation, citation, first_ref,
         last_ref, num_citations_in_note)

       if self:_check_tainted_position_change(cite_item, position_properties) then
         tainted_citation_ids[citation.citationID] = true
       end

       -- https://citeproc-js.readthedocs.io/en/latest/csl-json/markup.html#citations
       -- Citations within the main text of the document have a noteIndex of zero.
       if mode ~= "author-only" and mode ~= "full-cite" then
         if not first_ref[cite_item.id] and note_index > 0 then
           -- note_index == 0 implied an in-text citation
           first_ref[cite_item.id] = note_index
         end
         last_ref[cite_item.id] = note_index
         previous_cite = cite_item
       end
     end

     if mode ~= "author-only" and mode ~= "full-cite" then
       previous_citation = citation
     end
   end

   if self.style.class == "note" and self.style.has_disambiguate then
     ---@type table<CiteId, CitationData[]>
     local citations_by_item_id = {}
     for _, citation in ipairs(citations) do
       if citation.properties.mode ~= "author-only" and citation.properties.mode ~= "full-cite" then
         for _, cite_item in ipairs(citation.sorted_items) do
           if not citations_by_item_id[cite_item.id] then
             citations_by_item_id[cite_item.id] = {}
           end
           table.insert(citations_by_item_id[cite_item.id], citation)
         end
       end
     end
     for _, citation in ipairs(citations) do
       if citation.properties.mode ~= "author-only" and citation.properties.mode ~= "full-cite" then
         for _, cite_item in ipairs(citation.sorted_items) do
           assert(citations_by_item_id[cite_item.id])
           local num_citations = #citations_by_item_id[cite_item.id]
           if not cite_item.num_citations or (num_citations < 2) ~= (cite_item.num_citations < 2) then
             -- self.tainted_item_ids[cite_item.id] = true
             for _, citation_ in ipairs(citations_by_item_id[cite_item.id]) do
               tainted_citation_ids[citation_.citationID] = true
             end
           end
           cite_item.num_citations = num_citations
         end
       end
     end
   end
 end

 return tainted_citation_ids
end

function CiteProc:_set_cite_item_position(cite_item, note_index, previous_cite, previous_citation, citation, first_ref,
   last_ref, num_citations_in_note)
 -- https://citeproc-js.readthedocs.io/en/latest/csl-json/markup.html#citations
 -- Citations within the main text of the document have a noteIndex of zero.
 if citation.properties.mode == "author-only" or citation.properties.mode == "full-cite" then
   -- discretionary_IbidInAuthorDateStyleWithoutIntext.txt
   cite_item.position_level = Position.First
   cite_item.near_note = false
   return
 end

 local first_reference_note_number = first_ref[cite_item.id]
 if first_reference_note_number then
   cite_item.position_level = Position.Subsequent
   cite_item["first-reference-note-number"] = first_reference_note_number
 else
   cite_item.position_level = Position.First
 end

 local preceding_cite_item = self:_find_preceding_ibid_item(cite_item, previous_cite, previous_citation, note_index,
   num_citations_in_note)

 if preceding_cite_item then
   cite_item.position_level = self:_get_ibid_position(cite_item, preceding_cite_item)
 end

 cite_item.near_note = false
 local last_note_number = last_ref[cite_item.id]
 if last_note_number then
   local note_distance = note_index - last_note_number
   cite_item.near_note = (note_distance <= self.style.citation.near_note_distance)
 end

end

-- Find the preceding cite referencing the same item
function CiteProc:_find_preceding_ibid_item(cite_item, previous_cite, previous_citation, note_index,
   num_citations_in_note)
 if previous_cite then
   -- a. the current cite immediately follows on another cite, within the same
   --    citation, that references the same item
   if cite_item.id == previous_cite.id then
     return previous_cite
   end
 elseif previous_citation then
   -- (hidden) The previous citation is the only one in the previous note.
   --    See also
   --    https://github.com/citation-style-language/documentation/issues/121
   --    position_IbidWithMultipleSoloCitesInBackref.txt
   -- b. the current cite is the first cite in the citation, and the previous
   --    citation consists of a single cite referencing the same item
   local previous_note_number = previous_citation.properties.noteIndex
   local num_previous_note_citations = #num_citations_in_note[previous_note_number]
   if (previous_note_number == note_index - 1 and num_previous_note_citations == 1)
       or previous_note_number == note_index then
     if #previous_citation.sorted_items == 1 then
       previous_cite = previous_citation.sorted_items[1]
       if previous_cite.id == cite_item.id then
         return previous_cite
       end
     end
   end
 end
 return nil
end

function CiteProc:_get_ibid_position(item, preceding_cite)
 if preceding_cite.locator then
   if item.locator then
     if item.locator == preceding_cite.locator and item.label == preceding_cite.label then
       return Position.Ibid
     else
       return Position.IbidWithLocator
     end
   else
     return Position.Subsequent
   end
 else
   if item.locator then
     return Position.IbidWithLocator
   else
     return Position.Ibid
   end
 end
end

function CiteProc:_check_tainted_position_change(cite_item, position_properties)
 for key, value in pairs(position_properties) do
   if cite_item[key] ~= value then
     return true
   end
 end
 return false
end

---@param tainted_citation_ids table<CitationId, boolean>
---@return [integer, string, CitationId][]
function CiteProc:_rerun_changed_cites(tainted_citation_ids)
 local result = {}
 for citation_id, _ in pairs(tainted_citation_ids) do
   local citation = self.registry.citations_by_id[citation_id]
   local citation_index = citation.citation_index
   local mode = citation.properties.mode
   if mode == "suppress-author" and self.style.class == "note" then
     mode = nil
   end
   local citation_element = self.style.citation
   if mode == "author-only" and self.style.intext then
     citation_element = self.style.intext
   elseif mode == "full-cite" then
     if self.style.class == "note" then
       citation_element = self.style.citation
     else
       citation_element = self.style.full_citation
     end
   end

   local citation_str = citation_element:build_citation_str(citation, self)
   table.insert(result, {citation_index, citation_str, citation_id})
 end
 return result
end

function CiteProc:_get_sorted_refs()
 if self.registry.requires_sorting then
   self:sort_bibliography()
 end
 return self.registry.reflist
end

---@param ids CiteId[]
---@param bibsection any
---@return CiteId[]
---@return CiteId[]
function CiteProc:_filter_with_bibsection(ids, bibsection)
 if bibsection.quash then
   return self:filter_quash(ids, bibsection)
 elseif bibsection.select then
   return self:filter_select(ids, bibsection)
 elseif bibsection.include then
   return self:filter_include(ids, bibsection)
 elseif bibsection.exclude then
   return self:filter_exclude(ids, bibsection)
 else
   return ids, {}
 end
end

function CiteProc:match_bibsection_object(item, bibsection_object)
 local field = bibsection_object.field
 local value = bibsection_object.value
 local match = false
 if value == "" then
   if not item[field] or item[field] == "" then
     match = true
   end
 else
   if type(item[field]) == "table" then
     if util.in_list(value, item[field]) then
       match = true
     end
   elseif field == "keyword" then
     if item.keyword and util.in_list(value, util.split(item.keyword, "%s*[;,]%s*")) then
       match = true
     end
   elseif item[field] == value then
     match = true
   end
 end
 if bibsection_object.negative then
   match = not match
 end
 return match
end

function CiteProc:filter_select(ids, bibsection)
 -- Include the item if, and only if, all of the objects match.
 local res = {}
 local excluded_ids = {}
 for _, id in ipairs(ids) do
   local item = self.registry.registry[id]
   local match = true
   for _, bibsection_object in ipairs(bibsection.select) do
     if not self:match_bibsection_object(item, bibsection_object) then
       match = false
       break
     end
   end
   if match then
     table.insert(res, id)
   else
     table.insert(excluded_ids, id)
   end
 end
 return res, excluded_ids
end

function CiteProc:filter_include(ids, bibsection)
 -- Include the item if any of the objects match.
 local res = {}
 local excluded_ids = {}
 for _, id in ipairs(ids) do
   local item = self.registry.registry[id]
   local match = false
   for _, bibsection_object in ipairs(bibsection.include) do
     if self:match_bibsection_object(item, bibsection_object) then
       match = true
       break
     end
   end
   if match then
     table.insert(res, id)
   else
     table.insert(excluded_ids, id)
   end
 end
 return res, excluded_ids
end

function CiteProc:filter_exclude(ids, bibsection)
 -- Include the item if none of the objects match.
 local res = {}
 local excluded_ids = {}
 for _, id in ipairs(ids) do
   local item = self.registry.registry[id]
   local match = false
   for _, bibsection_object in ipairs(bibsection.exclude) do
     if self:match_bibsection_object(item, bibsection_object) then
       match = true
       break
     end
   end
   if not match then
     table.insert(res, id)
   else
     table.insert(excluded_ids, id)
   end
 end
 return res, excluded_ids
end

function CiteProc:filter_quash(ids, bibsection)
 -- Skip the item if all of the objects match.
 local res = {}
 local excluded_ids = {}
 for _, id in ipairs(ids) do
   local item = self.registry.registry[id]
   local match = true
   for _, bibsection_object in ipairs(bibsection.quash) do
     if not self:match_bibsection_object(item, bibsection_object) then
       match = false
       break
     end
   end
   if not match then
     table.insert(res, id)
   else
     table.insert(excluded_ids, id)
   end
 end
 return res, excluded_ids
end

function CiteProc:set_output_format(format)
 if format == "latex" then
   self.output_format = LatexWriter:new()
 elseif format == "html" then
   self.output_format = HtmlWriter:new()
 end
end

function CiteProc:enable_linking()
 self.opt.wrap_url_and_doi = true
 self.opt.citation_link = true
end

function CiteProc:disable_linking()
 self.opt.wrap_url_and_doi = false
 self.opt.citation_link = false
end

function CiteProc.create_element_tree(node)
 local element_name = node:get_element_name()
 local element_class = nodes[element_name]
 local el = nil
 if element_class then
   el = element_class:from_node(node)
 end
 if el then
   for _, child in ipairs(node:get_children()) do
     if child:is_element() then
       local child_element = CiteProc.create_element_tree(child)
       if child_element then
         if not el.children then
           el.children = {}
         end
         table.insert(el.children, child_element)
       end
     end
   end
 end
 return el
end

---@param id ItemId
---@return ItemData?
function CiteProc:get_item(id)
 ---@type ItemData?
 local item = self.registry.registry[id]
 if not item then
   item = self:_retrieve_item(id)
   if not item then
     return nil
   end
   item = self:process_extra_note(item)
   table.insert(self.registry.reflist, id)
   item["citation-number"] = #self.registry.reflist
   self.registry.registry[id] = item
   self.registry.requires_sorting = true
 end
 -- local res = {}
 -- setmetatable(res, {__index = item})
 -- return res
 return item
end

---@param id ItemId
---@return ItemData?
function CiteProc:_retrieve_item(id)
 -- Retrieve, copy, and normalize
 local res = {}
 local item = self.sys.retrieveItem(id)
 if not item then
   return nil
 end

 -- TODO: normalize data input
 item.id = tostring(item.id)

 for key, value in pairs(item) do
   res[key] = value
 end

 -- if res["page"] and not res["page-first"] then
 --   local page_first = util.split(res["page"], "%s*[&,-]%s*")[1]
 --   page_first = util.split(page_first, util.unicode["en dash"])[1]
 --   res["page-first"] = page_first
 -- end

 return res
end

-- TODO: Nomalize all inputs
function CiteProc:process_extra_note(item)
 if item.note then
   local note_fields = {}
   local note_lines = {}
   for _, line in ipairs(util.split(item.note, "%s*\r?\n%s*")) do
     local field, value = string.match(line, "^([%w-_ ]+):%s*(.*)$")
     if field then
       local variable_type = util.variable_types[field]
       if not item[field] or field == "type" or variable_type == "date" then
         if variable_type == "number" then
           item[field] = value
         elseif variable_type == "date" then
           item[field] = util.parse_edtf(value)
         elseif variable_type == "name" then
           if not note_fields[field] then
             note_fields[field] = {}
           end
           table.insert(note_fields[field], util.parse_extra_name(value))
         else
           item[field] = value
         end
       end
     else
       table.insert(note_lines, line)
     end
   end
   for field, value in pairs(note_fields) do
     item[field] = value
   end
   item.note = table.concat(note_lines, "\n")
 end
 return item
end

function CiteProc:sort_bibliography()
 -- Sort the items in registry according to the `sort` in `bibliography.`
 -- This will update the `citation-number` of each item.
 local bibliography_sort = nil
 if self.style.bibliography and self.style.bibliography.sort then
   bibliography_sort = self.style.bibliography.sort
 end
 if not bibliography_sort then
   return
 end
 local items = {}
 for _, id in ipairs(self.registry.reflist) do
   table.insert(items, self.registry.registry[id])
 end

 local state = IrState:new()
 local context = Context:new()
 context.engine = self
 context.style = self.style
 context.area = self.style.bibliography
 context.in_bibliography = true
 context.lang = self.lang
 context.locale = self:get_locale(self.lang)
 context.name_inheritance = self.style.bibliography.name_inheritance
 context.format = SortStringFormat:new()
 -- context.id = id
 context.cite = nil
 -- context.reference = self:get_item(id)

 bibliography_sort:sort(items, state, context)
 self.registry.reflist = {}
 self.tainted_item_ids = {}
 for i, item in ipairs(items) do
   if item["citation-number"] ~= i then
     self.tainted_item_ids[item.id] = true
   end
   item["citation-number"] = i
   self.registry.reflist[i] = item.id
 end
 self.registry.requires_sorting = false
end

---@param lang string
---@return Locale
function CiteProc:get_locale(lang)
 lang = util.primary_dialects[lang] or lang
 local locale = self.locales[lang] or self:get_merged_locales(lang)
 return locale
end

function CiteProc:get_merged_locales(lang)
 local fall_back_locales = {}

 local language = string.sub(lang, 1, 2)
 local primary_dialect = util.primary_dialects[language]

 -- 1. In-style cs:locale elements
 --    i. `xml:lang` set to chosen dialect, “de-AT”
 table.insert(fall_back_locales, self.style.locales[lang])

 --    ii. `xml:lang` set to matching language, “de” (German)
 if language and language ~= lang then
   table.insert(fall_back_locales, self.style.locales[language])
 end

 --    iii. `xml:lang` not set
 table.insert(fall_back_locales, self.style.locales["@generic"])

 -- 2. Locale files
 --    iv. `xml:lang` set to chosen dialect, “de-AT”
 if lang then
   table.insert(fall_back_locales, self:get_system_locale(lang))
 end

 --    v. `xml:lang` set to matching primary dialect, “de-DE” (Standard German)
 --       (only applicable when the chosen locale is a secondary dialect)
 if primary_dialect and primary_dialect ~= lang then
   table.insert(fall_back_locales, self:get_system_locale(primary_dialect))
 end

 --    vi. `xml:lang` set to “en-US” (American English)
 if lang ~= "en-US" and primary_dialect ~= "en-US" then
   table.insert(fall_back_locales, self:get_system_locale("en-US"))
 end

 -- Merge locales

 local locale = Locale:new()
 for i = #fall_back_locales, 1, -1 do
   local fall_back_locale = fall_back_locales[i]
   locale:merge(fall_back_locale)
 end

 self.locales[lang] = locale
 return locale
end

function CiteProc:get_system_locale(lang)
 local locale = self.system_locales[lang]
 if locale then
   return locale
 end

 local locale_str = self.sys.retrieveLocale(lang)
 if not locale_str then
   util.warning(string.format("Failed to retrieve locale '%s'", lang))
   return nil
 end
 local locale_xml = dom.parse(locale_str)
 local root_element = locale_xml:get_path("locale")[1]
 locale = Locale:from_node(root_element)
 self.system_locales[lang] = locale
 return locale
end


function CiteProc:get_style_class()
 if self.style and self.style.class then
   return self.style.class
 else
   return nil
 end
end


---@class Macro: Element
local Macro = Element:derive("macro")

function Macro:from_node(node)
 local o = Macro:new()
 o.children = {}
 o:set_attribute(node, "name")
 o:process_children_nodes(node)
 return o
end

---@param engine CiteProc
---@param state IrState
---@param context Context
---@return IrNode?
function Macro:build_ir(engine, state, context)
 local ir = self:build_group_ir(engine, state, context)
 return ir
end


engine.CiteProc = CiteProc

return engine

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.