import { delay } from 'redux-saga';

import * as types from '../constants/actionTypes';

import { getLastSync, getOnline } from './selectors';

import moment from 'moment';

import { startSynchronize, endSynchronize, updateLastSync } from '../actions/syncActions';

import { forceSync } from '../actions/networkActions';

import SessionSynchronizer from './SessionSyncronizer';

import NoteSynchronizer from './NoteSyncronizer';

import config from '../config';

function* doSync(context) {

    const online = yield select(getOnline);

    if(!online) {

      yield put(endSynchronize());

      return;

    }

    const lastSync = yield select(getLastSync);

    yield put(startSynchronize());

    const nextLastSync = moment().unix()

    // TODO: manage errors

    try {

      const syncObjects = yield context.client.get('/api/notes/sync/', { modified_since: lastSync });

      const sessionSynchronizer = new SessionSynchronizer(syncObjects.sessions, context.client);

      yield sessionSynchronizer.syncObjects();

      const noteSynchronizer = new NoteSynchronizer(syncObjects.notes, context.client);

      yield noteSynchronizer.syncObjects();

      yield put(updateLastSync(nextLastSync));

    } finally {

      yield put(endSynchronize());

    }

}

function* watchDoSync(context) {

  while (true) {

    yield take(types.SYNC_DO_SYNC);

    yield take(types.SYNC_END_SYNC);

  }

}

function* delayPutDoSync() {

  yield put(forceSync());

  yield call(delay, config.syncInterval);

}

function* loopDoSync() {

  while(true) {

    const online = yield select(getOnline);

    if(!online) {

      yield take(types.STATUS_ONLINE);

    }

    yield race({

      delaySync: call(delayPutDoSync),

      offline: take(types.STATUS_OFFLINE)

    });

  }

}

//--- The root saga

export default function* rootSaga(context) {

  yield all([

    watchDoSync(context),

    loopDoSync()

  ]);

}