export function bootstrap(platform: PlatformRef, Ng2Module: Type<{}>, element: Element, modules: string[]) {
  // We bootstrap the Angular module first; then when it is ready (async)
  // We bootstrap the AngularJS module on the bootstrap element
  return platform.bootstrapModule(Ng2Module).then(ref => {
    const upgrade = ref.injector.get(UpgradeModule) as UpgradeModule;
    upgrade.bootstrap(element, modules);
    return upgrade;
  });
}

export function bootstrap(
    platform: PlatformRef, Ng2Module: Type<{}>, element: Element, ng1Module: angular.IModule) {
  // We bootstrap the Angular 2 module first; then when it is ready (async)
  // We bootstrap the Angular 1 module on the bootstrap element
  return platform.bootstrapModule(Ng2Module).then(ref => {
    var upgrade = ref.injector.get(UpgradeModule) as UpgradeModule;
    upgrade.bootstrap(element, [ng1Module.name]);
    return upgrade;
  });
}

export function bootstrap(
    platform: PlatformRef, Ng2Module: Type<{}>, element: Element, ng1Module: angular.IModule) {
  // We bootstrap the Angular module first; then when it is ready (async) we bootstrap the AngularJS
  // module on the bootstrap element (also ensuring that AngularJS errors will fail the test).
  return platform.bootstrapModule(Ng2Module).then(ref => {
    const upgrade = ref.injector.get(UpgradeModule);
    const failHardModule: any = ($provide: angular.IProvideService) => {
      $provide.value('$exceptionHandler', (err: any) => { throw err; });
    };
    upgrade.bootstrap(element, [failHardModule, ng1Module.name]);
    return upgrade;
  });
}

export function bootstrap(
    platform: PlatformRef, Ng2Module: Type<{}>, element: Element, ng1Module: angular.IModule) {
  // We bootstrap the Angular module first; then when it is ready (async) we bootstrap the AngularJS
  // module on the bootstrap element (also ensuring that AngularJS errors will fail the test).
  return platform.bootstrapModule(Ng2Module).then(ref => {
    const ngZone = ref.injector.get<NgZone>(NgZone);
    const upgrade = ref.injector.get(UpgradeModule);
    const failHardModule: any = ($provide: angular.IProvideService) => {
      $provide.value($EXCEPTION_HANDLER, (err: any) => { throw err; });
    };

    // The `bootstrap()` helper is used for convenience in tests, so that we don't have to inject
    // and call `upgrade.bootstrap()` on every Angular module.
    // In order to closer emulate what happens in real application, ensure AngularJS is bootstrapped
    // inside the Angular zone.
    //
    ngZone.run(() => upgrade.bootstrap(element, [failHardModule, ng1Module.name]));

    return upgrade;
  });
}

