// attach to app.locals so errorHandlers can use it in altenate flow
  app.locals.appFinish = function(req, res, next) {
    debug("appFinish called");
    res.emit('timer', 'appFinish->' + req.nodule.name);

    var renderData = res.yukon.renderData;

    // non-components such as JSON calls and cms widgets dont get appClientData
    if (!req.nodule.isComponent) {
      if (!req.isHealth) {
        renderData.reporting = reporting.process(req.nodule.isJson, req, res);
        renderData.messagekeys = res.messagekeys;
        renderData.contingencies = res.contingencies;
      }

      doLog(req, res);
      
      next();
      return;
    }

    
    // passing request path for SEO canonical tag
    if (req.path.indexOf('__') !== -1 && req.cmsPath) 
      renderData.path = req.cmsPath;
    else 
      renderData.path = req.path;

    if (!res.locals.appClientData)
      res.locals.appClientData = {};
    
    if (!res.yukon.userProfile)
      res.yukon.userProfile = { profile:{} }; // something went wrong with getProfile call

    res.locals.appClientData.contingencies = res.contingencies; // note these are messages from the server - to be consumed by an angular directive, we may use a jade template instead

    res.locals.appClientData.messagekeys = res.messagekeys; // these are ATG messages with their keys that need to be handled by front end templates or JS code

    // Notes: This comes from Scientia - which is not installed on our dev boxes. To spoof this information on dev boxes - use lib/mobilesim.js.
    //        DeviceResolution only seems to be accurate for phones and tablets.
    res.locals.appClientData.deviceData = {
      type:        req.deviceType,
      cmsType:     res.locals.cmsDeviceType,
      os:          req.headers['x-device_device_os'],
      brand:       req.headers['x-device_brand_name'],
      iosVersion:  res.locals.iosVersion,
      resolution:  req.headers['x-device_resolution_width'] + 'x' + req.headers['x-device_resolution_height'],
      isSupported: req.isSupportedDevice
    };

    if (res.yukon.fullSiteNav) 
      renderData.fullSiteNav = res.yukon.fullSiteNav;
        
    if (res.yukon.mobileNav) 
      res.locals.appClientData.mobileNav = res.yukon.mobileNav;

    try { 
      res.locals.appClientData.reporting = reporting.process(req.nodule.isJson, req, res);
    } catch (error) {
      req.errLog.error(debug(error.stack || error));
    }

    if (req.isModal) 
      renderData.isModal = true;
    
    if (req.query.overlay) 
      renderData.isOverlay = res.locals.appClientData.isOverlay = true;
    else 
      renderData.isOverlay = res.locals.appClientData.isOverlay = false;

    if (res.yukon.userProfile && res.yukon.userProfile.profile) {
      res.locals.appClientData.userProfile = {};
      // customer's etoken is bad or expired, we need to set them back to prospect status
      if (res.yukon.userProfile.profile.customer && !res.yukon.userProfile.profile.authorized) {
        res.yukon.userProfile.profile = _.clone(app.libUtils.defaultProfile);
        res.clearCookie('JSESSIONID', {domain:'xxx.com'});
        res.clearCookie('DYN_USER_ID', {domain:'xxx.com'});
        res.clearCookie('DYN_USER_CONFIRM', {domain:'xxx.com'});
        res.clearCookie('customer', {domain:'xxx.com'});

        var msg = moment().format('M[/]D') + 'E-token mismatch, profile.authorized = false, resetting user to prospect';
        req.errLog.error(msg);
        debug(msg);
        app.libUtils.updateAggregateErrors(msg);
      }

      _.each(clientUserProfileVars, function(property) { 
        res.locals.appClientData.userProfile[property] = res.yukon.userProfile.profile[property]; 

// uncomment this to debug user profile, don't check it in uncommented
//        debug("userProfile." + property + " = " + res.locals.appClientData.userProfile[property]);

      });
      
      debug('requestId = ' + req.requestId);
      debug("sessionId = " + req.sessionId);
      debug("DYN_USER_ID = " + req.cookies['DYN_USER_ID']);

      if (req.cookies['appe-prospect-zip'] && res.locals.appClientData.userProfile.customer) 
        res.clearCookie('appe-prospect-zip');

      res.locals.appClientData.userProfile.internalStreamingDisabled = res.locals.internalStreamingDisabled;
    }

    // slimmed down version of user profile is good for most templates
    renderData.userProfile = res.locals.appClientData.userProfile;

    // modal launched via deep link (after user signs in, could be used elsewhere)
    if (req.query.modal) {
      res.locals.appClientData.modal = {
        modalClose: req.query.modalClose,
        modalTitle: req.query.modalTitle,
        modalClass: req.query.modalClass,
        modalError: req.query.modalError,
        modalTarget: req.query.modal,
        modalQueryString: querystring.stringify(_.omit(req.query, ['modal','modalClose','modalTitle','modalClass','modalError']))
      };
    }

    // Build error query for URL helpers
    var requestUrl = url.parse(req.originalUrl);
    var browserUrl = req.protocol + '://' + req.headers.host + requestUrl.pathname;
    var parsedQuery = querystring.parse(req.query);
    parsedQuery.modal = '/modal/signin';
    parsedQuery.modalError = 'true';
    var errorQuery = querystring.stringify(parsedQuery);
    var cdnHost = (requestUrl.protocol === 'http') ? "http://cdn.xxx.com" : "https://cdns.xxx.com";
    var appendQueryString =  req.query ? '?'+ querystring.stringify(req.query) : '';

    res.locals.loginDargs = app.config.login_dargs;

    // URL Helper Object for client
    res.locals.appClientData.url = {
      referer: req.headers.referer ? url.parse(req.headers.referer) : undefined,
      loginServer: app.locals.loginServer,
      // teamSitePath: req.protocol+app.locals.teamsiteServer.substr(app.locals.teamsiteServer.indexOf(':')),

      logoutLink: app.locals.loginServer + app.config.logout_url,
      appImageUrl: (requestUrl.protocol === 'http') ? app.config.app_http_img_url : app.config.app_https_img_url,
      appHomePage: app.config.app_home_page,
      cdnHost: cdnHost,
      is_prod_env: app.config.is_prod_env,
      enabledFlag: app.locals.atgConfig.enabled,
      typeAheadUrl: app.config.typeAheadUrl,
      sessionTimeoutWarning: app.locals.atgConfig.guardAuthEnabled ? app.config.session_timeout_minutes_guard : app.config.session_timeout_minutes
    };

    // URL Helper Object for JADE
    renderData.url = _.clone(res.locals.appClientData.url); // shallow clone is ok here
    renderData.url.request = requestUrl;
    renderData.url.request.host = req.hostname; // Request object is not properly populating these values
    renderData.url.request.protocol = req.protocol; // Request object is not properly populating these values

    renderData.url.loginSuccessUrl = browserUrl + appendQueryString;
    renderData.url.loginFailUrl = browserUrl + '?' + errorQuery;
    renderData.url.query = req.query; // don't blindly pass the query to client for XSS reasons
 
    renderData.hostname = os.hostname();
    renderData.userId = req.cookies['DYN_USER_ID'] || 'ANON';
    renderData.sessionId = req.sessionId;
    renderData.requestId = req.requestId;

    var isIE = req.headers['user-agent'].match(/MSIE (\d+)\./);
    renderData.ieVersion = res.locals.appClientData.deviceData.ieVersion = (isIE) ? 1*isIE[1] : false;

    // Make crawler detection available to JADE
    renderData.isCrawler = req.isCrawler;
  
    if (app.appMiddleware.appFinish) app.appMiddleware.appFinish(req, res);

    doLog(req, res);

    req._timer.stop();

    if (req.nodule.error !== 'isRedirect') next();    
  };

 (defn trips [hand-map]
  (let [t-cards (ranks-strength-count hand-map 3)
        k-cards (sorted-ranks-strength-count hand-map 1)]
    (conj t-cards
          (take-last 2 k-cards))))

