import {
  inject,
  it,
  describe,
  beforeEach,
  async,
  beforeEachProviders,
  expect
} from '@angular/core/testing';
import {provide} from '@angular/core';
import {RecordsProvider} from '../../dist/app/records/records-provider.service';
import {RecordCollection} from '../../dist/app/records/record-collection';
import {RecordStoreService} from '../../dist/app/records/record-store.service';
import {Observable} from 'rxjs/Observable';

const mockRecordsCollection = new RecordCollection({
  name: 'Collection 1',
  label: 'Collection 1'
});

class MockRecordStore {
  put() {}
  remove() {}
  allDocs() {
    const obs = Observable.of([mockRecordsCollection]).publishReplay();
    obs.connect();
    return obs;
  }
}

describe('Records Provider', () => {
  let recordsProvider: RecordsProvider;
  let recordStore: RecordStoreService;

  beforeEachProviders(() => {
    return [
      RecordsProvider,
      provide(RecordStoreService, {useClass: MockRecordStore})
    ];
  });

  beforeEach(async(
    inject(
      [RecordsProvider, RecordStoreService],
      (rp: RecordsProvider, rs: RecordStoreService) => {
        recordsProvider = rp;
        recordStore = rs;

        spyOn(rs, 'put');
        spyOn(rs, 'allDocs');
      }
    )
  ));

  it('add new collections by wrapping them in observables and storing them',
     done => {
      const testCollection = new RecordCollection({name: 'New Collection'});
      const observable = recordsProvider.add(testCollection);

      expect(recordStore.put).toHaveBeenCalled();
      expect(recordsProvider.sources).toContain(observable);

      observable.subscribe(col => {
        expect(col).toBe(testCollection);
        done();
      });
     }
  );

  it('add new sources', done => {
    const testCollection = new RecordCollection({name: 'New Collection'});
    const testObservable = Observable.create(obs => obs.next(testCollection));
    const observable = recordsProvider.addSource(testObservable);

    expect(recordsProvider.sources).toContain(observable);
    observable.subscribe(col => {
      expect(col).toBe(testCollection);
      done();
    });
  });

  it('remove sources', done => {
    const testCollection = new RecordCollection({name: 'New Collection'});
    const observable = recordsProvider.add(testCollection);

    expect(recordsProvider.sources).toContain(observable);
    recordsProvider.removeSource(observable);
    expect(recordsProvider.sources).not.toContain(observable);

    done();
  });

  it('should cast newly added sources to subscribers', done => {
    const testCollection = new RecordCollection({name: 'New Collection'});

    recordsProvider.sourceAdded.subscribe(source => {
      expect(recordsProvider.sources).toContain(source);
      source.subscribe(col => {
        expect(col).toBe(testCollection);
        done();
      });
    });

    recordsProvider.add(testCollection);
  });

  it('should cast newly removed sources to subscribers', done => {
    const testCollection = new RecordCollection({name: 'New Collection'});
    const source = recordsProvider.add(testCollection);

    recordsProvider.sourceRemoved.subscribe(src => {
      expect(recordsProvider.sources).not.toContain(src);
      expect(src).toBe(source);

      src.subscribe(col => {
        expect(col).toBe(testCollection);
        done();
      });
    });

    recordsProvider.removeSource(source);
  });
});