import {
	type ArchiveFilter,
	type ArchiveFilterInput,
	type ComicFilter,
	type ComicFilterInput,
	type StringFilter,
	type TagFilter,
	type TagFilterInput
} from '$gql/graphql';
import { getContext, setContext } from 'svelte';
import { writable, type Writable } from 'svelte/store';
import { navigate } from './Navigation';
import { numKeys } from './Utils';

interface FilterInput<T> {
	include?: T | null;
	exclude?: T | null;
}

interface BasicFilter {
	name?: { contains?: string | null } | null;
}

type FilterMode = 'any' | 'all' | 'exact';

type Key = string | number | symbol;

type Filter<T, K extends Key> = {
	[Property in K]?: T | null;
};

type AssocFilter<T, K extends Key> = Filter<
	{
		any?: T[] | null;
		all?: T[] | null;
		exact?: T[] | null;
		empty?: boolean | null;
	},
	K
>;

type EnumFilter<K extends Key> = Filter<
	{
		any?: string[] | null;
		empty?: boolean | null;
	},
	K
>;

interface Integrateable<F> {
	integrate(filter: F): void;
}

class ComplexMember<K extends Key> {
	values: unknown[] = [];
	key: K;
	mode: FilterMode;
	empty?: boolean | null;

	constructor(key: K, mode: FilterMode) {
		this.key = key;
		this.mode = mode;
	}

	integrate(filter: AssocFilter<unknown, K>) {
		if (this.values.length > 0) {
			filter[this.key] = { [this.mode]: this.values };
		}

		if (this.empty) {
			filter[this.key] = { ...filter[this.key], empty: this.empty };
		}
	}
}

export class Association<K extends Key> extends ComplexMember<K> {
	values: (string | number)[] = [];

	constructor(key: K, mode: FilterMode, filter?: AssocFilter<string | number, K> | null) {
		super(key, mode);

		if (!filter) {
			return;
		}

		const prop = filter[key];
		this.empty = prop?.empty;

		if (prop?.all && prop.all.length > 0) {
			this.mode = 'all';
			this.values = prop.all;
		} else if (prop?.any && prop.any.length > 0) {
			this.mode = 'any';
			this.values = prop.any;
		} else if (prop?.exact && prop.exact.length > 0) {
			this.mode = 'exact';
			this.values = prop.exact;
		}
	}
}

export class Enum<K extends Key> extends ComplexMember<K> {
	values: string[] = [];

	constructor(key: K, filter?: EnumFilter<K> | null) {
		super(key, 'any');

		if (!filter) {
			return;
		}

		this.empty = filter[key]?.empty;

		const prop = filter[key];
		if (prop?.any) {
			this.values = prop.any;
		}
	}
}

class Bool<K extends Key> {
	key: K;
	value?: boolean = undefined;

	constructor(key: K, filter?: Filter<boolean, K> | null) {
		this.key = key;

		if (filter) {
			this.value = filter[key] ?? undefined;
		}
	}

	integrate(filter: Filter<boolean, K>) {
		if (this.value !== undefined) {
			filter[this.key] = this.value;
		}
	}
}

class Str<K extends Key> {
	key: K;
	contains = '';

	constructor(key: K, filter?: Filter<StringFilter, K> | null) {
		this.key = key;

		if (filter) {
			this.contains = filter[key]?.contains ?? '';
		}
	}

	integrate(filter: Filter<StringFilter, K>) {
		if (this.contains) {
			filter[this.key] = { contains: this.contains };
		}
	}
}

abstract class Controls<F> {
	buildFilter() {
		const filter = {} as F;
		Object.values(this).forEach((v: Integrateable<F>) => v.integrate(filter));
		return filter;
	}
}

export class ArchiveFilterControls extends Controls<ArchiveFilter> {
	path: Str<'path'>;
	organized: Bool<'organized'>;

	constructor(filter: ArchiveFilter | null | undefined) {
		super();

		this.path = new Str('path', filter);
		this.organized = new Bool('organized', filter);
	}
}

export class ComicFilterControls extends Controls<ComicFilter> {
	title: Str<'title'>;
	categories: Enum<'category'>;
	censorships: Enum<'censorship'>;
	ratings: Enum<'rating'>;
	tags: Association<'tags'>;
	languages: Enum<'language'>;
	artists: Association<'artists'>;
	circles: Association<'circles'>;
	characters: Association<'characters'>;
	worlds: Association<'worlds'>;
	favourite: Bool<'favourite'>;
	organized: Bool<'organized'>;
	bookmarked: Bool<'bookmarked'>;

