import { put, take, all, select, spawn, race, call, fork} from 'redux-saga/effects'

import { delay } from 'redux-saga';

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

import { getLastSync } from '../selectors/syncSelectors';

import { getOnline } from '../selectors/authSelectors';

import moment from 'moment';

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

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

import { groupLoadAsync } from '../actions/groupActions';

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* doLoadGroup() {

  yield put(groupLoadAsync());

}

function* watchDoSync(context) {

  while (true) {

    yield take(types.SYNC_DO_SYNC);

    yield spawn(doSync, context); //we use spawn + take, because we do not want it to be interupted

    yield fork(doLoadGroup);

    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()

  ]);

}