habitica/src/app/party.coffee

_ = require('underscore')

###
  Subscribe to the user, the users's party (meta info like party name, member ids, etc), and the party's members. 3 subscriptions.
  1) If the user is solo, just subscribe to the user.
  2) If in a an empty party, just subscribe to the user & party meta.
  3) If full party, subscribe to everything.
###
module.exports.partySubscribe = partySubscribe = (page, model, params, next, cb) ->

  # Restart subscription to the main user
  selfQ = model.query('users').withId (model.get('_userId') or model.session.userId) # see http://goo.gl/TPYIt
  selfQ.subscribe (err, user) ->
    return next(err) if err
    return next("User not found - this shouldn't be happening!") unless user.get()

    # Attempted handling for 'party of undefined' error, which is caused by bustedSession (see derby-auth).
    # Theoretically simply reloading the page should restore model.at('_userId') and the second load should work just fine
    # bustedSession victims might hit a redirection loop if I'm wrong :/
#    return page.redirect('/') unless uObj

    model.ref '_user', user
    partyId = user.get('party.current')

    # (1) Solo player
    return cb() unless partyId

    # User in a party
    partyQ = model.query('parties').withId(partyId)
    partyQ.subscribe (err, party) ->
      return next(err) if err
      model.ref '_party', party
      members = party.get('members')

      ## (2) Party has no members, just subscribe to the party itself
      return cb() if _.isEmpty(members)

      ## (3) Party has members, subscribe to those users too
      membersQ = model.query('users').party(members)
      membersQ.subscribe (err, members) ->
        return next(err) if err
        model.ref '_partyMembers', members

        # Ok, now we've subscribed to everything. Now there's a strange issue:
        # Party members come with limited fields, so you can't hack their stuff. Strangely, subscribing to the members after
        # already subscribing to self limits self's fields to the fields which members are limited to. As a result, we have
        # to re-subscribe to self to get all the fields (otherwise everything breaks). Weirdly, this last subscription doesn't
        # do the opposite - granting all the fields back to members. I dont' know what's going on here
        model.unsubscribe selfQ, ->
          selfQ.subscribe (err, userAgain) ->
            return next(err) if err
            model.ref '_user', userAgain
            return cb()

module.exports.app = (appExports, model) ->
  character = require './character'
  browser = require './browser'

  user = model.at('_user')

  model.on 'set', '_user.party.invitation', (after, before) ->
    if !before? and after? # they just got invited
      partyQ = model.query('parties').withId(after)
      partyQ.fetch (err, party) ->
        return next(err) if err
        model.ref '_party', party
        browser.resetDom(model)

  appExports.partyCreate = ->
    newParty = model.get("_newParty")
    id = model.add 'parties', { name: newParty, leader: user.get('id'), members: [user.get('id')], invites:[] }
    user.set 'party', {current: id, invitation: null, leader: true}, ->
      window.location.reload true
#    partySubscribe model, -> $('#party-modal').modal('show')

  appExports.partyInvite = ->
    id = model.get('_newPartyMember').replace(/[\s"]/g, '')
    return if _.isEmpty(id)

    model.query('users').party([id]).fetch (err, res) ->
      throw err if err
      u = res.at(0).get()
      if !u?
        model.set "_partyError", "User with id #{id} not found."
        return
      else if u.party.current? or u.party.invitation?
        model.set "_partyError", "User already in a party or pending invitation."
        return
      else
        p = model.at '_party'
        #p.push "invites", id
        $.bootstrapGrowl "Invitation Sent."
        $('#party-modal').modal('hide')
        model.set "users.#{id}.party.invitation", p.get('id'), -> window.location.reload(true)
        #model.set '_newPartyMember', ''
        #partySubscribe model

  appExports.partyAccept = ->
    partyId = user.get('party.invitation')
    user.set 'party.invitation', null
    user.set 'party.current', partyId
    model.at("parties.#{partyId}.members").push user.get('id'), -> window.location.reload(true)
#    model.query('parties').withId(partyId).fetch (err, p) ->
#      members = p.get('members')
#      members.push user.get('id')
#      p.set 'members', members, ->
#        window.location.reload true

#    partySubscribe model, ->
#      p = model.at('_party')
#      p.push 'members', user.get('id')

  appExports.partyReject = ->
    user.set 'party.invitation', null
    browser.resetDom(model)
    # TODO splice parties.*.invites[key]
    # TODO notify sender

  appExports.partyLeave = ->
    id = user.set 'party.current', null
    p = model.at '_party'
    members = p.get('members')
    index = members.indexOf(user.get('id'))
    members.splice(index,1)
    p.set 'members', members, ->
      if (members.length == 0)
        # last member out, kill the party
        model.del "parties.#{id}", -> window.location.reload true
      else
        window.location.reload true
#    model.set '_party', null
#    model.set '_partyMembers', null
#    partyUnsubscribe model, ->
#      selfQ = model.query('users').withId model.get('_userId') #or model.session.userId # see http://goo.gl/TPYIt
#      selfQ.subscribe (err, u) ->
#        model.ref '_user', u
#        browser.resetDom model