import {Field, Model} from "./model";
import {ModelType} from "./universe";

export interface ObjIdentifier {
    base: string;
    target: string;
    name: string;
}

export function parseObjectIdentifier(str: string, uname: string): ObjIdentifier {
	const metaSplit = str.split(':');
	const targetSplit = metaSplit[0].split('/');
	const baseSplit = targetSplit[0].split('.');

	const oi: ObjIdentifier = {
		base: uname,
		name: targetSplit[0],
		target: uname,
	}

	if (baseSplit.length >= 2) {
		oi.base = baseSplit[0];
		oi.name = baseSplit[1];
	}

	if (targetSplit.length >= 2) {
		if (targetSplit[1] !== '') {
			oi.target = targetSplit[1];
		} else {
			oi.target = uname;
		}
	} else {
		oi.target = oi.base;
	}

	return oi;
}

export function identifyObjectIdentifier(oi: ObjIdentifier): string {
	return `${oi.base}.${oi.name}/${oi.target}`;
}

export class ResultSet<K, V> {

	protected readonly _set;

	constructor(set: Map<K, V>) {
		this._set = set;
	}

	public get(id: K): V | undefined {
		return this._set.get(id);
	}

	public get size(): number {
		return this._set.size;
	}

	public get map(): Map<K, V> {
		return this._set;
	}

	public get array(): V[] {
		return Array.from(this._set.values());
	}

}

export class ModelSet extends ResultSet<string, Model> {

	constructor(set: Map<string, Model>) {
		super(set);
	}

	public filter(filter: { target?: string, base?: string, type?: ModelType }): ModelSet {
		let models = Array.from(this._set.entries());
		if (filter.target) {
			models = models.filter(m => m[1].target === filter.target);
		}
		if (filter.base) {
			models = models.filter(m => m[1].base === filter.base);
		}
		if (filter.type) {
			models = models.filter(m => m[1].type === filter.type);
		}
		return new ModelSet(new Map<string, Model>(models));
	}

}

export class FieldSet extends ResultSet<string, Field> {

	constructor(set: Map<string, Field>) {
		super(set);
	}

	public filter(filter: { target?: string, base?: string }): FieldSet {
		let fields = Array.from(this._set.entries());
		if (filter.target) {
			fields = fields.filter(m => m[1].relation.target === filter.target);
		}
		if (filter.base) {
			fields = fields.filter(m => m[1].relation.base === filter.base);
		}
		return new FieldSet(new Map<string, Field>(fields));
	}

}