let g_about_cache = {};

async function query(sql, args) {
	let result = [];
	await ssb.sqlAsync(sql, args, function (row) {
		result.push(row);
	});
	return result;
}

async function contacts_internal(id, last_row_id, following, max_row_id) {
	let result = Object.assign({}, following[id] || {});
	result.following = result.following || {};
	result.blocking = result.blocking || {};
	let contacts = await query(
		`
				SELECT content FROM messages
				WHERE author = ? AND
				rowid > ? AND
				rowid <= ? AND
				json_extract(content, '$.type') = 'contact'
				ORDER BY sequence
			`,
		[id, last_row_id, max_row_id]
	);
	for (let row of contacts) {
		let contact = JSON.parse(row.content);
		if (contact.following === true) {
			result.following[contact.contact] = true;
		} else if (contact.following === false) {
			delete result.following[contact.contact];
		} else if (contact.blocking === true) {
			result.blocking[contact.contact] = true;
		} else if (contact.blocking === false) {
			delete result.blocking[contact.contact];
		}
	}
	following[id] = result;
	return result;
}

async function contact(id, last_row_id, following, max_row_id) {
	return await contacts_internal(id, last_row_id, following, max_row_id);
}

async function following_deep_internal(
	ids,
	depth,
	blocking,
	last_row_id,
	following,
	max_row_id
) {
	let contacts = await Promise.all(
		[...new Set(ids)].map((x) => contact(x, last_row_id, following, max_row_id))
	);
	let result = {};
	for (let i = 0; i < ids.length; i++) {
		let id = ids[i];
		let contact = contacts[i];
		let all_blocking = Object.assign({}, contact.blocking, blocking);
		let found = Object.keys(contact.following).filter((y) => !all_blocking[y]);
		let deeper =
			depth > 1
				? await following_deep_internal(
						found,
						depth - 1,
						all_blocking,
						last_row_id,
						following,
						max_row_id
					)
				: [];
		result[id] = [id, ...found, ...deeper];
	}
	return [...new Set(Object.values(result).flat())];
}

async function following_deep(ids, depth, blocking) {
	let db = await database('cache');
	const k_cache_version = 5;
	let cache = await db.get('following');
	cache = cache ? JSON.parse(cache) : {};
	if (cache.version !== k_cache_version) {
		cache = {
			version: k_cache_version,
			following: {},
			last_row_id: 0,
		};
	}
	let max_row_id = (
		await query(
			`
			SELECT MAX(rowid) AS max_row_id FROM messages
		`,
			[]
		)
	)[0].max_row_id;
	let result = await following_deep_internal(
		ids,
		depth,
		blocking,
		cache.last_row_id,
		cache.following,
		max_row_id
	);
	cache.last_row_id = max_row_id;
	let store = JSON.stringify(cache);
	await db.set('following', store);
	return result;
}

async function fetch_about(db, ids, users) {
	const k_cache_version = 1;
	let cache = await db.get('about');
	cache = cache ? JSON.parse(cache) : {};
	if (cache.version !== k_cache_version) {
		cache = {
			version: k_cache_version,
			about: {},
			last_row_id: 0,
		};
	}
	let max_row_id = 0;
	await ssb.sqlAsync(
		`
			SELECT MAX(rowid) AS max_row_id FROM messages
		`,
		[],
		function (row) {
			max_row_id = row.max_row_id;
		}
	);
	for (let id of Object.keys(cache.about)) {
		if (ids.indexOf(id) == -1) {
			delete cache.about[id];
		}
	}

	let abouts = [];
	await ssb.sqlAsync(
		`
				SELECT
					messages.*
				FROM
					messages,
					json_each(?1) AS following
				WHERE
					messages.author = following.value AND
					messages.rowid > ?3 AND
					messages.rowid <= ?4 AND
					json_extract(messages.content, '$.type') = 'about'
				UNION
				SELECT
					messages.*
				FROM
					messages,
					json_each(?2) AS following
				WHERE
					messages.author = following.value AND
					messages.rowid <= ?4 AND
					json_extract(messages.content, '$.type') = 'about'
				ORDER BY messages.author, messages.sequence
			`,
		[
			JSON.stringify(ids.filter((id) => cache.about[id])),
			JSON.stringify(ids.filter((id) => !cache.about[id])),
			cache.last_row_id,
			max_row_id,
		]
	);
	for (let about of abouts) {
		let content = JSON.parse(about.content);
		if (content.about === about.author) {
			delete content.type;
			delete content.about;
			cache.about[about.author] = Object.assign(
				cache.about[about.author] || {},
				content
			);
		}
	}
	cache.last_row_id = max_row_id;
	await db.set('about', JSON.stringify(cache));
	users = users || {};
	for (let id of Object.keys(cache.about)) {
		users[id] = Object.assign(users[id] || {}, cache.about[id]);
	}
	return Object.assign({}, users);
}

