var fetchTemplateData = require('okutil').fetchTemplateData;
var OKResource = require('okresource');

// Routes for views over collections have a special pattern
// containing a free variable e.g. :id
var UNBOUND_ROUTE_PATTERN = /:([a-zA-Z\-_]+)/;

/**
 * OKView!
 * Is supplied DB queries and a template and is responsible
 * for resolving the queries, throwing the data into the templates,
 * and sending the response.
 */
function OKView(options) {
  if (!(this instanceof OKView)) return new OKView(options);
  options = options || {};
  if (!options.template)
    throw new Error('No template provided to view.');
  if (!options.meta)
    throw new Error('No meta resource provided to view');
  if (!options.route)
    throw new Error('No route provided to view');
  this.route = options.route;
  this._template = options.template;
  var meta = this._meta = options.meta;
  var queries = this._queries = options.queries || [];
  // Whether this is a view for a specific resource or its
  // resource will be resolved later
  // TODO This bound / unbound thing can probably be expressed in a
  //      less convoluted way.
  var unbound = this.unbound = !!UNBOUND_ROUTE_PATTERN.exec(this.route);
  this._middleware = createMiddleware(this);
  this._fetchTemplateData = unbound ?
    fetchResourceTemplateData : fetchCollectionTemplateData;

  function fetchResourceTemplateData(id) {
    // Bound views only have a single query
    // TODO This is super convoluted
    return fetchTemplateData(meta, [queries[0].get(id)]);
  }

  function fetchCollectionTemplateData() {
    return fetchTemplateData(meta, queries);
  }
}

OKView.prototype.middleware = function() {
  return this._middleware;
};

OKView.prototype.render = function(req, res, data) {
  this._template.render(data).then(function(html) {
    res.send(html);
  }, errorHandler(req, res, data));
};

OKView.prototype.fetchTemplateData = function() {
  return this._fetchTemplateData.apply(this, arguments);
};

/**
 * Unbound views need different middleware to resolve requests
 */
function createMiddleware(view) {
  if (view.unbound) {
    return unboundMiddleware(view);
  } else {
    return boundMiddleware(view);
  }
}

// Note that these middleware do not call next
// and should thus always be added at the end of the
// middleware chain.

/**
 * Creates middleware for a view which does not
 * yet have a resource id associated with it
 */
function unboundMiddleware(view) {
  var paramName = getParamName(view.route);
  return function(req, res, next) {
    var id = req.params[paramName];
    view.fetchTemplateData(id).then(function(data) {
      view.render(req, res, data);
    }, errorHandler(req, res, next));
  };
}

/**
 * Creates middleware for a view which already
 * has a resource id associated with it
 */
function boundMiddleware(view) {
  return function(req, res, next) {
    view.fetchTemplateData().then(function(data) {
      view.render(req, res, data);
    }, errorHandler(req, res, next));
  };
}

/**
 * TODO BS error handling for now
 */
function errorHandler(req, res, next) {
  return function(err) {
    res.send(err.stack);
  }
}

/**
 * Given a route with a free variable, return the
 * name of the variable, e.g. :id returns id
 */
function getParamName(route) {
  route = route || '';
  var matches = UNBOUND_ROUTE_PATTERN.exec(route) || [];
  return matches[1];
}

module.exports = OKView;