import _ from 'lodash'

import { lacuna, call, findPlanets, eachPlanet, log, util } from '@tlecommunity/super-core'

class ThrowParties {
  constructor(options) {
    this.options = options

    this.partiesThrown = 0
    this.happiness = 0
  }

  validateOptions() {
    return new Promise((resolve, reject) => {
      if (!this.options.planet) {
        reject('please specify a planet')
      } else {
        resolve(true)
      }
    })
  }

  async handleParty(colony, park) {
    let view = await call(() => lacuna.park.view({ building_id: park.id }))
    let party = view.party || {}

    if (party.seconds_remaining) {
      log.info(`Park (level ${park.level}) on ${colony.name} already has a party in progress`)
      return
    }

    if (!party.can_throw) {
      log.info(`Park (level ${park.level}) on ${colony.name} can't throw a party right now`)
      return
    }

    if (this.options.dryRun) {
      log.info(`Would throw a party at Park (level ${park.level}) on ${colony.name}`)
      this.partiesThrown++
      return
    }

    let result = await call(() => lacuna.park.throwAParty({ building_id: park.id }))
    let gained = util.int((result.party || {}).happiness)

    this.partiesThrown++
    this.happiness += gained

    log.info(
      `Threw a party at Park (level ${park.level}) on ${colony.name} (+${util.commify(gained)} happiness)`
    )
  }

  async handleColony(colony, buildings) {
    let parks = _.filter(buildings, (b) => b.name === 'Park' && util.int(b.efficiency) === 100)

    if (parks.length === 0) {
      log.info(`No Parks on ${colony.name}`)
      return
    }

    for (const park of parks) {
      await this.handleParty(colony, park)
    }
  }

  run() {
    return new Promise((resolve, reject) => {
      findPlanets(this.options.planet)
        .then((colonies) => {
          return eachPlanet(colonies, _.bind(this.handleColony, this), {
            force: true,
          })
        })
        .then(() => {
          if (this.partiesThrown > 0) {
            let plural = util.handlePlurality(this.partiesThrown, 'party')
            resolve(
              `Threw ${this.partiesThrown} ${plural} for a total of ${util.commify(this.happiness)} happiness`
            )
          } else {
            resolve(`Didn't throw any parties`)
          }
        })
        .catch(reject)
    })
  }
}

export default ThrowParties