import { Injectable } from '@angular/core';

import { HttpClient, HttpHeaders, HttpEventType } from '@angular/common/http';

import { environment } from '../../environments/environment';
import { SessionService } from './session';

@Injectable()
export class HttpWrapperService {
	private displayReturn:boolean = false;
	constructor(private http: HttpClient,
				private session: SessionService) {

	}

	createRESTCall(api: string, inputOptions?: any) {
		let basePage = environment.apiUrl;
		let addressServerRest = `${basePage }/`;
		let options = inputOptions;
		if(options === undefined) {
			options = [];
		}
		let out = addressServerRest + api;
		let first = true;
		for(let iii = 0; iii < options.length; iii++) {
			if(first === false) {
				out = `${out }&`;
			} else {
				out = `${out }?`;
				first = false;
			}
			out = out + options[iii];
		}
		return out;
	}

	addTokenIfNeeded(headerOption:any): any {
		if(this.session.sessionData !== null) {
			if(headerOption.authorization === undefined) {
				headerOption.authorization = `Yota ${ this.session.sessionData.userId }:${ this.session.sessionData.token}`;
			}
		}
		return headerOption;
	}

	get(uriRest:string, headerOption:any, params:any) {
		this.addTokenIfNeeded(headerOption);
		let connectionAdresse = this.createRESTCall(uriRest, {});
		let config = {
			params: params,
			headers: new HttpHeaders(headerOption)
		};
		return new Promise((resolve, reject) => {
			if(this.displayReturn === true) {
				console.log(`call GET ${ connectionAdresse } params=${ JSON.stringify(params, null, 2)}`);
			}
			let request = this.http.get<any>(connectionAdresse, config);
			let self = this;
			request.subscribe((res: any) => {
				if(self.displayReturn === true) {
					console.log(`!! data ${ JSON.stringify(res, null, 2)}`);
				}
				if(res) {
					if(res.httpCode) {
						resolve({ status:res.httpCode, data:res });
					} else {
						resolve({ status:200, data:res });
					}
				} else {
					resolve({ status:200, data:'' });
				}
			},
			(error) => {
				if(self.displayReturn === true) {
					console.log(`an error occured status: ${ error.status}`);
					console.log(`answer: ${ JSON.stringify(error, null, 2)}`);
				}
				reject({ status:error.status, data:error.error });
			});
		});
	}

	post(uriRest:string, headerOption:any, data:any, progress:any = null) {
		this.addTokenIfNeeded(headerOption);
		let connectionAdresse = this.createRESTCall(uriRest, {});


		return new Promise((resolve, reject) => {
			if(this.displayReturn === true) {
				console.log(`call POST ${ connectionAdresse } data=${ JSON.stringify(data, null, 2)}`);
			}
			let request = this.http.post(connectionAdresse, data, {
				  headers: new HttpHeaders(headerOption),
			      reportProgress: true,
			      observe: 'events'
			    });
			let self = this;
			request.subscribe((res: any) => {
				if(self.displayReturn === true) {
					console.log(`!! data ${ JSON.stringify(res, null, 2)}`);
				}
			        if(res.type === HttpEventType.Sent) {
			        	/* res.type === 0 */
			        	console.log('post : Sent');
			        } else if(res.type === HttpEventType.UploadProgress) {
			        	/* res.type === 1 */
			            // console.log("post : " + res.loaded + " / " +  res.total);
			            progress(res.loaded, res.total);
			        } else if(res.type === HttpEventType.ResponseHeader) {
			        	/* res.type === 2 */
			        	console.log('post : get header');
			        } else if(res.type === HttpEventType.DownloadProgress) {
			        	/* res.type === 3 */
			        	console.log(`post : get DownloadProgress ${ res.loaded}`);
			        } else if(res.type === HttpEventType.Response) {
			        	/* res.type === 4 */
			        	console.log('post : get response');
			        	if(res.httpCode) {
						resolve({ status:res.httpCode, data:res });
					} else {
						resolve({ status:200, data:res });
					}
			        } else if(res.type === HttpEventType.User) {
			        	/* res.type === 5 */
			        	console.log('post : get User');
			        } else {
			        	console.log(`post : get unknown ... ${ res.type}`);
			        }
			},
			(error) => {
				if(self.displayReturn === true) {
					console.log(`an error occured status: ${ error.status}`);
					console.log(`answer: ${ JSON.stringify(error, null, 2)}`);
				}
				reject({ status:error.status, data:error.error });
			});

			/*

			      switch (event.type) {

			        case HttpEventType.UploadProgress:
			          const progress = Math.round(100 * event.loaded / event.total);
			          return { status: 'progress', message: progress };

			        case HttpEventType.Response:
			          return event.body;
			        default:
			          return `Unhandled event: ${event.type}`;
			      }
			    })
			    );
			    */
		});
	}
	put(uriRest:string, headerOption:any, data:any) {
		this.addTokenIfNeeded(headerOption);
		let connectionAdresse = this.createRESTCall(uriRest, {});
		const httpOption = {
			headers: new HttpHeaders(headerOption)
		};
		return new Promise((resolve, reject) => {
			if(this.displayReturn === true) {
				console.log(`call POST ${ connectionAdresse } data=${ JSON.stringify(data, null, 2)}`);
			}
			let request = this.http.put<any>(connectionAdresse, data, httpOption);
			let self = this;
			request.subscribe((res: any) => {
				if(self.displayReturn === true) {
					console.log(`!! data ${ JSON.stringify(res, null, 2)}`);
				}
				if(res) {
					if(res.httpCode) {
						resolve({ status:res.httpCode, data:res });
					} else {
						resolve({ status:200, data:res });
					}
				} else {
					resolve({ status:200, data:'' });
				}
			},
			(error) => {
				if(self.displayReturn === true) {
					console.log(`an error occured status: ${ error.status}`);
					console.log(`answer: ${ JSON.stringify(error, null, 2)}`);
				}
				reject({ status:error.status, data:error.error });
			});
		});
	}
	delete(uriRest:string, headerOption:any) {
		this.addTokenIfNeeded(headerOption);
		let connectionAdresse = this.createRESTCall(uriRest, {});
		const httpOption = {
			headers: new HttpHeaders(headerOption)
		};
		return new Promise((resolve, reject) => {
			if(this.displayReturn === true) {
				console.log(`call POST ${ connectionAdresse}`);
			}
			let request = this.http.delete<any>(connectionAdresse, httpOption);
			let self = this;
			request.subscribe((res: any) => {
				if(self.displayReturn === true) {
					console.log(`!! data ${ JSON.stringify(res, null, 2)}`);
				}
				if(res) {
					if(res.httpCode) {
						resolve({ status:res.httpCode, data:res });
					} else {
						resolve({ status:200, data:res });
					}
				} else {
					resolve({ status:200, data:'' });
				}
			},
			(error) => {
				if(self.displayReturn === true) {
					console.log(`an error occured status: ${ error.status}`);
					console.log(`answer: ${ JSON.stringify(error, null, 2)}`);
				}
				reject({ status:error.status, data:error.error });
			});
		});
	}

