/**
 * @provides javelin-behavior-project-boards
 * @requires javelin-behavior
 *           javelin-dom
 *           javelin-util
 *           javelin-vector
 *           javelin-stratcom
 *           javelin-workflow
 *           javelin-workboard-controller
 */

JX.behavior('project-boards', function(config, statics) {


  function onupdate(col) {
    var data = JX.Stratcom.getData(col);
    var cards = finditems(col);

    // Update the count of tasks in the column header.
    if (!data.countTagNode) {
      data.countTagNode = JX.$(data.countTagID);
      JX.DOM.show(data.countTagNode);
    }

    var sum = 0;
    for (var ii = 0; ii < cards.length; ii++) {
      // TODO: Allow this to be computed in some more clever way.
      sum += 1;
    }

    // TODO: This is a little bit hacky, but we don't have a PHUIX version of
    // this element yet.

    var over_limit = (data.pointLimit && (sum > data.pointLimit));

    var display_value = sum;
    if (data.pointLimit) {
      display_value = sum + ' / ' + data.pointLimit;
    }
    JX.DOM.setContent(JX.$(data.countTagContentID), display_value);


    var panel_map = {
      'project-panel-empty': !cards.length,
      'project-panel-over-limit': over_limit
    };
    var panel = JX.DOM.findAbove(col, 'div', 'workpanel');
    for (var p in panel_map) {
      JX.DOM.alterClass(panel, p, !!panel_map[p]);
    }

    var color_map = {
      'phui-tag-shade-disabled': (sum === 0),
      'phui-tag-shade-blue': (sum > 0 && !over_limit),
      'phui-tag-shade-red': (over_limit)
    };
    for (var c in color_map) {
      JX.DOM.alterClass(data.countTagNode, c, !!color_map[c]);
    }
  }

  function update_statics(update_config) {
    statics.boardID = update_config.boardID;
    statics.projectPHID = update_config.projectPHID;
    statics.order = update_config.order;
    statics.moveURI = update_config.moveURI;
    statics.createURI = update_config.createURI;
  }

  function setup() {
    JX.Stratcom.listen('click', 'boards-dropdown-menu', function(e) {
      var data = e.getNodeData('boards-dropdown-menu');
      if (data.menu) {
        return;
      }

      e.kill();

      var list = JX.$H(data.items).getFragment().firstChild;

      var button = e.getNode('boards-dropdown-menu');
      data.menu = new JX.PHUIXDropdownMenu(button);
      data.menu.setContent(list);
      data.menu.open();

      JX.DOM.listen(list, 'click', 'tag:a', function(e) {
        if (!e.isNormalClick()) {
          return;
        }
        data.menu.close();
      });
    });

    JX.Stratcom.listen(
      'quicksand-redraw',
      null,
      function (e) {
        var data = e.getData();
        if (!data.newResponse.boardConfig) {
          return;
        }
        var new_config;
        if (data.fromServer) {
          new_config = data.newResponse.boardConfig;
          statics.boardConfigCache[data.newResponseID] = new_config;
        } else {
          new_config = statics.boardConfigCache[data.newResponseID];
          statics.boardID = new_config.boardID;
        }
        update_statics(new_config);
      });

    return true;
  }

  if (!statics.setup) {
    update_statics(config);
    var current_page_id = JX.Quicksand.getCurrentPageID();
    statics.boardConfigCache = {};
    statics.boardConfigCache[current_page_id] = config;
    statics.setup = setup();
  }

  if (!statics.workboard) {
    statics.workboard = new JX.WorkboardController()
      .setUploadURI(config.uploadURI)
      .setCoverURI(config.coverURI)
      .setMoveURI(config.moveURI)
      .setCreateURI(config.createURI)
      .setChunkThreshold(config.chunkThreshold)
      .start();
  }

  var board_phid = config.projectPHID;
  var board_node = JX.$(config.boardID);

  var board = statics.workboard.newBoard(board_phid, board_node)
    .setOrder(config.order);

  var templates = config.templateMap;
  for (var k in templates) {
    board.setCardTemplate(k, templates[k]);
  }

  var column_maps = config.columnMaps;
  for (var column_phid in column_maps) {
    var column = board.getColumn(column_phid);
    var column_map = column_maps[column_phid];
    for (var ii = 0; ii < column_map.length; ii++) {
      column.newCard(column_map[ii]);
    }
  }

  var order_maps = config.orderMaps;
  for (var object_phid in order_maps) {
    board.setOrderMap(object_phid, order_maps[object_phid]);
  }

  board.start();

});