import * as types from '../constants/actionTypes';
import { all, call, fork, race, take, cancelled, put, select } from 'redux-saga/effects'
import config from '../config';
import jwt_decode from 'jwt-decode';
import moment from 'moment';
import { delay } from 'redux-saga';
import { setOnlineStatus } from '../actions/networkActions';
import { getToken } from '../selectors/authSelectors';



function pingServer(client, token) {
  const decodedToken = jwt_decode(token);
  const currentTs = moment.now()/1000;

  const timeout = new Promise((resolve, reject) => {
    setTimeout(reject, config.networkStatusTimeout, 'request timed out');
  });

  if((decodedToken.exp-currentTs) < 300) {
    return Promise
      .race([timeout, client.post('/api/auth/refresh/', { token })]);
  } else {
    // We do a GET because a HEAD generate a preflight CORS OPTION request. The GET does not.
    return Promise
      .race([timeout, client.get('/api/auth/user/')]);
  }
}

function* pollData(context) {
  const token = yield select(getToken);
  // No token : we wait for a login
  if(!token) {
    yield take(types.AUTH_LOGIN_SUCCESS);
  }
  try {
    const res = yield pingServer(context.client, token);
    yield put(setOnlineStatus(true));
    if(res.token) {
      yield put({
        type: types.AUTH_STORE_TOKEN_ASYNC,
        token: res.token,
      });
    }
  } catch (error) {
    yield put(setOnlineStatus(false));
    //TODO: This is ugly...
    const data = error.data;
    if ((data && data.non_field_errors &&
      data.non_field_errors &&
      data.non_field_errors.length &&
      data.non_field_errors.length > 0 &&
      ( data.non_field_errors[0] === 'Signature has expired.' ||
        data.non_field_errors[0] === 'Refresh has expired.' )) ||
      (error.detail && (
        error.detail === 'Signature has expired.' ||
        error.detail=== 'Refresh has expired.'
      ))
    ) {
      yield put({
        type: types.AUTH_DEAUTHENTICATE
      });
    }
  } finally {
    if (yield cancelled()) {
      // pollDate cancelled
      // if there is a token : this was a LOGIN, set status to ok
      // if there is no token : this was a LOGOUT, set status to ko and wait for login
      const token = yield select(getToken);
      yield put(setOnlineStatus(Boolean(token)));
    }
  }
}

function* callDelay(context) {
  try {
    yield call(delay, config.networkStatusInterval);
  } finally {
    if (yield cancelled()) {
      // pollDate cancelled
      // if there is a token : this was a LOGIN, set status to ok
      // if there is no token : this was a LOGOUT, set status to ko and wait for login
      const token = yield select(getToken);
      yield put(setOnlineStatus(Boolean(token)));
    }
  }
}

// Wait for successful response, then fire another request
// Cancel polling if user logs out or log in
function* watchPollData(context) {
  while (true) {
    yield race({
      poll: all([call(pollData, context), call(callDelay, context)]),
      logout: take(types.AUTH_LOGOUT),
      login: take(types.AUTH_LOGIN_SUCCESS)
    });
  }
}

// Daemonize tasks in parallel
export default function* root(context) {
  yield all([
    fork(watchPollData, context)
    // other watchers here
  ]);
}