	uploadFileMultipart(base:string, id:number, file:File): any {
		console.log(`Upload file to ${ base}`);

		let url = base;
		if(id !== null) {
			url = `${url }/${ id}`;
		}
		let formData = new FormData();
		formData.append('upload', file);
		let headers = new Headers();
		console.log(`upload filename : ${ file.name}`);
		let extention = file.name.split('.').pop();
		if(extention === 'jpg') {
			headers.append('Content-Type', 'image/jpeg');
		} else if(extention === 'png') {
			headers.append('Content-Type', 'image/png');
		} else if(extention === 'mkv') {
			headers.append('Content-Type', 'video/x-matroska');
		} else if(extention === 'webm') {
			headers.append('Content-Type', 'video/webm');
		} else {
			return null;
		}
		headers.append('filename', file.name);

		const httpOption = {
			headers: headers,
			reportProgress: true,
		};
		return new Promise((resolve, reject) => {
			this.post(url, httpOption, formData)
				.then((response: any) => {
					console.log(`URL: ${ url }\nRespond(${ response.status }): ${ JSON.stringify(response.data, null, 2)}`);
					if(response.status === 200) {
						resolve(response.data);
						return;
					}
					reject('An error occured');
				}, (response: any) => {
					if(typeof response.data === 'undefined') {
						reject('return ERROR undefined');
					} else {
						reject(`return ERROR ${ JSON.stringify(response.data, null, 2)}`);
					}
				});
		});
	}
	uploadFileBase64(base:string, id:number, file:File): any {
		console.log(`Upload file to ${ base}`);

		let url = base;
		if(id !== null) {
			url = `${url }/${ id}`;
		}
		let self = this;
		let reader = new FileReader();
		reader.readAsArrayBuffer(file);
		return new Promise((resolve, reject) => {
			reader.onload = () => {
				let headers:any = {};// new Headers();
				console.log(`upload filename : ${ file.name}`);
				let extention = file.name.split('.').pop();
				if(extention === 'jpg') {
					// headers.append('Content-Type', "image/jpeg");
					headers['Content-Type'] = 'image/jpeg';
					headers['mime-type'] = 'image/jpeg';
				} else if(extention === 'jpeg') {
					// headers.append('Content-Type', "image/jpeg");
					headers['Content-Type'] = 'image/jpeg';
					headers['mime-type'] = 'image/jpeg';
				} else if(extention === 'webp') {
					// headers.append('Content-Type', "image/webp");
					headers['Content-Type'] = 'image/webp';
					headers['mime-type'] = 'image/webp';
				} else if(extention === 'png') {
					// headers.append('Content-Type', "image/png");
					headers['Content-Type'] = 'image/png';
					headers['mime-type'] = 'image/png';
				} else if(extention === 'mkv') {
					headers['Content-Type'] = 'video/x-matroska';
					headers['mime-type'] = 'video/x-matroska';
				} else if(extention === 'webm') {
					headers['Content-Type'] = 'video/webm';
					headers['mime-type'] = 'video/webm';
				} else {
					return null;
				}
				// headers.append('filename', file.name);
				headers.filename = file.name;

				self.post(url, headers, reader.result)
					.then((response: any) => {
						console.log(`URL: ${ url }\nRespond(${ response.status }): ${ JSON.stringify(response.data, null, 2)}`);
						if(response.status === 200) {
							resolve(response.data);
							return;
						}
						reject('An error occured');
					}, (response: any) => {
						if(typeof response.data === 'undefined') {
							reject('return ERROR undefined');
						} else {
							reject('return ERROR ...');// + JSON.stringify(response, null, 2));
						}
					});
			};
		});
	}
	uploadFile(base:string, file:File): any {
		console.log(`Upload file to ${ base}`);

		let url = base;
		let self = this;
		let reader = new FileReader();
		reader.readAsArrayBuffer(file);
		return new Promise((resolve, reject) => {
			reader.onload = () => {
				let headers: any = {};// new Headers();
				console.log(`upload filename : ${ file.name}`);
				let extention = file.name.split('.').pop();
				if(extention === 'jpg') {
					// headers.append('Content-Type', "image/jpeg");
					headers['Content-Type'] = 'image/jpeg';
					headers['mime-type'] = 'image/jpeg';
				} else if(extention === 'jpeg') {
					// headers.append('Content-Type', "image/jpeg");
					headers['Content-Type'] = 'image/jpeg';
					headers['mime-type'] = 'image/jpeg';
				} else if(extention === 'webp') {
					// headers.append('Content-Type', "image/webp");
					headers['Content-Type'] = 'image/webp';
					headers['mime-type'] = 'image/webp';
				} else if(extention === 'png') {
					// headers.append('Content-Type', "image/png");
					headers['Content-Type'] = 'image/png';
					headers['mime-type'] = 'image/png';
				} else if(extention === 'mkv') {
					headers['Content-Type'] = 'video/x-matroska';
					headers['mime-type'] = 'video/x-matroska';
				} else if(extention === 'webm') {
					headers['Content-Type'] = 'video/webm';
					headers['mime-type'] = 'video/webm';
				} else {
					return null;
				}
				// headers.append('filename', file.name);
				headers.filename = file.name;

				self.post(url, headers, reader.result)
					.then((response: any) => {
						console.log(`URL: ${ url }\nRespond(${ response.status }): ${ JSON.stringify(response.data, null, 2)}`);
						if(response.status === 200) {
							resolve(response.data);
							return;
						}
						reject('An error occured');
					}, (response: any) => {
						if(typeof response.data === 'undefined') {
							reject('return ERROR undefined');
						} else {
							reject('return ERROR ...');// + JSON.stringify(response, null, 2));
						}
					});
			};
		});
	}
	uploadMultipart(base:string, multipart:FormData, progress:any): any {
		console.log(`Upload multipart to ${ base}`);

		let url = base;
		let self = this;
		return new Promise((resolve, reject) => {
			let headers = {
				// 'Content-Type': 'multipart/form-data',
			};// new Headers();

			self.post(url, headers, multipart, progress)
				.then((response: any) => {
					console.log(`URL: ${ url }\nRespond(${ response.status }): ${ JSON.stringify(response.data, null, 2)}`);
					if(response.status >= 200 && response.status <= 299) {
						resolve(response.data.body);
						return;
					}
					reject('An error occured');
				}, (response: any) => {
					if(typeof response.data === 'undefined') {
						reject('return ERROR undefined');
					} else {
						reject('return ERROR ...');// + JSON.stringify(response, null, 2));
					}
				});
		});
	}

