FutureImpl()
  : _successListeners = [],
    _exceptionHandlers = [],
    _completionListeners = [];

factory FutureImpl.immediate(T value) {
  final res = new FutureImpl();
  res._setValue(value);
  return res;
}

Future chain(Function transformation) {
  final completer = new Completer();
  handleException((e) {
    completer.completeException(e, this.stackTrace);
    return true;
  });
  then((v) {
    var future = null;
    try {
      future = transformation(v);
    } catch (final ex, final stackTrace) {
      completer.completeException(ex, stackTrace);
      return;
    }
    future.handleException((e) {
      completer.completeException(e, future.stackTrace);
      return true;
    });
    future.then((b) => completer.complete(b));
  });
  return completer.future;
}

Object get exception() {
  if (!isComplete) {
    throw new FutureNotCompleteException();
  }
  return _exception;
}

void handleException(bool onException(Object exception)) {
  if (_exceptionHandled) return;
  if (_isComplete) {
     if (_exception != null) {
       _exceptionHandled = onException(_exception);
     }
  } else {
    _exceptionHandlers.add(onException);
  }
}

bool get hasValue() {
  return isComplete && _exception === null;
}

bool get isComplete() {
  return _isComplete;
}

void onComplete(void complete(Future<T> future)) {
  if (_isComplete) {
    try {
      complete(this);
    } catch (final e) {}
  } else {
    _completionListeners.add(complete);
  }
}

Object get stackTrace() {
  if (!isComplete) {
    throw new FutureNotCompleteException();
  }
  return _stackTrace;
}

void then(void onSuccess(T value)) {
  if (hasValue) {
    onSuccess(value);
  } else if (!isComplete) {
    _successListeners.add(onSuccess);
  } else if (!_exceptionHandled) {
    throw _exception;
  }
}

Future transform(Function transformation) {
  final completer = new Completer();
  handleException((e) {
    completer.completeException(e, this.stackTrace);
    return true;
  });
  then((v) {
    var transformed = null;
    try {
      transformed = transformation(v);
    } catch (final ex, final stackTrace) {
      completer.completeException(ex, stackTrace);
      return;
    }
    completer.complete(transformed);
  });
  return completer.future;
}

T get value() {
  if (!isComplete) {
    throw new FutureNotCompleteException();
  }
  if (_exception !== null) {
    throw _exception;
  }
  return _value;
}