import toposort from 'toposort'
import [AnyCv] from"../support/gr.mjs"

export : define [CreateEmptyTable] {.languages {.} .features {.} .lookups {.} .lookupDep {}}
extern Map
extern Set

export : define [PickLanguage sink tag] : begin
	if sink.languages.(tag) : return sink.languages.(tag)
	define lang {.features {}}
	set sink.languages.(tag) lang
	return lang

export : define [CopyLanguage sink tag tagFrom] : begin
	define langFrom : PickLanguage sink tagFrom
	define langTo : PickLanguage sink tag
	foreach [feat : items-of langFrom.features] : langTo.features.push feat
	return langTo

export : define [AddLangFeature lang fea] : begin
	define index : lang.features.indexOf fea.name
	if (index < 0) : lang.features.push fea.name

export : define [AddFeature sink tag] : begin
	define lookupArray {}
	local n 0
	while true : begin
		if [not sink.features.(tag + '_' + n)] : begin
			set sink.features.(tag + '_' + n) lookupArray
			return {.name (tag + '_' + n) .lookups lookupArray}
		set n : n + 1

export : define [PickFeature sink name] : begin
	if sink.features.(name) : return { .name name .lookups sink.features.(name) }
	define featObj { .name name .lookups {} }
	set sink.features.(name) featObj.lookups
	return featObj

export : define [PickCommonFeature sink name] : begin
	if sink.features.(name) : return { .name name .lookups sink.features.(name) }
	define featObj { .name name .lookups {} }
	set sink.features.(name) featObj.lookups
	AddCommonFeature sink featObj
	return featObj

export : define [AddFeatureLookup fea lookupName] : begin
	define index : fea.lookups.indexOf lookupName
	if (index < 0) : fea.lookups.push lookupName

export : define [AddLookup sink data _prefix] : begin
	local prefix : _prefix || '_lut_'
	local n 0
	while true : begin
		if [not sink.lookups.(prefix + n)] : begin
			set sink.lookups.(prefix + n) data
			return (prefix + n)
		set n : n + 1

export : define [PickLookup sink name fallback] : begin
	if sink.lookups.(name) : return sink.lookups.(name)
	set sink.lookups.(name) fallback
	return sink.lookups.(name)

export : define [AddCommonFeature sink fea] : begin
	define dfltDflt : PickLanguage sink 'DFLT_DFLT'
	define latnDflt : PickLanguage sink 'latn_DFLT'
	define grekDflt : PickLanguage sink 'grek_DFLT'
	define cyrlDflt : PickLanguage sink 'cyrl_DFLT'

	AddLangFeature dfltDflt fea
	AddLangFeature latnDflt fea
	AddLangFeature grekDflt fea
	AddLangFeature cyrlDflt fea

	return fea

define UtilityLookupPrefix '.utility-single.'

export : define [BeginLookupBlock sink] : begin
	return : object
		existingLookupNames : new Set : Object.keys sink.lookups

define [IsUtilityLookupId name] : [name.slice 0 UtilityLookupPrefix.length] === UtilityLookupPrefix

export : define [EndLookupBlock rec sink] : begin
	local currentLookupNames : new Set : Object.keys sink.lookups
	foreach existing rec.existingLookupNames : foreach current currentLookupNames
		if (![IsUtilityLookupId existing] && ![IsUtilityLookupId current] && ![rec.existingLookupNames.has current])
			sink.lookupDep.push { existing current }

set EndLookupBlock.Front : lambda [rec sink] : begin
	local currentLookupNames : new Set : Object.keys sink.lookups
	foreach existing rec.existingLookupNames : foreach current currentLookupNames
		if (![IsUtilityLookupId existing] && ![IsUtilityLookupId current] && ![rec.existingLookupNames.has current])
			sink.lookupDep.push { current existing }

export : define [MoveBackUtilityLookups sink] : begin
	local lns : new Set : Object.keys sink.lookups
	foreach [front lns] : foreach [rear lns]
		if (![IsUtilityLookupId front] && [IsUtilityLookupId rear])
			sink.lookupDep.push { front rear }

