import { Logger } from 'besonders-logger'
import stringify from 'safe-stable-stringify'
import { Applog, CidString } from '../applog/datom-types.ts'
import { createDebugName } from '../utils/debug-name.ts'
import { Thread } from '../thread/basic.ts'
import { ThreadInMemory } from '../thread/writeable.ts'
import { memoizedFn } from './memoized.ts'

const { WARN, LOG, DEBUG, VERBOSE, ERROR } = Logger.setup(Logger.INFO) // eslint-disable-line no-unused-vars

export interface DivergenceLeaf {
	log: Applog
	thread: Thread
}

export const queryDivergencesByPrev = memoizedFn('queryDivergencesByPrev', function queryConflictingByPrev(
	sourceThread: Thread,
) {
	DEBUG(`queryDivergencesByPrev<${sourceThread.nameAndSizeUntracked}>`)
	if (sourceThread.filters.includes('lastWriteWins')) WARN(`queryDivergencesByPrev on thread lastWriteWins`, sourceThread)

	const logsForNode = new Map<CidString, Applog[]>()
	const leafs = new Set<CidString>()
	VERBOSE('all applogs:', sourceThread.applogs)
	for (const log of sourceThread.applogs) {
		let prevLogs
		if (log.pv) {
			prevLogs = log.pv && logsForNode.get(log.pv.toString())
			leafs.delete(log.pv.toString())
		}
		VERBOSE('traversing log', { log, prevLogs, leafs: Array.from(leafs) })
		logsForNode.set(log.cid, prevLogs ? [...prevLogs, log] : [log])
		leafs.add(log.cid)
	}
	const divergences = Array.from(leafs).map(leafID => {
		const thread = new ThreadInMemory(
			createDebugName({
				caller: 'DivergenceLeaf',
				thread: sourceThread,
				pattern: `leaf: ${leafID}`,
			}),
			logsForNode.get(leafID),
			sourceThread.filters,
			true,
		)
		return ({ log: thread.latestLog, thread })
	})
	// TODO: migrate to SubscribableArray for reactive updates
	return divergences
})