public getJwt(): any {
    var jwtHelper = new JwtHelper();
    var encodedToken = window.localStorage.getItem('jwt');
    var jwt = jwtHelper.decodeToken(encodedToken);

    return jwt;
  }

 isTokenValid(token: string): Boolean {
 //   auth0 = new auth0.WebAuth({
 //   clientID: AUTH_CONFIG.CLIENT_ID,
 //   domain: AUTH_CONFIG.CLIENT_DOMAIN
 // });
   const jwtHelper: JwtHelper = new JwtHelper();
   return jwtHelper.isTokenExpired(token);
 }

  // Checks for token expiration to display appropriate page
  ngOnInit() {
  var jwtHelper = new JwtHelper();
  var token = localStorage.getItem('auth_token');
  if (token) {
    console.log(jwtHelper.isTokenExpired(token));
    if (jwtHelper.isTokenExpired(token)) {
    this.router.navigate(['/']);
    } else {
    this.router.navigate(['/home']);
    }
  } else {
    this.router.navigate(['/']);
  }

  }

	public static tokenNotExpired(tokenName?: string, jwt?: string) {

		var authToken: string = tokenName || 'id_token';
		var token: string;

		if (jwt) {
			token = jwt;
		} else {
			token = localStorage.getItem(authToken);
		}

		var jwtHelper = new JwtHelper();

		if (!token || jwtHelper.isTokenExpired(token, null)) {
			return false;
		} else {
			return true;
		}
	}

 constructor(public router: Router, public http: Http, public authHttp: AuthHttp) {
   let timer = Observable.timer(2000, 1000);
   let jwtHelper: JwtHelper = new JwtHelper();
   timer.subscribe(t => {
     var token = jwtHelper.decodeToken(localStorage.getItem('id_token'));
     if (token) {
       this.tokenExpires = ((token.exp * 1000) - Number(new Date()));
       this.tokenExpired = this.tokenExpires <= 0;
       if (this.tokenExpires > -5000 && this.tokenExpires < 2000) {
         this.refreshToken();
       }
     }
   });
 }

    constructor(private _httpClient: HttpClient,
                private _notificationService: NotificationService) {
        this.baseUrl = API_ENDPOINT.concat('/auth/local/');
		console.log(`baseurl : ${this.baseUrl}`)
        this.jwtHelper = new JwtHelper();
        //the user doesn't need to login as long as the token is valid
        if (tokenNotExpired()) {
            let idToken = localStorage.getItem('id_token');
            let token = this.jwtHelper.decodeToken(idToken);
            this.currentUser = new User();
            this.currentUser._id = token._id;
            this.currentUser.name = token.name;
            this.currentUser.role = token.role;
			console.log(`existing token - ${this.currentUser.name}`);	
        }

    }

 constructor(public router: Router, public http: Http, public authHttp: AuthHttp,
 public jwtHelper: JwtHelper, private userService: UserService) {
     this.jwt = localStorage.getItem('jwt');
     this.decodedJwt = this.jwt && this.jwtHelper.decodeToken(this.jwt);
     this.user = this.userService.getCurrentUser();
 }

  canActivate() {
    var token = localStorage.getItem("jwt");
 
    if (token && !this.jwtHelper.isTokenExpired(token)){
        console.log(this.jwtHelper.decodeToken(token));
        return true;
    }
    this.router.navigate(["login"]);
    return false;
  }

		tokenGetter: () => {
			// Look in session storage for id_token, but fallback to local storage
			let session = sessionStorage.getItem('id_token');
			let local = localStorage.getItem('id_token');

			let token = session || local;

			if (typeof token !== 'string') { return ''; }

			// Remove any quotations from the sides
			token = token.split('"').join('');

			// Check validity of jwt token
			if (token.split('.').length !== 3) {
				localStorage.removeItem('id_token');
				sessionStorage.removeItem('id_token');
				return '';
			}

			// Check if token is expired. If it is, delete and send user to login page
			if (jwtHelper.isTokenExpired(token)) {
				sessionStorage.removeItem('id_token');
				localStorage.removeItem('id_token');

				this.router.navigate(['/login']);
				return '';
			}

			return token;
		},

            .mergeMap((token) => {
                const decodedToken = this.jwtHelper.decodeToken(token);

                return Observable.interval(
                    new Date(0).setUTCSeconds(decodedToken.exp) - new Date(0).setUTCSeconds(decodedToken.iat)
                );
            })

 this.authProvider.authUser.subscribe(jwt => {
   if (jwt) {
     const decoded = this.jwtHelper.decodeToken(jwt);
     this.user = decoded.sub
   }
   else {
     this.user = null;
   }
 });

  canActivate(next: ActivatedRouteSnapshot, state: RouterStateSnapshot) {
    if (window.localStorage.getItem('token') &&
      !jwtHelper.isTokenExpired(window.localStorage.getItem('token'))) {
      return true;
    }

    this.router.navigate(['login']);
    return false;
  }

 getUserName(): string {
   if (window.localStorage.getItem('token')) {
     let token = window.localStorage.getItem('token');
     let decoded = this.jwtHelper.decodeToken(token);
     return decoded.login
   } else {
     return "not logged in"
   }
 }

    isAuthenticated(): boolean {
        let jwt = this.jwtStorage.getToken();

        if (null === jwt) {
            return false;
        }

        return !this.jwtHelper.isTokenExpired(jwt.token);
    }

 timer.subscribe(t => {
   var token = jwtHelper.decodeToken(localStorage.getItem('id_token'));
   if (token) {
     this.tokenExpires = ((token.exp * 1000) - Number(new Date()));
     this.tokenExpired = this.tokenExpires <= 0;
     if (this.tokenExpires > -5000 && this.tokenExpires < 2000) {
       this.refreshToken();
     }
   }
 });

 private saveToken(data: any): boolean {
   if (data.status) {
     let decodedToken = this.jwtHelper.decodeToken(data.jwt);
     localStorage.setItem('profile', JSON.stringify(decodedToken));
     localStorage.setItem('id_token', data.jwt);
     return true;
   } else {
     return false;
   }
 }

 get currentUser() {
     if (this._currentUser) {
         return Promise.resolve(this._currentUser);
     } else {
         let deserializedToken = jwtHelper.decodeToken(this._store.getString('authtoken'));
         let userId = deserializedToken.sub;
         return this.get(Number(userId)).then(user => {
             this._currentUser = user;
             return user;
         });
     }
 }

    tokenDecode() {

        let token = localStorage.getItem('id_token');

        if (!token) {

            return "unathorized";
        } else {

            return this.jwtHelper.decodeToken(token);
        }
    }

 response => {
     var idToken = response.json().token;
     console.log(idToken);
     localStorage.setItem('id_token', idToken);
     let token = this.jwtHelper.decodeToken(idToken);
     console.log(token);						
     //TODO get the user from the response object;
     this.currentUser = new User();
     this.currentUser._id = token._id;
     this.currentUser.name = token.name;
     this.currentUser.role = token.role;
     observer.next('SUCCESS');
 },

	canActivate() {
		// Look in session storage for id_token, but fallback to local storage
		let session = sessionStorage.getItem('id_token');
		let local = localStorage.getItem('id_token');

		let token = session || local;

		// If there is a token, then user is logged in, otherwise redirect to login page
		if (token && !jwtHelper.isTokenExpired(token)) {
			return true;
		}

		// Delete JWT from the client just in case it was simply expired
		sessionStorage.removeItem('id_token');
		localStorage.removeItem('id_token');

		this.router.navigate(['/login']);
		return false;
	}