import config from 'config';
import { differenceInYears } from 'date-fns';
import { unit } from 'mathjs';
import { MerkleJson } from 'merkle-json';
import moment from 'moment';
import omit from 'object.omit';
import convert from 'convert';

import initLogger from './logger.js';
import { knexOwner as knex, knexManticore } from './knex.js';
import { utilsApi } from './manticore.js';
import { HttpError } from './errors.js';
import { fetchCountriesByAlpha2 } from './countries.js';
import { curateEntity } from './entities.js';
import { curateMedia } from './media.js';
import { curateStash } from './stashes.js';
import escape from '../utils/escape-manticore.js';
import slugify from '../utils/slugify.js';
import { curateRevision } from './revisions.js';
import { interpolateProfiles } from '../common/actors.mjs'; // eslint-disable-line import/namespace

const logger = initLogger();
const mj = new MerkleJson();

export function curateActor(actor, context = {}) {
	return {
		id: actor.id,
		slug: actor.slug,
		name: actor.name,
		gender: actor.gender,
		age: actor.age,
		dateOfBirth: actor.date_of_birth,
		ageFromBirth: actor.date_of_birth && differenceInYears(Date.now(), actor.date_of_birth),
		ageThen: context.sceneDate && actor.date_of_birth && differenceInYears(context.sceneDate, actor.date_of_birth),
		dateOfDeath: actor.date_of_death,
		bust: actor.bust,
		cup: actor.cup,
		waist: actor.waist,
		hip: actor.hip,
		naturalBoobs: actor.natural_boobs,
		boobsVolume: actor.boobs_volume,
		boobsImplant: actor.boobs_implant,
		boobsPlacement: actor.boobs_placement,
		boobsSurgeon: actor.boobs_surgeon,
		naturalButt: actor.natural_butt,
		buttVolume: actor.butt_volume,
		buttImplant: actor.butt_implant,
		penisLength: actor.penis_length,
		penisGirth: actor.penis_girth,
		isCircumcised: actor.is_circumcised,
		height: actor.height && {
			metric: actor.height,
			imperial: unit(actor.height, 'cm').splitUnit(['ft', 'in']).map((value) => Math.round(value.toNumber())),
		},
		weight: actor.weight && {
			metric: actor.weight,
			imperial: Math.round(unit(actor.weight, 'kg').toNumeric('lbs')),
		},
		eyes: actor.eyes,
		hairColor: actor.hair_color,
		hasTattoos: actor.has_tattoos,
		tattoos: actor.tattoos,
		hasPiercings: actor.has_piercings,
		piercings: actor.piercings,
		origin: actor.birth_country_alpha2 && {
			country: actor.birth_country_alpha2 && {
				alpha2: actor.birth_country_alpha2,
				name: actor.birth_country_name,
				alias: actor.birth_country_alias,
			},
			city: actor.birth_city,
			state: actor.birth_state,
		},
		residence: actor.residence_country_alpha2 && {
			country: actor.residence_country_alpha2 && {
				alpha2: actor.residence_country_alpha2,
				name: actor.residence_country_name,
				alias: actor.residence_country_alias,
			},
			city: actor.residence_city,
			state: actor.residence_state,
		},
		agency: actor.agency,
		avatar: curateMedia(actor.avatar),
		profiles: context.profiles?.map((profile) => ({
			id: profile.id,
			description: profile.description,
			descriptionHash: profile.description_hash,
			entity: curateEntity({ ...profile.entity, parent: profile.parent_entity }),
			avatar: curateMedia(profile.avatar),
		})),
		createdAt: actor.created_at,
		updatedAt: actor.updated_at,
		scenes: actor.scenes,
		likes: actor.stashed,
		stashes: context.stashes?.map((stash) => curateStash(stash)) || [],
		...context.append?.[actor.id],
	};
}

