export function PresentationOnBreakpoint(
    breakpoints: {
        breakpoint: number;
        presentation: GridBodyPresentation
    }[]
): BehaviorSubject<GridBodyPresentation> {
    
    function getPresentation() {
        var width = window.outerWidth, i = 0;
        
        while (i < breakpoints.length - 1 && breakpoints[i + 1].breakpoint < width) {
            i++;
        }
        
        return breakpoints[i].presentation;
    }
    
    breakpoints.sort((a, b) => a.breakpoint - b.breakpoint);
    
    let subject = new BehaviorSubject<GridBodyPresentation>(getPresentation());
    
    function listener() {
        subject.next(getPresentation());
    }
    
    subject.next(getPresentation());
    
    window.addEventListener('resize', listener);
    
    return subject;
}

    constructor(private _data:DataService, private _user:UserService, private _cd:ChangeDetectorRef) {
        this.isAuth = new BehaviorSubject(false);
        this.privateData = new BehaviorSubject('');

        this.isAuth.subscribe(val => this.authStatus = val);
        this.privateData.subscribe(val => this.message = val);
    }

  constructor () {

    let windowSize$ = new BehaviorSubject(this.newWindowSize());
    this.windowObject$ = windowSize$.distinctUntilChanged();
    Observable.fromEvent(window, 'resize')
      .map(this.newWindowSize)
      .subscribe(windowSize$);

  }

 it('if not passed any rows, does nothing', (done) => {
     var selection = new BehaviorSubject<{[key: string]: string}>({});
     var doOnce = false;
     selection.subscribe(() => {
         if (!doOnce) {
             doOnce = true;
         } else {
             done.fail('Changed the selection');
         }
     });
     
     SelectionUpdateStrategies.SimpleIteration(selection, null, d => d.id);
     setTimeout(done);
 });

 this.document.addEventListener("visibilitychange", () => {
   if (document.visibilityState === "visible") {
     this.detailedFocusSubject.next(DetailedFocusStates.TabFocus);
   } else {
     this.detailedFocusSubject.next(DetailedFocusStates.TabBlur);
   }
 });

 (counties: County[]) => {
   if (!this._counties$.getValue().length) {
     counties.forEach((county: County) =>
     this._counties$.getValue().push(county));
   }
   this._counties$.next(this._counties$.getValue());
 },

 this.autobahn.onclose((reason, details) => {
   log.error(`Connection lost, reason: [${reason}]`)
   log.error(`Connection lost, details: [${JSON.stringify(details)}]`)
   this.isConnected = false
   const disconnectTimerDisposable = this.autoDisconnectDisposable
   if (disconnectTimerDisposable) {
     disconnectTimerDisposable.unsubscribe()
   }
   // if we explicitly called close then we move to ConnectionStatus.idle status
   if (reason === 'closed') {
     this.connectionStatusSubject.next(ConnectionStatus.sessionExpired)
   } else {
     this.connectionStatusSubject.next(ConnectionStatus.disconnected)
   }
 })

 ref.child(key).on('value', snapshot => {
   if (snapshot.exists()) {
     let model = snapshot.val();
     model.$key =  snapshot.key;
     return model$.next(model);
   }
 });

 this._user.auth.onAuthStateChanged(user => {
     this.isAuth.next(!!user);
     this._cd.detectChanges();
     this._data.db.child('/private').on('value', data => {
         this.privateData.next(data.val());
         this._cd.detectChanges();
     }, err => console.log(err));
 });