export function D2FarmingService(
  $rootScope: IRootScopeService,
  $q: IQService,
  dimItemService: ItemServiceType,
  D2StoresService: StoreServiceType,
  $interval: IIntervalService,
  toaster,
  $i18next
) {
  'ngInject';

  let intervalId;
  let subscription;

  const outOfSpaceWarning = _.throttle((store) => {
    toaster.pop('info',
                $i18next.t('FarmingMode.OutOfRoomTitle'),
                $i18next.t('FarmingMode.OutOfRoom', { character: store.name }));
  }, 60000);

  function getMakeRoomBuckets() {
    return getBuckets().then((buckets) => {
      return Object.values(buckets.byHash).filter((b) => b.category === 3 && b.type);
    });
  }

  return {
    active: false,
    store: null,
    movingItems: false,
    makingRoom: false,

    // Ensure that there's one open space in each category that could
    // hold an item, so they don't go to the postmaster.
    async makeRoomForItems(store: DimStore) {
      const makeRoomBuckets = await getMakeRoomBuckets();

      // If any category is full, we'll move one aside
      let itemsToMove: DimItem[] = [];
      makeRoomBuckets.forEach((makeRoomBucket) => {
        const items = store.buckets[makeRoomBucket.id];
        if (items.length > 0 && items.length >= makeRoomBucket.capacity) {
          // We'll move the lowest-value item to the vault.
          const itemToMove = _.min(items.filter((i) => !i.equipped && !i.notransfer), (i) => {
            let value = {
              Common: 0,
              Uncommon: 1,
              Rare: 2,
              Legendary: 3,
              Exotic: 4
            }[i.tier];
            // And low-stat
            if (i.primStat) {
              value += i.primStat.value / 1000;
            }
            return value;
          });
          if (!_.isNumber(itemToMove)) {
            itemsToMove.push(itemToMove);
          }
        }
      });

      if (settings.farming.moveTokens) {
        itemsToMove = itemsToMove.concat(store.items.filter((i) => REP_TOKENS.has(i.hash)));
      }

      if (itemsToMove.length === 0) {
        return $q.resolve();
      }

      return moveItemsToVault(store, itemsToMove, makeRoomBuckets);
    },

    async farm(store: DimStore) {
      this.makingRoom = true;
      try {
        // Then make room for items
        await this.makeRoomForItems(store);
      } finally {
        this.makingRoom = false;
      }
    },

    start(account: DestinyAccount, storeId: string) {
      if (!this.active) {
        this.active = true;
        this.movingItems = false;
        this.makingRoom = false;

        // Whenever the store is reloaded, run the farming algo
        // That way folks can reload manually too
        subscription = D2StoresService.getStoresStream(account).subscribe((stores) => {
          // prevent some recursion...
          if (this.active && !this.movingItems && !this.makingRoom && stores) {
            const store = stores.find((s) => s.id === storeId);
            this.store = store;
            this.farm(store);
          }
        });
//.........这里部分代码省略.........

  vm.$onInit = () => {
    vm.endTime = new Date(vm.endTime);

    // Update once a minute
    vm.timer = $interval(update, 60000);
    update();
  };

 function update() {
   const diff = vm.endTime.getTime() - Date.now();
   vm.text = dhms(diff / 1000);
   if (diff <= 0) {
     $interval.cancel(vm.timer);
   }
 }

 vm.$onInit = () => {
   this.lastNbNotification = -1;
   // schedule an automatic refresh of the user notifications
   if (!vm.notificationsScheduler) {
     vm.refreshUserNotifications();
     vm.notificationsScheduler = $interval(() => {
       vm.refreshUserNotifications();
     }, UserNotificationService.getNotificationSchedulerInSeconds() * 1000);
   }
 };

 vm.startTasks = function(user) {
   if (user.authenticated) {
     vm.graviteeUser = user;
     // schedule an automatic refresh of the user tasks
     if (!vm.tasksScheduler) {
       vm.refreshUserTasks();
       vm.tasksScheduler = $interval(() => {
         vm.refreshUserTasks();
       }, TaskService.getTaskSchedulerInSeconds() * 1000);
     }
   }
 };

 vm.$onDestroy = () => {
   $interval.cancel(vm.timer);
 };

 vm.cancelRefreshUserNotifications = function() {
   if (vm.notificationsScheduler) {
     $interval.cancel(vm.notificationsScheduler);
     vm.notificationsScheduler = undefined;
   }
 };

 ctrl.$onInit = (): void => {
   ctrl.game = new Game();
   ctrl.updateTimer = $interval(tickMethod, GameSettings.tick);
   ctrl.fixedUpdateTimer = $interval(fixedTickMethod, 1000);
 }