export function sortActorsByGender(actors, context = {}) {
	if (!actors) {
		return actors;
	}

	const alphaActors = actors.sort((actorA, actorB) => actorA.name.localeCompare(actorB.name, 'en'));
	const genderActors = ['transsexual', 'female', undefined, null, 'male'].flatMap((gender) => alphaActors.filter((actor) => actor.gender === gender));

	const titleSlug = slugify(context.title);
	const titleActors = titleSlug ? genderActors.sort((actorA, actorB) => {
		const actorASlug = actorA.slug.split('-')[0];
		const actorBSlug = actorB.slug.split('-')[0];

		if (titleSlug.includes(actorASlug) && !titleSlug.includes(actorBSlug)) {
			return -1;
		}

		if (titleSlug.includes(actorBSlug) && !titleSlug.includes(actorASlug)) {
			return 1;
		}

		return 0;
	}) : alphaActors;

	return titleActors;
}

export async function fetchActorsById(actorIds, options = {}, reqUser) {
	const [actors, profiles, stashes] = await Promise.all([
		knex('actors')
			.select(
				'actors.*',
				'actors_meta.*',
				'birth_countries.alpha2 as birth_country_alpha2',
				knex.raw('COALESCE(birth_countries.alias, birth_countries.name) as birth_country_name'),
				'residence_countries.alpha2 as residence_country_alpha2',
				knex.raw('COALESCE(residence_countries.alias, residence_countries.name) as residence_country_name'),
			)
			.leftJoin('actors_meta', 'actors_meta.actor_id', 'actors.id')
			.leftJoin('countries as birth_countries', 'birth_countries.alpha2', 'actors.birth_country_alpha2')
			.leftJoin('countries as residence_countries', 'residence_countries.alpha2', 'actors.residence_country_alpha2')
			.whereIn('actors.id', actorIds)
			.modify((builder) => {
				if (options.order) {
					builder.orderBy(...options.order);
				}
			}),
		knex('actors_profiles')
			.select('actors_profiles.*', knex.raw('row_to_json(entities) as entity'), knex.raw('row_to_json(parents) as parent_entity'), knex.raw('row_to_json(media) as avatar'))
			.leftJoin('actors', 'actors.id', 'actors_profiles.actor_id')
			.leftJoin('entities', 'entities.id', 'actors_profiles.entity_id')
			.leftJoin('entities as parents', 'parents.id', 'entities.parent_id')
			.leftJoin('media', 'media.id', 'actors_profiles.avatar_media_id')
			.whereIn('actor_id', actorIds)
			.groupBy('actors_profiles.id', 'entities.id', 'parents.id', 'media.id'),
		reqUser
			? knex('stashes_actors')
				.leftJoin('stashes', 'stashes.id', 'stashes_actors.stash_id')
				.where('stashes.user_id', reqUser.id)
				.whereIn('stashes_actors.actor_id', actorIds)
			: [],
	]);

	if (options.order) {
		return actors.map((actorEntry) => curateActor(actorEntry, {
			stashes: stashes.filter((stash) => stash.actor_id === actorEntry.id),
			append: options.append,
		}));
	}

	const curatedActors = actorIds.map((actorId) => {
		const actor = actors.find((actorEntry) => actorEntry.id === actorId);

		if (!actor) {
			console.warn(`Can't match actor ${actorId}`);
			return null;
		}

		return curateActor(actor, {
			stashes: stashes.filter((stash) => stash.actor_id === actor.id),
			profiles: profiles.filter((profile) => profile.actor_id === actor.id),
			append: options.append,
		});
	}).filter(Boolean);

	return curatedActors;
}

function curateOptions(options = {}) {
	if (options.limit > 120) {
		throw new HttpError('Limit must be <= 120', 400);
	}

	return {
		page: options.page || 1,
		limit: options.limit || 30,
		aggregateCountries: true,
		requireAvatar: options.requireAvatar || false,
		order: [escape(options.order?.[0]) || 'name', escape(options.order?.[1]) || 'asc'],
	};
}

