define(['core/ArrayUtilities'], (array) => {
	'use strict';

	class AgentState {
		constructor({
			visible = false,
			locked = false,
			blocked = false,
			highlighted = false,
			group = null,
			covered = false,
		} = {}) {
			this.visible = visible;
			this.locked = locked;
			this.blocked = blocked;
			this.highlighted = highlighted;
			this.group = group;
			this.covered = covered;
		}
	}
	AgentState.LOCKED = new AgentState({locked: true});
	AgentState.DEFAULT = new AgentState();

	const Agent = {
		equals: (a, b) => {
			return a.name === b.name;
		},
		make: (name, {anchorRight = false} = {}) => {
			return {name, anchorRight};
		},
		getName: (agent) => {
			return agent.name;
		},
		hasFlag: (flag, has = true) => {
			return (agent) => (agent.flags.includes(flag) === has);
		},
	};

	const MERGABLE = {
		'agent begin': {
			check: ['mode'],
			merge: ['agentNames'],
			siblings: new Set(['agent highlight']),
		},
		'agent end': {
			check: ['mode'],
			merge: ['agentNames'],
			siblings: new Set(['agent highlight']),
		},
		'agent highlight': {
			check: ['highlighted'],
			merge: ['agentNames'],
			siblings: new Set(['agent begin', 'agent end']),
		},
	};

	function mergableParallel(target, copy) {
		const info = MERGABLE[target.type];
		if(!info || target.type !== copy.type) {
			return false;
		}
		if(info.check.some((c) => target[c] !== copy[c])) {
			return false;
		}
		return true;
	}

	function performMerge(target, copy) {
		const info = MERGABLE[target.type];
		info.merge.forEach((m) => {
			array.mergeSets(target[m], copy[m]);
		});
	}

	function iterateRemoval(list, fn) {
		for(let i = 0; i < list.length;) {
			const remove = fn(list[i], i);
			if(remove) {
				list.splice(i, 1);
			} else {
				++ i;
			}
		}
	}

	function performParallelMergers(stages) {
		iterateRemoval(stages, (stage, i) => {
			for(let j = 0; j < i; ++ j) {
				if(mergableParallel(stages[j], stage)) {
					performMerge(stages[j], stage);
					return true;
				}
			}
			return false;
		});
	}

	function findViableSequentialMergers(stages) {
		const mergers = new Set();
		const types = stages.map(({type}) => type);
		types.forEach((type) => {
			const info = MERGABLE[type];
			if(!info) {
				return;
			}
			if(types.every((sType) =>
				(type === sType || info.siblings.has(sType))
			)) {
				mergers.add(type);
			}
		});
		return mergers;
	}

	function performSequentialMergers(lastViable, viable, lastStages, stages) {
		iterateRemoval(stages, (stage) => {
			if(!lastViable.has(stage.type) || !viable.has(stage.type)) {
				return false;
			}
			for(let j = 0; j < lastStages.length; ++ j) {
				if(mergableParallel(lastStages[j], stage)) {
					performMerge(lastStages[j], stage);
					return true;
				}
			}
			return false;
		});
	}

	function optimiseStages(stages) {
		let lastStages = [];
		let lastViable = new Set();
		for(let i = 0; i < stages.length;) {
			const stage = stages[i];
			let subStages = null;
			if(stage.type === 'parallel') {
				subStages = stage.stages;
			} else {
				subStages = [stage];
			}

			performParallelMergers(subStages);
			const viable = findViableSequentialMergers(subStages);
			performSequentialMergers(lastViable, viable, lastStages, subStages);

			lastViable = viable;
			lastStages = subStages;

			if(subStages.length === 0) {
				stages.splice(i, 1);
			} else if(stage.type === 'parallel' && subStages.length === 1) {
				stages.splice(i, 1, subStages[0]);
				++ i;
			} else {
				++ i;
			}
		}
	}

	function swapBegin(stage, mode) {
		if(stage.type === 'agent begin') {
			stage.mode = mode;
			return true;
		}
		if(stage.type === 'parallel') {
			let any = false;
			stage.stages.forEach((subStage) => {
				if(subStage.type === 'agent begin') {
					subStage.mode = mode;
					any = true;
				}
			});
			return any;
		}
		return false;
	}

	function swapFirstBegin(stages, mode) {
		for(let i = 0; i < stages.length; ++ i) {
			if(swapBegin(stages[i], mode)) {
				break;
			}
		}
	}

	function addBounds(target, agentL, agentR, involvedAgents = null) {
		array.remove(target, agentL, Agent.equals);
		array.remove(target, agentR, Agent.equals);

		let indexL = 0;
		let indexR = target.length;
		if(involvedAgents) {
			const found = (involvedAgents
				.map((agent) => array.indexOf(target, agent, Agent.equals))
				.filter((p) => (p !== -1))
			);
			indexL = found.reduce((a, b) => Math.min(a, b), target.length);
			indexR = found.reduce((a, b) => Math.max(a, b), indexL) + 1;
		}

		target.splice(indexL, 0, agentL);
		target.splice(indexR + 1, 0, agentR);

		return {indexL, indexR: indexR + 1};
	}

	const NOTE_DEFAULT_AGENTS = {
		'note over': [{name: '[', flags: []}, {name: ']', flags: []}],
		'note left': [{name: '[', flags: []}],
		'note right': [{name: ']', flags: []}],
	};

	return class Generator {
		constructor() {
			this.agentStates = new Map();
			this.agentAliases = new Map();
			this.activeGroups = new Map();
			this.agents = [];
			this.labelPattern = null;
			this.blockCount = 0;
			this.nesting = [];
			this.markers = new Set();
			this.currentSection = null;
			this.currentNest = null;

			this.stageHandlers = {
				'block begin': this.handleBlockBegin.bind(this),
				'block split': this.handleBlockSplit.bind(this),
				'block end': this.handleBlockEnd.bind(this),
				'group begin': this.handleGroupBegin.bind(this),
				'mark': this.handleMark.bind(this),
				'async': this.handleAsync.bind(this),
				'agent define': this.handleAgentDefine.bind(this),
				'agent begin': this.handleAgentBegin.bind(this),
				'agent end': this.handleAgentEnd.bind(this),
				'label pattern': this.handleLabelPattern.bind(this),
				'connect': this.handleConnect.bind(this),
				'note over': this.handleNote.bind(this),
				'note left': this.handleNote.bind(this),
				'note right': this.handleNote.bind(this),
				'note between': this.handleNote.bind(this),
			};
			this.expandGroupedAgent = this.expandGroupedAgent.bind(this);
			this.handleStage = this.handleStage.bind(this);
			this.convertAgent = this.convertAgent.bind(this);
			this.endGroup = this.endGroup.bind(this);
		}

		convertAgent({alias, name}) {
			if(alias) {
				if(this.agentAliases.has(name)) {
					throw new Error(
						'Cannot alias ' + name + '; it is already an alias'
					);
				}
				const old = this.agentAliases.get(alias);
				if(
					(old && old !== alias) ||
					this.agents.some((agent) => (agent.name === alias))
				) {
					throw new Error(
						'Cannot use ' + alias +
						' as an alias; it is already in use'
					);
				}
				this.agentAliases.set(alias, name);
			}
			return Agent.make(this.agentAliases.get(name) || name);
		}

		addStage(stage, isVisible = true) {
			if(!stage) {
				return;
			}
			if(stage.ln === undefined) {
				stage.ln = this.latestLine;
			}
			this.currentSection.stages.push(stage);
			if(isVisible) {
				this.currentNest.hasContent = true;
			}
		}

		addParallelStages(stages) {
			const viableStages = stages.filter((stage) => Boolean(stage));
			if(viableStages.length === 0) {
				return;
			}
			if(viableStages.length === 1) {
				return this.addStage(viableStages[0]);
			}
			viableStages.forEach((stage) => {
				if(stage.ln === undefined) {
					stage.ln = this.latestLine;
				}
			});
			return this.addStage({
				type: 'parallel',
				stages: viableStages,
			});
		}

		defineAgents(colAgents) {
			array.mergeSets(this.currentNest.agents, colAgents, Agent.equals);
			array.mergeSets(this.agents, colAgents, Agent.equals);
		}

		getAgentState(agent) {
			return this.agentStates.get(agent.name) || AgentState.DEFAULT;
		}

		updateAgentState(agent, change) {
			const state = this.agentStates.get(agent.name);
			if(state) {
				Object.assign(state, change);
			} else {
				this.agentStates.set(agent.name, new AgentState(change));
			}
		}

		validateAgents(agents, {
			allowGrouped = false,
			rejectGrouped = false,
		} = {}) {
			agents.forEach((agent) => {
				const state = this.getAgentState(agent);
				if(state.covered) {
					throw new Error(
						'Agent ' + agent.name + ' is hidden behind group'
					);
				}
				if(rejectGrouped && state.group !== null) {
					throw new Error('Agent ' + agent.name + ' is in a group');
				}
				if(state.blocked && (!allowGrouped || state.group === null)) {
					throw new Error('Duplicate agent name: ' + agent.name);
				}
				if(agent.name.startsWith('__')) {
					throw new Error(agent.name + ' is a reserved name');
				}
			});
		}

		setAgentVis(colAgents, visible, mode, checked = false) {
			const seen = new Set();
			const filteredAgents = colAgents.filter((agent) => {
				if(seen.has(agent.name)) {
					return false;
				}
				seen.add(agent.name);
				const state = this.getAgentState(agent);
				if(state.locked || state.blocked) {
					if(checked) {
						throw new Error(
							'Cannot begin/end agent: ' + agent.name
						);
					} else {
						return false;
					}
				}
				return state.visible !== visible;
			});
			if(filteredAgents.length === 0) {
				return null;
			}
			filteredAgents.forEach((agent) => {
				this.updateAgentState(agent, {visible});
			});
			this.defineAgents(filteredAgents);

			return {
				type: (visible ? 'agent begin' : 'agent end'),
				agentNames: filteredAgents.map(Agent.getName),
				mode,
			};
		}

		setAgentHighlight(colAgents, highlighted, checked = false) {
			const filteredAgents = colAgents.filter((agent) => {
				const state = this.getAgentState(agent);
				if(state.locked || state.blocked) {
					if(checked) {
						throw new Error(
							'Cannot highlight agent: ' + agent.name
						);
					} else {
						return false;
					}
				}
				return state.visible && (state.highlighted !== highlighted);
			});
			if(filteredAgents.length === 0) {
				return null;
			}
			filteredAgents.forEach((agent) => {
				this.updateAgentState(agent, {highlighted});
			});

			return {
				type: 'agent highlight',
				agentNames: filteredAgents.map(Agent.getName),
				highlighted,
			};
		}

		beginNested(mode, label, name, ln) {
			const leftAgent = Agent.make(name + '[', {anchorRight: true});
			const rightAgent = Agent.make(name + ']');
			const agents = [leftAgent, rightAgent];
			const stages = [];
			this.currentSection = {
				header: {
					type: 'block begin',
					mode,
					label,
					left: leftAgent.name,
					right: rightAgent.name,
					ln,
				},
				stages,
			};
			this.currentNest = {
				mode,
				agents,
				leftAgent,
				rightAgent,
				hasContent: false,
				sections: [this.currentSection],
			};
			this.agentStates.set(leftAgent.name, AgentState.LOCKED);
			this.agentStates.set(rightAgent.name, AgentState.LOCKED);
			this.nesting.push(this.currentNest);

			return {agents, stages};
		}

		nextBlockName() {
			const name = '__BLOCK' + this.blockCount;
			++ this.blockCount;
			return name;
		}

		handleBlockBegin({ln, mode, label}) {
			this.beginNested(mode, label, this.nextBlockName(), ln);
		}

		handleBlockSplit({ln, mode, label}) {
			if(this.currentNest.mode !== 'if') {
				throw new Error(
					'Invalid block nesting ("else" inside ' +
					this.currentNest.mode + ')'
				);
			}
			optimiseStages(this.currentSection.stages);
			this.currentSection = {
				header: {
					type: 'block split',
					mode,
					label,
					left: this.currentNest.leftAgent.name,
					right: this.currentNest.rightAgent.name,
					ln,
				},
				stages: [],
			};
			this.currentNest.sections.push(this.currentSection);
		}

		handleBlockEnd() {
			if(this.nesting.length <= 1) {
				throw new Error('Invalid block nesting (too many "end"s)');
			}
			optimiseStages(this.currentSection.stages);
			const nested = this.nesting.pop();
			this.currentNest = array.last(this.nesting);
			this.currentSection = array.last(this.currentNest.sections);

			if(nested.hasContent) {
				this.defineAgents(nested.agents);
				addBounds(
					this.agents,
					nested.leftAgent,
					nested.rightAgent,
					nested.agents
				);
				nested.sections.forEach((section) => {
					this.currentSection.stages.push(section.header);
					this.currentSection.stages.push(...section.stages);
				});
				this.addStage({
					type: 'block end',
					left: nested.leftAgent.name,
					right: nested.rightAgent.name,
				});
			} else {
				throw new Error('Empty block');
			}
		}

		makeGroupDetails(agents, alias) {
			const colAgents = agents.map(this.convertAgent);
			this.validateAgents(colAgents, {rejectGrouped: true});
			if(this.agentStates.has(alias)) {
				throw new Error('Duplicate agent name: ' + alias);
			}
			const name = this.nextBlockName();
			const leftAgent = Agent.make(name + '[', {anchorRight: true});
			const rightAgent = Agent.make(name + ']');
			this.agentStates.set(leftAgent.name, AgentState.LOCKED);
			this.agentStates.set(rightAgent.name, AgentState.LOCKED);
			this.updateAgentState(
				{name: alias},
				{blocked: true, group: alias}
			);
			this.defineAgents(colAgents);
			const {indexL, indexR} = addBounds(
				this.agents,
				leftAgent,
				rightAgent,
				colAgents
			);

			const agentsCovered = [];
			const agentsContained = colAgents.slice();
			for(let i = indexL + 1; i < indexR; ++ i) {
				agentsCovered.push(this.agents[i]);
			}
			array.removeAll(agentsCovered, agentsContained, Agent.equals);

			return {
				colAgents,
				leftAgent,
				rightAgent,
				agentsContained,
				agentsCovered,
			};
		}

		handleGroupBegin({agents, mode, label, alias}) {
			const details = this.makeGroupDetails(agents, alias);

			details.agentsContained.forEach((agent) => {
				this.updateAgentState(agent, {group: alias});
			});
			details.agentsCovered.forEach((agent) => {
				this.updateAgentState(agent, {covered: true});
			});
			this.activeGroups.set(alias, details);
			this.addStage(this.setAgentVis(details.colAgents, true, 'box'));
			this.addStage({
				type: 'block begin',
				mode,
				label,
				left: details.leftAgent.name,
				right: details.rightAgent.name,
			});
		}

		endGroup({name}) {
			const details = this.activeGroups.get(name);
			if(!details) {
				return null;
			}
			this.activeGroups.delete(name);

			details.agentsContained.forEach((agent) => {
				this.updateAgentState(agent, {group: null});
			});
			details.agentsCovered.forEach((agent) => {
				this.updateAgentState(agent, {covered: false});
			});
			this.updateAgentState({name}, {group: null});

			return {
				type: 'block end',
				left: details.leftAgent.name,
				right: details.rightAgent.name,
			};
		}

		handleMark({name}) {
			this.markers.add(name);
			this.addStage({type: 'mark', name}, false);
		}

		handleAsync({target}) {
			if(target !== '' && !this.markers.has(target)) {
				throw new Error('Unknown marker: ' + target);
			}
			this.addStage({type: 'async', target}, false);
		}

		handleLabelPattern({pattern}) {
			this.labelPattern = pattern.slice();
			for(let i = 0; i < this.labelPattern.length; ++ i) {
				const part = this.labelPattern[i];
				if(typeof part === 'object' && part.start !== undefined) {
					this.labelPattern[i] = Object.assign({
						current: part.start,
					}, part);
				}
			}
		}

		applyLabelPattern(label) {
			let result = '';
			const tokens = {
				'label': label,
			};
			this.labelPattern.forEach((part) => {
				if(typeof part === 'string') {
					result += part;
				} else if(part.token !== undefined) {
					result += tokens[part.token];
				} else if(part.current !== undefined) {
					result += part.current.toFixed(part.dp);
					part.current += part.inc;
				}
			});
			return result;
		}

		expandGroupedAgent(agent) {
			const group = this.getAgentState(agent).group;
			if(!group) {
				return [agent];
			}
			const details = this.activeGroups.get(group);
			return [details.leftAgent, details.rightAgent];
		}

		expandGroupedAgentConnection(agents) {
			const agents1 = this.expandGroupedAgent(agents[0]);
			const agents2 = this.expandGroupedAgent(agents[1]);
			let ind1 = array.indexOf(this.agents, agents1[0], Agent.equals);
			let ind2 = array.indexOf(this.agents, agents2[0], Agent.equals);
			if(ind1 === -1) {
				ind1 = this.agents.length;
			}
			if(ind2 === -1) {
				ind2 = this.agents.length;
			}
			if(ind1 === ind2) {
				// Self-connection
				return [array.last(agents1), array.last(agents2)];
			} else if(ind1 < ind2) {
				return [array.last(agents1), agents2[0]];
			} else {
				return [agents1[0], array.last(agents2)];
			}
		}

		filterConnectFlags(agents) {
			const beginAgents = (agents
				.filter(Agent.hasFlag('begin'))
				.map(this.convertAgent)
			);
			const endAgents = (agents
				.filter(Agent.hasFlag('end'))
				.map(this.convertAgent)
			);
			if(array.hasIntersection(beginAgents, endAgents, Agent.equals)) {
				throw new Error('Cannot set agent visibility multiple times');
			}

			const startAgents = (agents
				.filter(Agent.hasFlag('start'))
				.map(this.convertAgent)
			);
			const stopAgents = (agents
				.filter(Agent.hasFlag('stop'))
				.map(this.convertAgent)
			);
			array.mergeSets(stopAgents, endAgents);
			if(array.hasIntersection(startAgents, stopAgents, Agent.equals)) {
				throw new Error('Cannot set agent highlighting multiple times');
			}

			this.validateAgents(beginAgents);
			this.validateAgents(endAgents);
			this.validateAgents(startAgents);
			this.validateAgents(stopAgents);

			return {beginAgents, endAgents, startAgents, stopAgents};
		}

		handleConnect({agents, label, options}) {
			const flags = this.filterConnectFlags(agents);

			let colAgents = agents.map(this.convertAgent);
			this.validateAgents(colAgents, {allowGrouped: true});

			const allAgents = array.flatMap(colAgents, this.expandGroupedAgent);
			this.defineAgents(allAgents);

			colAgents = this.expandGroupedAgentConnection(colAgents);
			const agentNames = colAgents.map(Agent.getName);

			const implicitBegin = (agents
				.filter(Agent.hasFlag('begin', false))
				.map(this.convertAgent)
			);
			this.addStage(this.setAgentVis(implicitBegin, true, 'box'));

			const connectStage = {
				type: 'connect',
				agentNames,
				label: this.applyLabelPattern(label),
				options,
			};

			this.addParallelStages([
				this.setAgentVis(flags.beginAgents, true, 'box', true),
				this.setAgentHighlight(flags.startAgents, true, true),
				connectStage,
				this.setAgentHighlight(flags.stopAgents, false, true),
				this.setAgentVis(flags.endAgents, false, 'cross', true),
			]);
		}

		handleNote({type, agents, mode, label}) {
			let colAgents = null;
			if(agents.length === 0) {
				colAgents = NOTE_DEFAULT_AGENTS[type] || [];
			} else {
				colAgents = agents.map(this.convertAgent);
			}

			this.validateAgents(colAgents, {allowGrouped: true});
			colAgents = array.flatMap(colAgents, this.expandGroupedAgent);
			const agentNames = colAgents.map(Agent.getName);
			const uniqueAgents = new Set(agentNames).size;
			if(type === 'note between' && uniqueAgents < 2) {
				throw new Error('note between requires at least 2 agents');
			}

			this.addStage(this.setAgentVis(colAgents, true, 'box'));
			this.defineAgents(colAgents);

			this.addStage({
				type,
				agentNames,
				mode,
				label,
			});
		}

		handleAgentDefine({agents}) {
			const colAgents = agents.map(this.convertAgent);
			this.validateAgents(colAgents);
			this.defineAgents(colAgents);
		}

		handleAgentBegin({agents, mode}) {
			const colAgents = agents.map(this.convertAgent);
			this.validateAgents(colAgents);
			this.addStage(this.setAgentVis(colAgents, true, mode, true));
		}

		handleAgentEnd({agents, mode}) {
			const groupAgents = (agents
				.filter((agent) => this.activeGroups.has(agent.name))
			);
			const colAgents = (agents
				.filter((agent) => !this.activeGroups.has(agent.name))
				.map(this.convertAgent)
			);
			this.validateAgents(colAgents);
			this.addParallelStages([
				this.setAgentHighlight(colAgents, false),
				this.setAgentVis(colAgents, false, mode, true),
				...groupAgents.map(this.endGroup),
			]);
		}

		handleStage(stage) {
			this.latestLine = stage.ln;
			try {
				const handler = this.stageHandlers[stage.type];
				if(!handler) {
					throw new Error('Unknown command: ' + stage.type);
				}
				handler(stage);
			} catch(e) {
				if(typeof e === 'object' && e.message) {
					throw new Error(e.message + ' at line ' + (stage.ln + 1));
				}
			}
		}

		generate({stages, meta = {}}) {
			this.agentStates.clear();
			this.markers.clear();
			this.agentAliases.clear();
			this.activeGroups.clear();
			this.agents.length = 0;
			this.blockCount = 0;
			this.nesting.length = 0;
			this.labelPattern = [{token: 'label'}];
			const globals = this.beginNested('global', '', '', 0);

			stages.forEach(this.handleStage);

			if(this.nesting.length !== 1) {
				throw new Error(
					'Unterminated section at line ' +
					(this.currentSection.header.ln + 1)
				);
			}
			if(this.activeGroups.size > 0) {
				throw new Error('Unterminated group');
			}

			const terminators = meta.terminators || 'none';

			this.addParallelStages([
				this.setAgentHighlight(this.agents, false),
				this.setAgentVis(this.agents, false, terminators),
			]);

			addBounds(
				this.agents,
				this.currentNest.leftAgent,
				this.currentNest.rightAgent
			);
			optimiseStages(globals.stages);
			swapFirstBegin(globals.stages, meta.headers || 'box');

			return {
				meta: {
					title: meta.title,
					theme: meta.theme,
				},
				agents: this.agents.slice(),
				stages: globals.stages,
			};
		}
	};
});