export async function watchHeadingAsync(callback: HeadingCallback): Promise<object> {
  // Check if there is already a compass event watch.
  if (headingEventSub) {
    _removeHeadingWatcher(headingId);
  }

  headingEventSub = LocationEventEmitter.addListener(
    'Exponent.headingChanged',
    ({ watchId, heading }: { watchId: string, heading: HeadingData }) => {
      const callback = watchCallbacks[watchId];
      if (callback) {
        callback(heading);
      } else {
        ExpoLocation.removeWatchAsync(watchId);
      }
    }
  );

  headingId = _getNextWatchId();
  watchCallbacks[headingId] = callback;
  await ExpoLocation.watchDeviceHeading(headingId);
  return {
    remove() {
      _removeHeadingWatcher(headingId);
    },
  };
}

 ({ heading }: { heading: HeadingData }) => {
   if (heading.accuracy > 1 || tries > 5) {
     resolve(heading);
     LocationEventEmitter.removeSubscription(headingSub);
   } else {
     tries += 1;
   }
 }

// Removes the compass listener and sub from JS and Native
function _removeHeadingWatcher(watchId) {
  if (!watchCallbacks[watchId]) {
    return;
  }
  delete watchCallbacks[watchId];
  ExpoLocation.removeWatchAsync(watchId);
  if (headingEventSub) {
    LocationEventEmitter.removeSubscription(headingEventSub);
    headingEventSub = null;
  }
}

function _removeWatcher(watchId) {
  // Do nothing if we have already removed the subscription
  if (!watchCallbacks[watchId]) {
    return;
  }

  ExpoLocation.removeWatchAsync(watchId);
  delete watchCallbacks[watchId];
  if (Object.keys(watchCallbacks).length === 0 && deviceEventSubscription) {
    LocationEventEmitter.removeSubscription(deviceEventSubscription);
    deviceEventSubscription = null;
  }
}

function _maybeInitializeEmitterSubscription() {
  if (!deviceEventSubscription) {
    deviceEventSubscription = LocationEventEmitter.addListener(
      'Exponent.locationChanged',
      ({ watchId, location }: { watchId: string, location: LocationData }) => {
        const callback = watchCallbacks[watchId];
        if (callback) {
          callback(location);
        } else {
          ExpoLocation.removeWatchAsync(watchId);
        }
      }
    );
  }
}

  error: TaskError | null,
  executionInfo: {
    eventId: string,
    taskName: string,
  },
}

interface RegisteredTask {
  taskName: string,
  taskType: string,
  options: any,
}

type Task = (body: TaskBody) => void;

const eventEmitter = new EventEmitter(ExpoTaskManager);
const tasks: Map<string, Task> = new Map<string, Task>();

let isRunningDuringInitialization = true;

function _validateTaskName(taskName) {
  if (!taskName || typeof taskName !== 'string') {
    throw new TypeError('`taskName` must be a non-empty string.')
  }
}

export function defineTask(taskName: string, task: Task) {
  if (!isRunningDuringInitialization) {
    console.error(`TaskManager.defineTask must be called during initialization phase!`);
    return;
  }

 removeAllListeners(): void {
   this._listenerCount = 0;
   this._nativeEmitter.removeAllListeners(this._nativeEventName);
 }

 removeSubscription(subscription: Subscription): void {
   this._listenerCount--;
   this._nativeEmitter.removeSubscription(subscription);
 }

 addListener(listener: Listener<M>): Subscription {
   let subscription = this._nativeEmitter.addListener(this._nativeEventName, listener);
   subscription.remove = () => this.removeSubscription(subscription);
   this._listenerCount++;
   return subscription;
 }