export const authorize = (to: ComponentInstruction, from: ComponentInstruction, params: Object = {}) =>
{
  let injector: Injector = appInjector();
  //let router: Router = injector.get(Router);
  let user$: Observable<User> = injector.get(UserService).user$
  let projects$: Observable<Array<Project>> = injector.get(ProjectsService).projects$

  // checks
  let authorized = false;
  let checkToken = tokenNotExpired(null, localStorage.getItem('token'))
  let checkRole$ = user$.map(user => user.role === 'admin' || user.role === params['checkRole'])
  let checkGroup$ = projects$
    .flatMap(project => project)
    .filter(project => project.url === to.urlPath)
    .zip(user$)
    .map(merged => merged[0].groups.map(projectsGroup => merged[1].groups.indexOf(projectsGroup) !== -1))
    .flatMap(merged => merged)

  Observable
    .merge(checkRole$, checkGroup$)
    .filter(check => check === true)
    .subscribe
    (
      (check: boolean) => authorized = check,
      err => console.error // maybe redirect to custom 4xx page here...
    )

  return new Promise((resolve) => resolve(checkToken && authorized))
}

 beforeEach(() => {
   injector = Injector.resolveAndCreate([
     TestService,
     provideStore({test}, {}),
   ]);
   testService = injector.get(TestService);
 });

export function useInjector() {
  var injector:Injector;

//#enddocregion injector
/*
//#docregion injector-no-new
  // Cannot 'new' an Injector like this!
  var injector = new Injector([Car, Engine, Tires, Logger]);
//#enddocregion injector-no-new
*/

//#docregion injector
  //#docregion injector-create-and-call
  injector = Injector.resolveAndCreate([Car, Engine, Tires, Logger]);
  //#docregion injector-call
  var car = injector.get(Car);
 //#enddocregion injector-call
 //#enddocregion injector-create-and-call
  car.description = 'Injector';

  var logger = injector.get(Logger);
  logger.log('Injector car.drive() said: '+car.drive());

  return car;
}

	beforeEach(() => {
		injector = Injector.resolveAndCreate([
			BaseRequestOptions,
			MockBackend,
			provide(Http, {
				useFactory: (connectionBackend: ConnectionBackend, defaultOptions: BaseRequestOptions) => {
					return new Http(connectionBackend, defaultOptions);
				},
				deps: [
					MockBackend,
					BaseRequestOptions
				]
			}),
			provide(Icon, {
				useFactory: (http: Http) => {
					return new Icon(http);
				},
				deps: [
					Http
				]
			})
		]);
		backend = injector.get(MockBackend);
		store = injector.get(Icon);
		response = new Response(
			new ResponseOptions({body: SVG_GLYPH_HTML})
		);
		glyph = createGlyphNode();
	});

export const checkAuth = (next: ComponentInstruction, previous: ComponentInstruction) => {
    let injector: Injector = appInjector(); // get the stored reference to the injector
    let auth: Auth = injector.get(Auth);
    let router: Router = injector.get(Router);
    let location: Location = injector.get(Location);

    // return a boolean or a promise that resolves a boolean
    return new Promise((resolve, reject) => {

        if (auth.check()) {
            // already login, redirect to default page
            if (next.urlPath == 'login' || next.urlPath == 'signup') {
                router.navigate(['/Home']);	// r
                // window.location.href = 'index.html';
                resolve(false);
            }
            // show the page
            else {
                resolve(true);
            }
        } else {
            // not login; show the login page
            if (next.urlPath == 'login' || next.urlPath == 'signup') {
                resolve(true);
            }
            // restrict the page
            else {
                router.navigate(['/Login']); // r
                // window.location.href = 'login.html';
                resolve(false);
            }
        }
    });
};

  beforeEach(() => {
    injector = Injector.resolveAndCreate([
      DB.DB_PROVIDERS,
      DB.provideDB(todoAppSchema)
    ]);

    idb = injector.get(DB.Database);
  });

 constructor( private name: string) {
   console.log('component');
   console.log(this.name);
   
   let injector:Injector = appInjector();
   this.svc = injector.get(NavService);
   console.log(this.svc);
 }

    beforeEach(() => {

      injector = Injector.resolveAndCreate([
        provideStore({ counter1: counterReducer, counter2: counterReducer }, { counter1: 0, counter2: 1 })
      ]);

      store = injector.get(Store);
    });

	static isAuthorized() {
		let injector: Injector = appInjector()
		let router: Router = injector.get(Router)

		return new Promise((resolve) => {
			if(!UserService.isAuthenticated()) {
				router.navigate(['Login'])
			}
			resolve(UserService.isAuthenticated())
		})
	}

 beforeEach(() => {
     injector = Injector.resolveAndCreate([
         HTTP_PROVIDERS,
         GithubComponent,
         GithubService,
         Config
     ]);
     component = injector.get(GithubComponent);
     service = injector.get(GithubService);
     sinon.spy(service, "searchRepositories");
 });