async function queryManticoreSql(filters, options, _reqUser) {
	const aggSize = config.database.manticore.maxAggregateSize;

	const sqlQuery = knexManticore.raw(`
		:query:
		OPTION
			max_matches=:maxMatches:,
			max_query_time=:maxQueryTime:
		:countriesFacet:;
		show meta;
	`, {
		query: knexManticore(filters.stashId ? 'actors_stashed' : 'actors')
			.modify((builder) => {
				if (filters.stashId) {
					builder.select(knex.raw(`
						actors.id as id,
						actors.slug,
						actors.gender as gender,
						actors.country as country,
						actors.height as height,
						actors.mass as mass,
						actors.cup as cup,
						actors.natural_boobs as natural_boobs,
						actors.date_of_birth as date_of_birth,
						actors.has_avatar as has_avatar,
						actors.scenes as scenes,
						actors.stashed as stashed,
						created_at as stashed_at,
						if(actors.date_of_birth, floor((now() - actors.date_of_birth) / 31556952), 0) as age,
						weight() as _score
					`));

					builder
						.innerJoin('actors', 'actors.id', 'actors_stashed.actor_id')
						.where('stash_id', filters.stashId);
				} else {
					builder.select(knex.raw('*, weight() as _score'));
				}

				if (filters.query) {
					if (filters.query.charAt(0) === '#') {
						builder.where('id', Number(escape(filters.query.slice(1))));
					} else {
						builder.whereRaw('match(\'@name :query:\', actors)', { query: escape(filters.query) });
					}
				}

				// attribute filters
				['country'].forEach((attribute) => {
					if (filters[attribute]) {
						builder.where(attribute, filters[attribute]);
					}
				});

				if (filters.gender === 'other') {
					builder.whereNull('gender');
				} else if (filters.gender) {
					builder.where('gender', filters.gender);
				}

				if (filters.age) {
					builder.select('if(date_of_birth, floor((now() - date_of_birth) / 31556952), 0) as age');
				}

				// range filters
				['age', 'height'].forEach((attribute) => {
					if (filters[attribute]) {
						builder
							.where(attribute, '>=', filters[attribute][0])
							.where(attribute, '<=', filters[attribute][1]);
					}
				});

				if (filters.weight) {
					// weight is a reserved keyword in manticore
					builder
						.where('mass', '>=', filters.weight[0])
						.where('mass', '<=', filters.weight[1]);
				}

				if (filters.dateOfBirth && filters.dobType === 'dateOfBirth') {
					builder.where('date_of_birth', Math.floor(filters.dateOfBirth.getTime() / 1000));
				}

				if (filters.dateOfBirth && filters.dobType === 'birthday') {
					const month = filters.dateOfBirth.getMonth() + 1;
					const day = filters.dateOfBirth.getDate();

					builder.select('month(date_of_birth) as month_of_birth, day(date_of_birth) as day_of_birth');

					builder
						.where('month_of_birth', month)
						.where('day_of_birth', day);
				}

				if (filters.cup) {
					builder.select(`regex(actors.cup, '^[${filters.cup[0]}-${filters.cup[1]}]') as cup_in_range`);
					builder.where('cup_in_range', 1);
				}

				if (typeof filters.naturalBoobs === 'boolean') {
					builder.where('natural_boobs', filters.naturalBoobs ? 2 : 1); // manticore boolean does not support null, so 0 = null, 1 = false (enhanced), 2 = true (natural)
				}

				if (filters.requireAvatar) {
					builder.where('has_avatar', 1);
				}

				if (options.order?.[0] === 'name') {
					builder.orderBy('actors.slug', options.order[1]);
				} else if (options.order?.[0] === 'likes') {
					builder.orderBy([
						{ column: 'actors.stashed', order: options.order[1] },
						{ column: 'actors.slug', order: 'asc' },
					]);
				} else if (options.order?.[0] === 'scenes') {
					builder.orderBy([
						{ column: 'actors.scenes', order: options.order[1] },
						{ column: 'actors.slug', order: 'asc' },
					]);
				} else if (options.order?.[0] === 'results') {
					builder.orderBy([
						{ column: '_score', order: options.order[1] },
						{ column: 'actors.stashed', order: 'desc' },
						{ column: 'actors.slug', order: 'asc' },
					]);
				} else if (options.order?.[0] === 'stashed' && filters.stashId) {
					builder.orderBy([
						{ column: 'stashed_at', order: options.order[1] },
						{ column: 'actors.slug', order: 'asc' },
					]);
				} else if (options.order) {
					builder.orderBy([
						{ column: `actors.${options.order[0]}`, order: options.order[1] },
						{ column: 'actors.slug', order: 'asc' },
					]);
				} else {
					builder.orderBy('actors.slug', 'asc');
				}
			})
			.limit(options.limit)
			.offset((options.page - 1) * options.limit)
			.toString(),
		// option threads=1 fixes actors, but drastically slows down performance, wait for fix
		countriesFacet: options.aggregateCountries ? knex.raw('facet actors.country order by count(*) desc limit :aggSize', { aggSize }) : null,
		maxMatches: config.database.manticore.maxMatches,
		maxQueryTime: config.database.manticore.maxQueryTime,
	}).toString();

	// manticore does not seem to accept table.column syntax if 'table' is primary (yet?), crude work-around
	const curatedSqlQuery = filters.stashId
		? sqlQuery
		: sqlQuery.replace(/actors\./g, '');

	if (process.env.NODE_ENV === 'development') {
		console.log(curatedSqlQuery);
	}

	const results = await utilsApi.sql(curatedSqlQuery);

	const countries = results
		.find((result) => (result.columns[0].country || result.columns[0]['actors.country']) && result.columns[1]['count(*)'])
		?.data.map((row) => ({ key: row.country || row['actors.country'], doc_count: row['count(*)'] })).filter((country) => !!country.key)
		|| [];

	const total = Number(results.at(-1).data.find((entry) => entry.Variable_name === 'total_found').Value);

	return {
		actors: results[0].data,
		total,
		aggregations: {
			countries,
		},
	};
}