	/*
	public upload(base:string, id:number, file:File): any {
		data, userId) {
	}
	    let uploadURL = `${this.SERVER_URL}/auth/${userId}/avatar`;

	    return this.http.post<any>(uploadURL, data, {
	      reportProgress: true,
	      observe: 'events'
	    }).pipe(map((event) => {

	      switch (event.type) {

	        case HttpEventType.UploadProgress:
	          const progress = Math.round(100 * event.loaded / event.total);
	          return { status: 'progress', message: progress };

	        case HttpEventType.Response:
	          return event.body;
	        default:
	          return `Unhandled event: ${event.type}`;
	      }
	    })
	    );
	  }
	*/
	// Complex wrapper to simplify interaction:
	getSpecific(base:string, id:number = null, subElement:string = '', select:string[] = []):any {
		console.log(`Get All data from ${ base}`);
		const httpOption = { 'Content-Type': 'application/json' };
		let url = base;
		if(id !== null) {
			url = `${url }/${ id}`;
		}
		if(subElement !== '') {
			url = `${url }/${ subElement}`;
		}
		if(select.length !== 0) {
			let newValue = '';
			for(let iii = 0; iii < select.length; iii++) {
				if(select.length !== 0) {
					newValue = `${newValue}&`;
				}
				newValue = `${newValue}select=${select[iii]}`;
			}
			url = `${url}?${newValue}`;
		}
		// console.log("call GET " + url);

		return new Promise((resolve, reject) => {
			this.get(url, httpOption, {})
				.then((response: any) => {
					// console.log("URL: " + url + "\nRespond(" + response.status + "): " + JSON.stringify(response.data, null, 2));
					if(response.status === 200) {
						resolve(response.data);
						return;
					}
					reject('An error occured');
				}, (response: any) => {
					if(typeof response.data === 'undefined') {
						reject('return ERROR undefined');
					} else {
						reject(`return ERROR ${ JSON.stringify(response.data, null, 2)}`);
					}
				});
		});
	}

