import { Injectable, isDevMode } from '@angular/core';
import {HttpClient, HttpHeaders} from '@angular/common/http';
import {LocalStorageService} from 'angular-2-local-storage';
import {Observable} from 'rxjs';
import {ErrorComponent} from '../error/error.component';
import {ModalService} from '@inst-iot/bosch-angular-ui-components';


@Injectable({
	providedIn: 'root'
})
export class ApiService {

	private host: string;

		constructor(
			private http: HttpClient,
			private storage: LocalStorageService,
			private modalService: ModalService,
			private window: Window
	) {
		if(isDevMode())
			this.host = '/api';
		else if(window.location.hostname === 'definma-test.apps.de1.bosch-iot-cloud.com')
			this.host = 'https://definma-api-test.apps.de1.bosch-iot-cloud.com';
		else
			this.host = 'https://definma-api.apps.de1.bosch-iot-cloud.com';
	}

	get hostName() {
		return this.host;
	}

	// Main HTTP methods
	get<T>(url, f: (data?: T, err?, headers?) => void = () => {}) {
		this.requestErrorHandler<T>(this.http.get(this.url(url), this.options()), f);
	}

	post<T>(url, data = null, f: (data?: T, err?, headers?) => void = () => {}) {
		this.requestErrorHandler<T>(this.http.post(this.url(url), data, this.options()), f);
	}

	put<T>(url, data = null, f: (data?: T, err?, headers?) => void = () => {}) {
		this.requestErrorHandler<T>(this.http.put(this.url(url), data, this.options()), f);
	}

	delete<T>(url, f: (data?: T, err?, headers?) => void = () => {}) {
		this.requestErrorHandler<T>(this.http.delete(this.url(url), this.options()), f);
	}

	// Execute request and handle errors
	private requestErrorHandler<T>(observable: Observable<any>, f: (data?: T, err?, headers?) => void) {
		observable.subscribe(data => {  // Successful request
			f(
				data.body,
				undefined,
				data.headers.keys().reduce((s, e) => {s[e.toLowerCase()] = data.headers.get(e); return s; }, {})
			);
		}, err => {  // Error
			if (f.length > 1) {  // Pass on error
				f(undefined, err, undefined);
			}
			else {  // Handle directly
				this.requestError(err);
			}
		});
	}

	requestError(err) {  // Network error dialog
		const modalRef = this.modalService.openComponent(ErrorComponent);
		modalRef.instance.message = 'Network request failed!';
		const details = [err.error.status];
		if (err.error.details) {
			details.push(err.error.details);
		}
		modalRef.instance.details = details;
		modalRef.result.then(() => {
			this.window.location.reload();
		});
	}

	private url(url) {  // Detect if host was given, otherwise use default host
		if (/http[s]?:\/\//.test(url)) {
			return url;
		}
else {
	return this.host + url;
}
	}

	// Generate request options
	private options(): {headers: HttpHeaders, observe: 'body'} {
		return {headers: this.authOptions(), observe: 'response' as 'body'};
	}

	// Generate Basic Auth
	private authOptions(): HttpHeaders {
		const auth = this.storage.get('basicAuth');
		if (auth) {
			return new HttpHeaders({Authorization: 'Basic ' + auth});
		}
		else {
			return new HttpHeaders();
		}
	}
}