export async function fetchActors(filters, rawOptions, reqUser) {
	const options = curateOptions(rawOptions);

	console.log('filters', filters);
	console.log('options', options);

	const result = await queryManticoreSql(filters, options, reqUser);

	// console.log('result', result);

	const actorIds = result.actors.map((actor) => Number(actor.id));
	const [actors, countries] = await Promise.all([
		fetchActorsById(actorIds, {}, reqUser),
		fetchCountriesByAlpha2(result.aggregations.countries.map((bucket) => bucket.key)),
	]);

	return {
		actors,
		countries,
		total: result.total,
		limit: options.limit,
	};
}

export async function fetchActorRevisions(revisionId, filters = {}, reqUser) {
	const limit = filters.limit || 50;
	const page = filters.page || 1;

	const revisions = await knex('actors_revisions')
		.select(
			'actors_revisions.*',
			'users.username as username',
			'reviewers.username as reviewer_username',
		)
		.leftJoin('users', 'users.id', 'actors_revisions.user_id')
		.leftJoin('users as reviewers', 'reviewers.id', 'actors_revisions.reviewed_by')
		.modify((builder) => {
			if (!['admin', 'editor'].includes(reqUser?.role) && !filters.userId && !filters.actorId) {
				builder.where('user_id', reqUser.id);
			}

			if (filters.userId) {
				if (!['admin', 'editor'].includes(reqUser?.role) && filters.userId !== reqUser.id) {
					throw new HttpError('You are not permitted to view revisions from other users.', 403);
				}

				builder.where('actors_revisions.user_id', filters.userId);
			}

			if (revisionId) {
				builder.where('actors_revisions.id', revisionId);
				return;
			}

			if (filters.actorId) {
				builder.where('actors_revisions.actor_id', filters.actorId);
			}

			if (filters.isFinalized === false) {
				builder.whereNull('approved');
			}

			if (filters.isFinalized === true) {
				builder.whereNotNull('approved');
			}
		})
		.orderBy('created_at', 'desc')
		.limit(limit)
		.offset((page - 1) * limit);

	const avatarIds = Array.from(new Set(revisions.flatMap((revision) => [revision.base.avatar, revision.deltas.find((delta) => delta.key === 'avatar')?.value]))).filter(Boolean);
	const avatarEntries = await knex('media').whereIn('id', avatarIds);
	const avatars = avatarEntries.map((avatar) => curateMedia(avatar));

	const curatedRevisions = revisions.map((revision) => curateRevision(revision));

	return {
		revisions: curatedRevisions,
		revision: revisionId && curatedRevisions.find((revision) => revision.id === revisionId),
		avatars,
	};
}

