import { isNodeData, NodeData } from "common/model";
import { HttpWrapperService, BddService } from "common/service";
import { DataInterface, isArrayOf, isNullOrUndefined, TypeCheck } from "common/utils";

export class GenericInterfaceModelDBv2<TYPE> {
	constructor(
		protected serviceName: string,
		protected http: HttpWrapperService,
		protected bdd: BddService,
		protected checker: (subData: any) => subData is TYPE) {
		// nothing to do ...
	}

	gets(): Promise<TYPE[]> {
		let self = this;
		return new Promise((resolve, reject) => {
			self.bdd.get(self.serviceName)
				.then((response: DataInterface) => {
					let data = response.gets();
					if (isNullOrUndefined(data)) {
						reject('Data does not exist in the local BDD');
						return;
					}
					if (isArrayOf<TYPE>(data, this.checker)) {
						resolve(data);
					} else {
						reject("The data is not an array of the correct type ...");
					}
					return;
				}).catch((response) => {
					reject(response);
				});
		});
	}
	get(id: number): Promise<TYPE> {
		let self = this;
		return new Promise((resolve, reject) => {
			self.bdd.get(self.serviceName)
				.then((response: DataInterface) => {
					let data = response.get(id);
					if (isNullOrUndefined(data)) {
						reject('Data does not exist in the local BDD');
						return;
					}
					if (this.checker(data)) {
						resolve(data);
					} else {
						reject("The data is not an array of the correct type ...");
					}
					return;
				}).catch((response) => {
					reject(response);
				});
		});
	}

	getFilter(filter: (subData: any) => boolean): Promise<TYPE[]> {
		let self = this;
		return new Promise((resolve, reject) => {
			self.bdd.get(self.serviceName)
				.then((response: DataInterface) => {
					let data = response.gets();
					if (isNullOrUndefined(data)) {
						reject('Data does not exist in the local BDD');
						return;
					}
					let out = [];
					for (const elem of data) {
						if (filter(elem)) {
							out.push(elem);
						}
					}
					resolve(out as TYPE[]);
					return;
				}).catch((response) => {
					reject(response);
				});
		});
	}

	insert(data: object): TYPE {
		let ret = this.http.postSpecific([this.serviceName], data);
		return this.bdd.addAfterPost(this.serviceName, ret) as TYPE;

	}
	patch(id: number, data: object): TYPE {
		let ret = this.http.patchSpecific([this.serviceName, id], data);
		return this.bdd.setAfterPut(this.serviceName, id, ret) as TYPE;
	}

	delete(id: number): TYPE {
		let ret = this.http.deleteSpecific([this.serviceName, id]);
		return this.bdd.delete(this.serviceName, id, ret) as TYPE;
	}

}