(defn quads [hand-map]
  (let [q-cards (ranks-strength-count hand-map 4)
        k-cards (sort (concat (ranks-strength-count hand-map 1)
                              (ranks-strength-count hand-map 2)
                              (ranks-strength-count hand-map 3)))]
    (conj q-cards
          (take-last 1 k-cards))))

## not exactly how this work, but trying to make it clearer. 
## In reality the functions return lists and I cons them together.
def trips (hand_map):
    t_cards = ranks_strength_count (hand_map 3)
    kicker_cards = sorted_ranks_strength_count (hand_map 3)
    return [[kicker_cards], t_cards]

def quads (hand_map):
    q_cards = ranks_strength_count (hand_map 4)
    ## only one of these function will return a value. Not sure if
    ## Null + Null + value = ( , , value), but the intention is for it
    ## to be (value).
    kicker_cards = sorted_ranks_strength_count (hand_map 1) +
                   sorted_ranks_strength_count (hand_map 2) +
                   sorted_ranks_strength_count (hand_map 3)
    return [[kicker_cards] q_cards]

(defn pair [hand-map]
  (let [p-card (ranks-strength-count hand-map 2)
        k-cards (sorted-ranks-strength-count hand-map 1)]
    (conj p-card (take-last 3 k-cards))))

{T 1, Q 2, A 1, 6 1, J 1, 2 1}

(def ranks ["_" "2" "3" "4" "5" "6" "7" "8" "9" "T" "J" "Q" "K" "A"])
;; Q is in position 11

(1 5 9 10 13)

((9 10 13) 11)

[((9 10 13) 11) :pair]

(defn pair [hand-map]
  (println hand-map) ;; {T 1, Q 2, A 1, 6 1, J 1, 2 1}
  (let [p-card (ranks-strength-count hand-map 2)
        k-cards (sorted-ranks-strength-count hand-map 1)]
    (println p-card) ;; (11)
    (println k-cards) ;; (1 5 9 10 13)
    (conj p-card (take-last 3 k-cards)))) ;; result ((9 10 13) 11)