const keyMap = {
	avatar: 'avatar_media_id',
	dateOfBirth: 'date_of_birth',
	dateOfDeath: 'date_of_death',
	originCountry: 'birth_country_alpha2',
	originState: 'birth_state',
	originCity: 'birth_city',
	residenceCountry: 'residence_country_alpha2',
	residenceState: 'residence_state',
	residenceCity: 'residence_city',
	hairColor: 'hair_color',
	naturalBoobs: 'natural_boobs',
	boobsVolume: 'boobs_volume',
	boobsImplant: 'boobs_implant',
	boobsPlacement: 'boobs_placement',
	boobsSurgeon: 'boobs_surgeon',
	naturalButt: 'natural_butt',
	buttVolume: 'butt_volume',
	buttImplant: 'butt_implant',
	penisLength: 'penis_length',
	penisGirth: 'penis_girth',
	isCircumcised: 'circumcised',
	hasTattoos: 'has_tattoos',
	hasPiercings: 'has_piercings',
};

async function applyActorValueDelta(profileId, delta, trx) {
	return knex('actors_profiles')
		.where('id', profileId)
		.update(keyMap[delta.key] || delta.key, delta.value)
		.transacting(trx);
}

async function applyActorDirectDelta(actorId, delta, trx) {
	return knex('actors')
		.where('id', actorId)
		.update(keyMap[delta.key] || delta.key, delta.value)
		.modify((builder) => {
			if (delta.key === 'name') {
				builder.update('slug', slugify(delta.value));
			}
		})
		.transacting(trx);
}

async function fetchMainProfile(actorId, wasCreated = false) {
	const profileEntry = await knex('actors_profiles')
		.where('actor_id', actorId)
		.where('entity_id', null)
		.first();

	if (profileEntry) {
		return profileEntry;
	}

	if (wasCreated) {
		throw new HttpError('Failed to find or create main profile', 404);
	}

	await knex('actors_profiles').insert({
		actor_id: actorId,
		entity_id: null,
	});

	return fetchMainProfile(actorId, true);
}

/*
async function applyMainProfile(actorId) {
	const [actorEntry, mainProfile] = await Promise.all([
		knex('actors')
			.where('id', actorId)
			.first(),
		fetchMainProfile(actorId),
	]);

	if (!actorEntry) {
		throw new HttpError('No actor profile found to apply main profile to', 404);
	}

	const preservedKeys = ['id'];

	// we start iterating from the actor entry so we don't include keys that are not yet supported by the actors table
	const mergedProfile = Object.fromEntries(Object.entries(actorEntry)
		.filter(([key]) => Object.hasOwn(mainProfile, key))
		.map(([key, value]) => [key, mainProfile[key] === null || preservedKeys.includes(key)
			? value
			: mainProfile[key]]));

	await knex('actors')
		.where('id', actorId)
		.update(mergedProfile);
}
*/