export : define [ChainRuleBuilder sink] : begin
	define [createNewLookup f t] : begin
		local subst {.}
		foreach [j : range 0 f.length] : set subst.(f.(j)) t.(j)
		return : AddLookup sink {.type 'gsub_single' .substitutions subst} UtilityLookupPrefix

	define [getSubLookup left right] : piecewise
		[not right] null
		([typeof right] === "string") right
		(right <@ Function) : getSubLookup left [right left]
		true : begin
			local found    null
			local maxMatch 0
			local lookupKeys : [Object.keys sink.lookups].reverse
			foreach [name : items-of lookupKeys] : begin
				local st sink.lookups.(name).substitutions
				if [IsUtilityLookupId name] : begin
					local compatible true
					local matchCount 0
					foreach [j : range 0 left.length] : begin
						if (st.(left.(j)) && st.(left.(j)) !== right.(j)) : set compatible false
						if (st.(left.(j)) === right.(j)) : inc matchCount
					if (compatible && (!found || matchCount > maxMatch)) : begin
						set found    name
						set maxMatch matchCount

			if found : begin
				local st sink.lookups.(found).substitutions
				foreach [j : range 0 left.length] : set st.(left.(j)) right.(j)
				return found

			return : createNewLookup left right

	define [chain-rule] : begin
		local terms : [{}.slice.call arguments 0].map (x -> [if x.left x {.left x .right null}])
		local rule {.match {} .apply {} .inputBegins 0 .inputEnds 0}
		local foundi false
		local founde false
		foreach [j : range 0 terms.length] : if (!foundi && terms.(j).right) : begin
			set rule.inputBegins j
			set foundi true
		foreach [j : range (terms.length - 1) downtill 0] : if (!founde && terms.(j).right) : begin
			set rule.inputEnds (j + 1)
			set founde true
		foreach [j : range 0 terms.length] : begin
			local term terms.(j)
			rule.match.push : Array.from : new Set term.left
			local lutn : getSubLookup term.left term.right
			if lutn : rule.apply.push {.at j .lookup lutn}
		return rule

	define [reverse-rule] : begin
		local terms : [{}.slice.call arguments 0].map (x -> [if x.left x {.left x .right null}])
		local rule {.match {} .to {} .inputIndex 0}
		local foundi false

		foreach [j : range 0 terms.length] : begin
			local term terms.(j)
			local subst : new Map
			foreach [g : items-of term.left] : subst.set g g

			if term.right : begin
				if foundi : throw : new Error "Duplicate substitutions in one reverse rule"
				set foundi true
				set rule.inputIndex j
				local toGlyphs : piecewise
					(term.right <@ Function) [term.right term.left]
					true                     term.right
				foreach [k : range 0 term.left.length]
					subst.set term.left.(k) (toGlyphs.(k) || term.left.(k))

				set rule.to : Array.from [subst.values]

			set rule.match.(j) : Array.from [subst.keys]

		return rule

	return {chain-rule reverse-rule}

export : define [QueryRelatedGlyphs glyphs para entries] : begin
	define sink {}
	foreach [gid : items-of entries] : if glyphs.(gid) : begin
		sink.push gid
		if para.enableCvSs : foreach [gr : items-of : AnyCv.query glyphs.(gid)] : begin
			sink.push : gr.get glyphs.(gid)
	return sink

export : define [FinalizeTable table] : begin
	set table.lookupOrder : toposort table.lookupDep
	foreach [{key lang} : pairs-of table.languages] : begin
		if lang.features : lang.features.sort

export : define [UkMapToLookup m] : begin
	local l {}
	local r {}
	foreach { k v } [Object.entries m] : begin
		l.push k
		r.push v
	return { .left l .right r }

export : define [UkMap2ToLookup mm] : begin
	local res {}
	foreach { g1 second } [Object.entries mm] : foreach { g2 gTo } [Object.entries second] : begin
		res.push {.from {g1 g2} .to gTo}
	return res