	constructor(filter: ComicFilter | null | undefined, mode: FilterMode);
	constructor(filter: ComicFilter | null | undefined, mode: FilterMode);
	constructor(filter: ComicFilter | null | undefined, mode: FilterMode) {
		super();

		this.title = new Str('title', filter);
		this.favourite = new Bool('favourite', filter);
		this.organized = new Bool('organized', filter);
		this.bookmarked = new Bool('bookmarked', filter);
		this.tags = new Association('tags', mode, filter);
		this.languages = new Enum('language', filter);
		this.categories = new Enum('category', filter);
		this.censorships = new Enum('censorship', filter);
		this.ratings = new Enum('rating', filter);
		this.artists = new Association('artists', mode, filter);
		this.circles = new Association('circles', mode, filter);
		this.characters = new Association('characters', mode, filter);
		this.worlds = new Association('worlds', mode, filter);
	}
}

export class BasicFilterControls extends Controls<BasicFilter> {
	name: Str<'name'>;

	constructor(filter?: BasicFilter | null) {
		super();

		this.name = new Str('name', filter);
	}
}

export class TagFilterControls extends BasicFilterControls {
	namespaces: Association<'namespaces'>;

	constructor(filter: TagFilter | null | undefined, mode: FilterMode) {
		super(filter);

		this.namespaces = new Association('namespaces', mode, filter);
	}
}

function buildFilterInput<F>(include?: F, exclude?: F) {
	const input: FilterInput<F> = {};

	if (include && Object.keys(include).length > 0) {
		input.include = include;
	}

	if (exclude && Object.keys(exclude).length > 0) {
		input.exclude = exclude;
	}

	return input;
}

abstract class FilterContext<F> {
	include!: { controls: Controls<F>; size: number };
	exclude!: { controls: Controls<F>; size: number };

	apply(params: URLSearchParams) {
		navigate(
			{
				filter: buildFilterInput(
					this.include.controls.buildFilter(),
					this.exclude.controls.buildFilter()
				)
			},
			params
		);
	}
}

export class ArchiveFilterContext extends FilterContext<ArchiveFilter> {
	include: { controls: ArchiveFilterControls; size: number };
	exclude: { controls: ArchiveFilterControls; size: number };
	private static ignore = ['organized'];

	constructor(filter: ArchiveFilterInput) {
		super();

		this.include = {
			controls: new ArchiveFilterControls(filter.include),
			size: numKeys(filter.include, ArchiveFilterContext.ignore)
		};
		this.exclude = {
			controls: new ArchiveFilterControls(filter.exclude),
			size: numKeys(filter.exclude, ArchiveFilterContext.ignore)
		};
	}
}

export class ComicFilterContext extends FilterContext<ComicFilter> {
	include: { controls: ComicFilterControls; size: number };
	exclude: { controls: ComicFilterControls; size: number };
	private static ignore = ['title', 'favourite', 'organized', 'bookmarked'];

	constructor(filter: ComicFilterInput) {
		super();

		this.include = {
			controls: new ComicFilterControls(filter.include, 'all'),
			size: numKeys(filter.include, ComicFilterContext.ignore)
		};
		this.exclude = {
			controls: new ComicFilterControls(filter.exclude, 'any'),
			size: numKeys(filter.exclude, ComicFilterContext.ignore)
		};
	}
}

export class BasicFilterContext extends FilterContext<BasicFilter> {
	include: { controls: BasicFilterControls; size: number };
	exclude: { controls: BasicFilterControls; size: number };

	constructor(filter: FilterInput<BasicFilter>) {
		super();

		this.include = {
			controls: new BasicFilterControls(filter.include),
			size: numKeys(filter.include)
		};
		this.exclude = {
			controls: new BasicFilterControls(),
			size: 0
		};
	}
}

export class TagFilterContext extends FilterContext<TagFilter> {
	include: { controls: TagFilterControls; size: number };
	exclude: { controls: TagFilterControls; size: number };
	private static ignore = ['name'];

	constructor(filter: TagFilterInput) {
		super();

		this.include = {
			controls: new TagFilterControls(filter.include, 'all'),
			size: numKeys(filter.include, TagFilterContext.ignore)
		};
		this.exclude = {
			controls: new TagFilterControls(filter.exclude, 'any'),
			size: numKeys(filter.exclude, TagFilterContext.ignore)
		};
	}
}

export function initFilterContext<F extends FilterContext<unknown>>() {
	return setContext<Writable<F>>('filter', writable());
}

export function getFilterContext<F extends FilterContext<unknown>>() {
	return getContext<Writable<F>>('filter');
}

export function cycleBooleanFilter(value: boolean | undefined, tristate = true) {
	if (tristate) {
		if (value === undefined) {
			return true;
		} else if (value) {
			return false;
		} else {
			return undefined;
		}
	} else {
		if (value) {
			return undefined;
		} else {
			return true;
		}
	}
}