async function applyActorRevision(revisionIds, reqUser) {
	const revisions = await knex('actors_revisions')
		.whereIn('id', revisionIds)
		.whereNull('applied_at'); // should not re-apply revision that was already applied

	await revisions.reduce(async (chain, revision) => {
		await chain;

		const mainProfile = await fetchMainProfile(revision.actor_id);

		await knex.transaction(async (trx) => {
			await Promise.all(revision.deltas.map(async (delta) => {
				if ([
					'gender',
					'avatar',
					'dateOfBirth',
					'dateOfDeath',
					'originCountry',
					'originState',
					'originCity',
					'residenceCountry',
					'residenceState',
					'residenceCity',
					'height',
					'weight',
					'bust',
					'cup',
					'waist',
					'hip',
					'naturalBoobs',
					'boobsVolume',
					'boobsImplant',
					'boobsPlacement',
					'boobsSurgeon',
					'naturalButt',
					'buttVolume',
					'buttImplant',
					'penisLength',
					'penisGirth',
					'isCircumcised',
					'hairColor',
					'eyes',
					'hasTattoos',
					'tattoos',
					'hasPiercings',
					'piercings',
					'agency',
				].includes(delta.key)) {
					return applyActorValueDelta(mainProfile.id, delta, trx);
				}

				if (delta.key === 'name' && reqUser.role === 'admin') {
					return applyActorDirectDelta(revision.actor_id, delta, trx);
				}

				return null;
			}));

			await knex('actors_revisions')
				.transacting(trx)
				.where('id', revision.id)
				.update('applied_at', knex.fn.now());

			// await trx.commit();
		}).catch(async (error) => {
			logger.error(`Failed to apply revision ${revision.id} on actor ${revision.actor_id}: ${error.message}`);
		});
	}, Promise.resolve());

	const actorIds = Array.from(new Set(revisions.map((revision) => revision.actor_id)));

	await interpolateProfiles(actorIds, {
		knex,
		logger,
		moment,
		slugify,
		omit,
	});
}

export async function reviewActorRevision(revisionId, isApproved, { feedback }, reqUser) {
	if (!reqUser || reqUser.role === 'user') {
		throw new HttpError('You are not permitted to approve revisions', 403);
	}

	if (typeof isApproved !== 'boolean') {
		throw new HttpError('You must either approve or reject the revision', 400);
	}

	const updated = await knex('actors_revisions')
		.where('id', revisionId)
		.whereNull('approved') // don't rerun reviewed revision, must be forked into new revision instead
		.whereNull('applied_at')
		.update({
			approved: isApproved,
			reviewed_at: knex.fn.now(),
			reviewed_by: reqUser.id,
			feedback,
		});

	if (updated === 0) {
		throw new HttpError('This revision was already reviewed', 409);
	}

	if (isApproved) {
		await applyActorRevision([revisionId], reqUser);
	}
}

const cupConversions = {
	us: ['AA', 'A', 'B', 'C', 'D', ['DD', 'E'], ['DDD', 'F'], 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P'], // United States
	uk: ['AA', 'A', 'B', 'C', 'D', 'DD', 'E', 'F', 'FF', 'G', 'GG', 'H', 'HH', 'J', 'JJ', 'K', 'KK'], // United Kingdom
	eu: ['AA', 'A', 'B', 'C', 'D', 'E', 'F', 'G', ' H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P'], // Europe
	jp: ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q'], // Japan
};

cupConversions.fr = cupConversions.eu; // France
cupConversions.it = cupConversions.uk; // Italy
cupConversions.au = cupConversions.uk; // Australia

// bra band sizes
const bustConversions = {
	us: [28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56],
	eu: [60, 65, 70, 75, 80, 85, 90, 95, 100, 105, 110, 115, 120, 125, 130],
	fr: [75, 80, 85, 90, 95, 100, 105, 110, 115, 120, 125, 130, 135, 140, 145],
	it: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13],
	au: [6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34],
};

bustConversions.uk = bustConversions.us;
bustConversions.jp = bustConversions.eu;

const conversions = {
	cup: cupConversions,
	bust: bustConversions,
};