	// Complex wrapper to simplify interaction:
	deleteSpecific(base:string, id:number, subElement:string = ''):any {
		// console.log("delete data to " + base);
		const httpOption = { 'Content-Type': 'application/json' };
		let url = base;
		if(id !== null) {
			url = `${url }/${ id}`;
		}
		if(subElement !== '') {
			url = `${url }/${ subElement}`;
		}
		// console.log("call DELETE: " + url);
		// console.log("    data: " + JSON.stringify(data, null, 2));

		return new Promise((resolve, reject) => {
			this.delete(url, httpOption)
				.then((response: any) => {
					// console.log("URL: " + url + "\nRespond(" + response.status + "): " + JSON.stringify(response.data, null, 2));
					if(response.status === 200) {
						resolve(response.data);
						return;
					}
					if(response.status === 201) {
						resolve(response.data);
						return;
					}
					reject('An error occured');
				}, (response: any) => {
					if(typeof response.data === 'undefined') {
						reject('return ERROR undefined');
					} else {
						reject(`return ERROR ${ JSON.stringify(response.data, null, 2)}`);
					}
				});
		});
	}
	// Complex wrapper to simplify interaction:
	putSpecific(base:string, id:number, data:any, subElement:string = ''):any {
		// console.log("put data to " + base);
		const httpOption = { 'Content-Type': 'application/json' };
		let url = base;
		if(id !== null) {
			url = `${url }/${ id}`;
		}
		if(subElement !== '') {
			url = `${url }/${ subElement}`;
		}
		// console.log("call PUT: " + url);
		// console.log("    data: " + JSON.stringify(data, null, 2));

		return new Promise((resolve, reject) => {
			this.put(url, httpOption, data)
				.then((response: any) => {
					// console.log("URL: " + url + "\nRespond(" + response.status + "): " + JSON.stringify(response.data, null, 2));
					if(response.status === 200) {
						resolve(response.data);
						return;
					}
					if(response.status === 201) {
						resolve(response.data);
						return;
					}
					reject('An error occured');
				}, (response: any) => {
					if(typeof response.data === 'undefined') {
						reject('return ERROR undefined');
					} else {
						reject(`return ERROR ${ JSON.stringify(response.data, null, 2)}`);
					}
				});
		});
	}
	// Complex wrapper to simplify interaction:
	postSpecific(base:string, id:number, data:any, subElement:string = ''):any {
		// console.log("put data to " + base);
		const httpOption = { 'Content-Type': 'application/json' };
		let url = base;
		if(id !== null) {
			url = `${url }/${ id}`;
		}
		if(subElement !== '') {
			url = `${url }/${ subElement}`;
		}
		// console.log("call PUT: " + url);
		// console.log("    data: " + JSON.stringify(data, null, 2));

		return new Promise((resolve, reject) => {
			this.post(url, httpOption, data)
				.then((response: any) => {
					// console.log("URL: " + url + "\nRespond(" + response.status + "): " + JSON.stringify(response.data, null, 2));
					if(response.status === 200) {
						resolve(response.data);
						return;
					}
					if(response.status === 201) {
						resolve(response.data);
						return;
					}
					reject('An error occured');
				}, (response: any) => {
					if(typeof response.data === 'undefined') {
						reject('return ERROR undefined');
					} else {
						reject(`return ERROR ${ JSON.stringify(response.data, null, 2)}`);
					}
				});
		});
	}
}