async function getAbout(db, id) {
	if (g_about_cache[id]) {
		return g_about_cache[id];
	}
	let o = await db.get(id + ':about');
	const k_version = 4;
	let f = o ? JSON.parse(o) : o;
	if (!f || f.version != k_version) {
		f = {about: {}, sequence: 0, version: k_version};
	}
	await ssb.sqlAsync(
		'SELECT ' +
			'  sequence, ' +
			'  content ' +
			'FROM messages ' +
			'WHERE ' +
			'  author = ?1 AND ' +
			'  sequence > ?2 AND ' +
			"  json_extract(content, '$.type') = 'about' AND " +
			"  json_extract(content, '$.about') = ?1 " +
			'UNION SELECT MAX(sequence) as sequence, NULL FROM messages WHERE author = ?1 ' +
			'ORDER BY sequence',
		[id, f.sequence],
		function (row) {
			f.sequence = row.sequence;
			if (row.content) {
				let about = {};
				try {
					about = JSON.parse(row.content);
				} catch {}
				delete about.about;
				delete about.type;
				f.about = Object.assign(f.about, about);
			}
		}
	);
	let j = JSON.stringify(f);
	if (o != j) {
		await db.set(id + ':about', j);
	}
	g_about_cache[id] = f.about;
	return f.about;
}

async function getSize(db, id) {
	let size = 0;
	await ssb.sqlAsync(
		'SELECT (LENGTH(author) * COUNT(*) + SUM(LENGTH(content)) + SUM(LENGTH(id))) AS size FROM messages WHERE author = ?1',
		[id],
		function (row) {
			size += row.size;
		}
	);
	return size;
}

async function getSizes(ids) {
	let sizes = {};
	await ssb.sqlAsync(
		`
			SELECT
				author,
				(SUM(LENGTH(content)) + SUM(LENGTH(author)) + SUM(LENGTH(messages.id))) AS size
			FROM messages
			JOIN json_each(?) AS ids ON author = ids.value
			GROUP BY author
		`,
		[JSON.stringify(ids)],
		function (row) {
			sizes[row.author] = row.size;
		}
	);
	return sizes;
}

function niceSize(bytes) {
	let value = bytes;
	let unit = 'B';
	const k_units = ['kB', 'MB', 'GB', 'TB'];
	for (let u of k_units) {
		if (value >= 1024) {
			value /= 1024;
			unit = u;
		} else {
			break;
		}
	}
	return Math.round(value * 10) / 10 + ' ' + unit;
}

function escape(value) {
	return value
		.replaceAll('&', '&amp;')
		.replaceAll('<', '&lt;')
		.replaceAll('>', '&gt;');
}

async function main() {
	await app.setDocument('<pre style="color: #fff">building...</pre>');
	let db = await database('ssb');
	let whoami = await ssb.getIdentities();
	let tree = '';
	await app.setDocument(
		`<pre style="color: #fff">Enumerating followed users...</pre>`
	);
	let following = await following_deep(whoami, 2, {});
	await app.setDocument(
		`<pre style="color: #fff">Getting names and sizes...</pre>`
	);
	let [about, sizes] = await Promise.all([
		fetch_about(db, following, {}),
		getSizes(following),
	]);
	await app.setDocument(`<pre style="color: #fff">Finishing...</pre>`);
	following.sort((a, b) => (sizes[b] ?? 0) - (sizes[a] ?? 0));
	for (let id of following) {
		tree += `<li><a href="/~core/ssb/#${id}">${escape(about[id]?.name ?? id)}</a> ${niceSize(sizes[id] ?? 0)}</li>\n`;
	}
	await app.setDocument(
		'<!DOCTYPE html>\n<html>\n<body style="color: #fff"><h1>Following</h1>\n<ul>' +
			tree +
			'</ul>\n</body>\n</html>'
	);
}

main();