// to US
function convertFigure(domain = 'cup', rawValue, units) {
	if (!rawValue) {
		return null;
	}

	const value = typeof rawValue === 'string'
		? rawValue.toUpperCase()
		: Number(rawValue);

	if (!units || !cupConversions[units] || units === 'us') {
		return value;
	}

	if (!conversions[domain]) {
		if (['us', 'uk'].includes(units)) {
			return value; // should already be in inches
		}

		return Math.round(convert(value, 'cm').to('inches'));
	}

	if (Number.isNaN(value)) {
		return value;
	}

	const valueIndex = conversions[domain][units].findIndex((chartValue) => (Array.isArray(chartValue) // US uses both DD and E, and DDD and F
		? chartValue.includes(value)
		: value === chartValue));

	const usValue = Array.isArray(conversions[domain].us[valueIndex])
		? conversions[domain].us[valueIndex][0]
		: conversions[domain].us[valueIndex];

	return usValue;
}

export async function createActorRevision(actorId, {
	edits,
	comment,
	apply,
	...options
}, reqUser) {
	const [
		[actor],
		openRevisions,
	] = await Promise.all([
		fetchActorsById([actorId], {
			reqUser,
			includeAssets: true,
			includePartOf: true,
		}),
		knex('actors_revisions')
			.where('user_id', reqUser.id)
			.whereNull('approved'),
	]);

	if (!actor) {
		throw new HttpError(`No actor with ID ${actorId} found to update`, 404);
	}

	if (openRevisions.length >= config.revisions.unapprovedLimit && reqUser.role !== 'admin') {
		throw new HttpError(`You have ${config.revisions.unapprovedLimit} unapproved revisions, please wait for approval before submitting another revision.`, 429);
	}

	const baseActor = Object.fromEntries(Object.entries(actor).map(([key, values]) => {
		if ([
			'scenes',
			'likes',
			'stashes',
			'profiles',
		].includes(key)) {
			return null;
		}

		/* avatar should return id
		if (values?.hash) {
			return [key, values.hash];
		}
		*/

		if (values?.id) {
			return [key, values.id];
		}

		if (values?.metric) {
			return [key, values.metric];
		}

		if (Array.isArray(values)) {
			return [key, values.map((value) => value?.hash || value?.id || value)];
		}

		return [key, values];
	}).filter(Boolean));

	const deltas = Object.entries(edits).map(([key, value]) => {
		if (baseActor[key] === value || typeof value === 'undefined') {
			return null;
		}

		if (Array.isArray(value)) {
			const valueSet = new Set(value);
			const baseSet = new Set(baseActor[key]);

			if (valueSet.size === baseSet.size && baseActor[key].every((id) => valueSet.has(id))) {
				return null;
			}

			return { key, value: Array.from(valueSet) };
		}

		if (['cup', 'bust', 'waist', 'hip'].includes(key)) {
			const convertedValue = convertFigure(key, value, options.figureUnits);

			const conversionComment = !value || convertedValue === value
				? null
				: `${key} converted from ${value} ${options.figureUnits?.toUpperCase() || 'US'} to ${convertedValue} US`;

			return {
				key,
				value: convertedValue,
				comment: conversionComment,
			};
		}

		return { key, value };
	}).filter(Boolean);

	const deltaComments = deltas.map((delta) => delta.comment);
	const curatedComment = [comment, ...deltaComments].filter(Boolean).join(' | ');

	if (deltas.length === 0) {
		throw new HttpError('No effective changes provided', 400);
	}

	const [revisionEntry] = await knex('actors_revisions')
		.insert({
			user_id: reqUser.id,
			actor_id: actor.id,
			base: JSON.stringify(baseActor),
			deltas: JSON.stringify(deltas),
			hash: mj.hash({
				base: baseActor,
				deltas,
			}),
			comment: curatedComment,
		})
		.returning('id');

	if (['admin', 'editor'].includes(reqUser.role) && apply) {
		// don't keep the editor waiting for the revision to apply
		reviewActorRevision(revisionEntry.id, true, {}, reqUser);
	}
}