describe('angularfire', () => {
  let subscription:Subscription;
  let app: FirebaseApp;
  let rootRef: firebase.database.Reference;
  let questionsRef: firebase.database.Reference;
  let listOfQuestionsRef: firebase.database.Reference;
  let defaultPlatform: PlatformRef;

  const APP_NAME = 'super-awesome-test-firebase-app-name';

  beforeEach(() => {

    TestBed.configureTestingModule({
      imports: [AngularFireModule.initializeApp(COMMON_CONFIG, APP_NAME)]
    });

    inject([FirebaseApp, PlatformRef], (_app: FirebaseApp, _platform: PlatformRef) => {
      app = _app;
      rootRef = app.database().ref();
      questionsRef = rootRef.child('questions');
      listOfQuestionsRef = rootRef.child('list-of-questions');
      defaultPlatform = _platform;
    })();

  });

  afterEach((done) => {
    rootRef.remove()
    if(subscription && !subscription.closed) {
      subscription.unsubscribe();
    }
    app.delete().then(done, done.fail);
  });

  describe('FirebaseApp', () => {
    it('should provide a FirebaseApp for the FirebaseApp binding', () => {
      expect(typeof app.delete).toBe('function');
    });
    it('should have the provided name', () => {
      expect(app.name).toBe(APP_NAME);
    })
    it('should use an already intialized firebase app if it exists', done => {
      @NgModule({
        imports: [
          AngularFireModule.initializeApp(COMMON_CONFIG, APP_NAME),
          BrowserModule
        ]})
      class MyModule {
        ngDoBootstrap() {}
      }

      const compilerFactory: CompilerFactory =
          defaultPlatform.injector.get(CompilerFactory, null);
      const moduleFactory = compilerFactory.createCompiler().compileModuleSync(MyModule);

      defaultPlatform.bootstrapModuleFactory(moduleFactory)
        .then(moduleRef => {
          const ref = moduleRef.injector.get(FirebaseApp);
          expect(ref.name).toEqual(app.name);
        }).then(done, e => {
          fail(e);
          done()
        });
    })
  });
});

  WebAppInternals.registerBoilerplateDataCallback('angular', async (request, data) => {

    let document,
      platformRef: PlatformRef;
    // Handle Angular's error, but do not prevent client bootstrap
    try {


      document = `
        <html>
          <head>
              <base href="/">
          </head>
          <body>
              <app></app>
          </body>
        </html>
      `;

      // Integrate Angular's router with Meteor
      const url = request.url;

      // Get rendered document
      platformRef = platformDynamicServer([
        {
          provide: INITIAL_CONFIG,
          useValue: {
            // Initial document
            document,
            url
          }
        }
      ]);

      const appModuleRef = await platformRef.bootstrapModule(ServerAppModule, {
        ngZone: 'noop',
        providers: [
          {
            provide: ResourceLoader,
            useValue: {
              get: Assets.getText
            },
            deps: []
          }
        ]
      });

      const applicationRef: ApplicationRef = appModuleRef.injector.get(ApplicationRef);

      await applicationRef.isStable.pipe(
        first(isStable => isStable == true)
      ).toPromise();

      applicationRef.tick();

      // Run any BEFORE_APP_SERIALIZED callbacks just before rendering to string.
      const callbacks = appModuleRef.injector.get(BEFORE_APP_SERIALIZED, null);
      if (callbacks) {
        for (const callback of callbacks) {
          try {
            callback();
          } catch (e) {
            // Ignore exceptions.
            console.warn('Ignoring BEFORE_APP_SERIALIZED Exception: ', e);
          }
        }
      }

      const platformState: PlatformState = appModuleRef.injector.get(PlatformState);

      document = platformState.renderToString();

    } catch (e) {

      // Write errors to console
      console.error('Angular SSR Error: ' + e.stack || e);

    } finally {

      //Make sure platform is destroyed before rendering

      if (platformRef) {
        platformRef.destroy();
      }
      const head = HEAD_REGEX.exec(document)[1];
      data.dynamicHead = head;
      const body = BODY_REGEX.exec(document)[1];
      data.dynamicBody = body;

    }
  })

        .then(() => {
          const platformState = platform.injector.get(PlatformState);

          // Run any BEFORE_APP_SERIALIZED callbacks just before rendering to string.
          const callbacks = moduleRef.injector.get(BEFORE_APP_SERIALIZED, null);
          if (callbacks) {
            for (const callback of callbacks) {
              try {
                callback();
              } catch (e) {
                // Ignore exceptions.
                console.warn('Ignoring BEFORE_APP_SERIALIZED Exception: ', e);
              }
            }
          }

          const output = platformState.renderToString();
          platform.destroy();
          return output;
        });

    it('should use an already intialized firebase app if it exists', done => {
      @NgModule({
        imports: [
          AngularFireModule.initializeApp(COMMON_CONFIG, APP_NAME),
          BrowserModule
        ]})
      class MyModule {
        ngDoBootstrap() {}
      }

      const compilerFactory: CompilerFactory =
          defaultPlatform.injector.get(CompilerFactory, null);
      const moduleFactory = compilerFactory.createCompiler().compileModuleSync(MyModule);

      defaultPlatform.bootstrapModuleFactory(moduleFactory)
        .then(moduleRef => {
          const ref = moduleRef.injector.get(FirebaseApp);
          expect(ref.name).toEqual(app.name);
        }).then(done, e => {
          fail(e);
          done()
        });
    })

 .then(() => {
   const output = platform.injector.get(PlatformState).renderToString();
   platform.destroy();
   return output;
 });

 const complete = () => {
   const output = platformState.renderToString();
   platform.destroy();
   return output;
 };