Pop

var yamlish = require('yamlish')
  , path = require('path')
  , fs = require('fs');

module.exports = {

datePad: function(num) {
    return num.toString().length === 1 ? '0' + num : num;
  },

getPostFileName: function(pf, date, title, format) {
    // TODO: Remove non-ASCII?
    title = title.toLowerCase().replace(/\s+/g, '-');
    return '_posts/' + pf.replace(':year', date.getFullYear())
             .replace(':month', this.datePad(date.getMonth() + 1))
             .replace(':day', this.datePad(date.getDate()))
             .replace(/^\//, '')
             .replace(/\//g, '-')
             .replace(':title', title + '.' + format);
  },

makePost: function(config, title, fn) {
    // TODO: Get at least format and author from CLI
    var meta = {
          layout: 'post'
        , title: title
        , author: ''
        , tags: ['tag_1', 'tag_2']
        }
      , url = ''
      , format = 'md'
      , date = new Date()
      , frontMatter = ''
      , fileName = this.getPostFileName(config.permalink, date, title, format);

    frontMatter = '---\n' + yamlish.encode(meta).replace(/^\s+/mg, '') + '\n---\n';

    fs.writeFile(path.join(config.root, fileName), frontMatter, function(err) {
      if (err) {
        console.log('Error writing file:', fileName);
        throw(err);
      }
      console.log('Post created:', fileName);
      fn();
    });
  },

defaultConfig: function() {
    return '' 
    + '{  "url": "http://example.com/"\n'
    + ' , "title": "Example"\n'
    + ' , "permalink": "/:year/:month/:day/:title"\n'
    + ' , "paginate": 10\n'
    + ' , "exclude": ["\\\\.swp"]\n'
    + ' , "autoGenerate": [{"feed": "feed.xml"}] }\n'
  },

defaultIndex: function() {
    return ''
    + '---\n'
    + 'layout: default\n'
    + 'title: My Site\n'
    + '---\n\n'
    + 'h1 Welcome to my site\n'
    + 'p Coming soon.\n';
  },

defaultLayout: function() {
    return ''
    + '!!! 5\n'
    + 'html(lang="en")\n'
    + '  head\n'
    + '    title Example Site\n'
    + '  body\n'
    + '    #content\n'
    + '      !{content}\n';
  },

makeSite: function(pathName, fn) {
    if (path.existsSync(pathName)) {
      console.log('Error: Path already exists');
      process.exit(1);
    } else {
      var paths = ['_posts', '_lib', '_layouts', '_includes'];
      fs.mkdirSync(pathName, 0777);
      paths.forEach(function(p) {
        fs.mkdirSync(path.join(pathName, p), 0777);
      });

      fs.writeFileSync(path.join(pathName, '_config.json'), this.defaultConfig());
      fs.writeFileSync(path.join(pathName, 'index.jade'), this.defaultIndex());
      fs.writeFileSync(path.join(pathName, '_layouts', 'default.jade'), this.defaultLayout());

      console.log('Site created:', pathName);
      fn();
    }
  }
};

function readConfigFile(file) {
  var defaults = {
    perPage: 20 
  };

  function applyDefaults(config) {
    for (var key in defaults) {
      config[key] = config[key] || defaults[key];
    }
    return config;
  }

  try {
    var data = fs.readFileSync(file).toString();
    return applyDefaults(JSON.parse(data));
  } catch(exception) {
    console.log('Error reading config:', exception.message);
    throw(exception);
  }
}

var root = process.cwd()
  , fs = require(__dirname + '/graceful')

module.exports = readConfigFile;

var fs = require(__dirname + '/graceful')
  , path = require('path')
  , EventEmitter = require('events').EventEmitter;

function FileMap(config) {
  this.config = config || {};
  this.config.exclude = config && config.exclude ? config.exclude : [];
  this.config.exclude.push('/_site');
  this.ignoreDotFiles = true;
  this.root = config.root;
  this.files = [];
  this.events = new EventEmitter();
  this.filesLeft = 0;
  this.dirsLeft = 1;
}

FileMap.prototype.fileType = function(fileName) {
  var extension = path.extname(fileName).substring(1);

  if (fileName.match(/\/_posts\//)) {
    return 'post ' + extension;
  } else if (fileName.match(/\/_layouts\//)) {
    return 'layout ' + extension;
  } else if (fileName.match(/\/_includes\//)) {
    return 'include ' + extension;
  } else if (['jade', 'ejs', 'styl'].indexOf(extension) !== -1) {
    return 'file ' + extension;
  } else {
    return 'file';
  }
};

FileMap.prototype.walk = function(dir) {
  if (!dir) dir = this.root;

  var self = this;

  fs.readdir(dir, function(err, files) {
    self.dirsLeft--;
    if (!files) return;
    files.forEach(function(file) {
      file = path.join(dir, file);
      self.filesLeft++;
      fs.stat(file, function(err, stats) {
        if (err) console.log('Error:', err);
        if (!stats) return;
        if (stats.isDirectory(file)) {
          self.filesLeft--;
          self.dirsLeft++;
          self.walk(file);
          self.addFile(file, 'dir');
        } else {
          self.filesLeft--;
          self.addFile(file, self.fileType(file));
          if (self.filesLeft === 0 && self.dirsLeft === 0) {
            process.nextTick(function() {
              self.events.emit('ready');
            });
          }
        }
      });
    });
  });
};

FileMap.prototype.isExcludedFile = function(file) {
  if (this.ignoreDotFiles)
    if (file.match(/\/\./)) return true;

  return this.config.exclude.some(function(pattern) {
    return file.match(pattern);
  });
};

FileMap.prototype.addFile = function(file, type) {
  if (this.isExcludedFile(file)) return;

  this.files.push({
    name: file,
    type: type,
  });
};

FileMap.prototype.on = function(eventName, fn) {
  this.events.on(eventName, fn);
};

module.exports = FileMap;

*
   * Replaces liquid tag highlight directives with prettyprint HTML tags.
   *
   * @param {String} The text for a post
   * @return {String}
   

var fs = require('fs')
  , path = require('path')
  , defaultTimeout = 0
  , timeout = defaultTimeout;

function mkdir_p(dir, mode, callback, position) {
  mode = mode || process.umask();
  position = position || 0;
  parts = path.normalize(dir).split('/');

  if (position >= parts.length) {
    if (callback) {
      return callback();
    } else {
      return true;
    }
  }

  var directory = parts.slice(0, position + 1).join('/') || '/';
  fs.stat(directory, function(err) {    
    if (err === null) {
      mkdir_p(dir, mode, callback, position + 1);
    } else {
      fs.mkdir(directory, mode, function(err) {
        if (err && err.errno != 17) {
          if (callback) {
            return callback(err);
          } else {
            throw err;
          }
        } else {
          mkdir_p(dir, mode, callback, position + 1);
        }
      });
    }
  });
}

fs.mkdir_p = function(dir, mode, callback) {
  mkdir_p(dir, mode, callback || process.noop);
}

// Graceful patching wraps async fs methods
Object.keys(fs)
  .forEach(function(i) {
    exports[i] = (typeof fs[i] !== 'function') ? fs[i]
               : (i.match(/^[A-Z]|^create|Sync$/)) ? function() {
                   return fs[i].apply(fs, arguments);
                 }
               : graceful(fs[i]);
  });

function graceful(fn) { return function GRACEFUL() {
  var args = Array.prototype.slice.call(arguments)
    , cb_ = args.pop();
  
  args.push(cb);

  function cb(er) {
    if (er && er.message.match(/^EMFILE, Too many open files/)) {
      setTimeout(function() {
        GRACEFUL.apply(fs, args)
      }, timeout++);
      return;
    }
    timeout = defaultTimeout;
    cb_.apply(null, arguments);
  }
  fn.apply(fs, args)
}};

var jade = require('jade')
  , fs = require('fs')
  , path = require('path')
  , cache = {}
  , _date = require('underscore.date')
  , helpers;

helpers = {

paginate: function(paginator) {
    var template = '';
    template += '.pages\n';
    template += '  - if (paginator.previousPage)\n';
    template += '    span.prev_next\n';
    template += '      - if (paginator.previousPage === 1)\n';
    template += '        span ←\n';
    template += '        a.previous(href="/") Previous\n';
    template += '      - else\n';
    template += '        span ←\n';
    template += '        a.previous(href="/page" + paginator.previousPage + "/") Previous\n';
    template += '  - if (paginator.pages > 1)\n';
    template += '    span.prev_next\n';
    template += '      - for (var i = 1; i <= paginator.pages; i++)\n';
    template += '        - if (i === paginator.page)\n';
    template += '          strong.page #{i}\n';
    template += '        - else if (i !== 1)\n';
    template += '          a.page(href="/page" + i + "/") #{i}\n';
    template += '        - else\n';
    template += '          a.page(href="/") 1\n';
    template += '      - if (paginator.nextPage <= paginator.pages)\n';
    template += '        a.next(href="/page" + paginator.nextPage + "/") Next\n';
    template += '        span →\n';
    return jade.render(template, { locals: { paginator: paginator } });
  },

atom: function(url, title, feed, perPage) {
    perPage = perPage || 20;
    var template = ''
      , site = this;
    template += '!!!xml\n';
    template += 'feed(xmlns="http://www.w3.org/2005/Atom")\n';
    template += '  title #{title}\n';
    template += '  link(href=feed, rel="self")\n';
    template += '  link(href=url)\n';
    template += '  updated #{dx(site.posts[0].date)}\n';
    template += '  id #{url}\n';
    template += '  author\n';
    template += '    name #{title}\n';
    template += '  - for (var i = 0, post = site.posts[i]; i < ' + perPage + '; i++, post = site.posts[i])\n';
    template += '    entry\n';
    template += '      title #{post.title}\n';
    template += '      link(href=url + post.url)\n';
    template += '      updated #{dx(post.date)}\n';
    template += '      id #{url.replace(/\\/$/, "")}#{post.url}\n';
    template += '      content(type="html") !{h(post.content)}\n';
    return jade.render(template, { locals: site.applyHelpers({ paginator: site.paginator, title: title, url: url, feed: feed }) });
  },

allTags: function() {
    var allTags = [];

    for (var key in this.posts) {
      if (this.posts[key].tags) {
        for (var i = 0; i < this.posts[key].tags.length; i++) {
          var tag = this.posts[key].tags[i];
          if (allTags.indexOf(tag) === -1) allTags.push(tag);
        }
      }
    }

    allTags.sort(function(a, b) {
      a = a.toLowerCase();
      b = b.toLowerCase();
      if (a < b) return -1;
      if (a > b) return 1;
      return 0;
    });

    return allTags;
  },

tags: function(tags) {
    return tags.map(function(tag) {
      return '<a href="/tags.html#' + escape(tag) + '">' + tag + '</a>';
    }).join(', ');
  },

hNews: function(post) {
    var template = '';
    template += 'article.hentry\n';
    template += '  header\n';
    template += '    h1.entry-title\n';
    template += '      a(href=post.url) !{post.title}\n';
    template += '    time.updated(datetime=dx(post.date), pubdate) #{ds(post.date)}\n';
    template += '    p.byline.author.vcard by <span class="fn">#{post.author}</span>\n';

    if (post.tags) template += '    div.tags !{tags(post.tags)}\n';

    template += '  !{post.content}\n';
    return jade.render(template, { locals: this.applyHelpers({ post: post }) });
  },

df: function(date, format) {
    return _date(date).format(format);
  },

ds: function(date) {
    return helpers.df(date, 'DD MMMM YYYY');
  },

dx: function(date) {
    return helpers.df(date, 'YYYY-MM-DDTHH:MM:ssZ');
  },

h: function(text) {
    return text &amp;&amp; text.replace(/&/g,'&').replace(/</g,'<').replace(/>/g,'>');
  },

truncateParagraphs: function(text, length, moreText) {
    var t = text.split('</p>');
    return t.length &lt; length ? text : t.slice(0, length).join('</p>') + '</p>' + moreText;
  }
};

module.exports = helpers;

function Paginator(perPage, items) {
  this.allItems = this.sort(items);
  this.perPage = perPage;
  this.items = this.allItems.slice(0, perPage);
  this.previousPage = 0;
  this.nextPage = 2;
  this.page = 1;
  this.pages = Math.round(this.allItems.length / this.perPage) + 1;
}

Paginator.prototype.advancePage = function() {
  this.page++;
  this.previousPage = this.page - 1;
  this.nextPage = this.page + 1;

  var start = (this.page - 1) * this.perPage
    , end = this.page * this.perPage;
  this.items = this.allItems.slice(start, end); 
};

Paginator.prototype.sort = function(items) {
  return items.sort(function(a, b) {
    a = a.date.valueOf();
    b = b.date.valueOf();
    if (a > b)
      return -1;
    else if (a < b)
      return 1;
    return 0;
  });
};

module.exports = Paginator;

var path = require('path')
  , FileMap = require(__dirname + '/file_map')
  , SiteBuilder = require(__dirname + '/site_builder')
  , cliTools = require(__dirname + '/cli_tools')
  , readConfig = require(__dirname + '/config')
  , usage
  , args = process.argv.slice(2)
  , version = '0.0.1';

usage  = 'pop is a static site builder.\n\n';
usage += 'Usage: pop [command] [options]\n';
usage += 'new    path           Generates a new site at path/\n';
usage += 'post   "Post Title"   Writes a new post file\n'; 
usage += 'server                Create a server on port 4000 for _site/\n\n';
usage += '-v, --version         Display version and exit\n';
usage += '-h, --help            Shows this message\n';

function loadConfig() {
  var root = process.cwd()
    , config = readConfig(path.join(root, '_config.json'));
  config.root = root;
  return config;
}

function loadConfigAndGenerateSite(useServer) {
  generateSite(loadConfig(), useServer);
}

function generateSite(config, useServer) {
  var fileMap = new FileMap(config)
    , siteBuilder = new SiteBuilder(config)
    , server = require(__dirname + '/server')(siteBuilder);

  fileMap.walk();
  fileMap.on('ready', function() {
    siteBuilder.fileMap = fileMap;
    siteBuilder.build();
  });

  siteBuilder.on('ready', function() {
    if (useServer) {
      server.run();
      server.watch();
    }
  });

  return siteBuilder;
}

module.exports = function() {
  while (args.length) {
    arg = args.shift();
    switch (arg) {
      case 'server':
        loadConfigAndGenerateSite(true);
      break;
      case 'post':
        cliTools.makePost(loadConfig(), args.shift(), function() { process.exit(0); });
      break;
      case 'new':
        cliTools.makeSite(args.shift(), function() { process.exit(0); });
      break;
      case '-v':
      case '--version':
        console.log('pop version:', version);
        process.exit(0);
      break;
      case '-h':
      case '--help':
        console.log(usage);
        process.exit(1);
      default:
        loadConfigAndGenerateSite();
    }
  }
};

module.exports.SiteBuilder = SiteBuilder;
module.exports.FileMap = FileMap;
module.exports.generateSite = generateSite;
module.exports.cliTools = cliTools;

var path = require('path')
  , watch = require('nodewatch')
  , siteBuilder;

function server() {
  // TODO: Show require express error
  var express = require('express'),
      app = express.createServer();

  app.configure(function() {
    app.use(express.static(siteBuilder.outputRoot));
    app.use(express.errorHandler({ dumpExceptions: true, showStack: true }));
  });

  // Map missing trailing slashes for posts
  app.get('*', function(req, res) {
    var postPath = siteBuilder.outputRoot + req.url + '/';
    // TODO: Security
    if (req.url.match(/[^/]$/) && path.existsSync(postPath)) {
      res.redirect(req.url + '/');
    } else {
      res.send('404');
    }
  });

  // TODO: Config
  app.listen(4000);
  console.log('Listening on port 4000');
}

function watchChanges() {
  // TODO: What happens when files are added?
  // TODO: Other directories?
  watch
    .add(siteBuilder.root)
    .add(path.join(siteBuilder.root, '_posts'))
    .onChange(function(file) {
      console.log('File changed:', file);
      siteBuilder.buildChange(file);
    });
}

module.exports = function(s) {
  siteBuilder = s;
  return {
    run: server
  , watch: watchChanges
  };
};

var textile = require('stextile')
  , fs = require('./graceful')
  , path = require('path')
  , jade = require('jade')
  , stylus = require('stylus')
  , yamlish = require('yamlish')
  , markdown = require('markdown-js')
  , Paginator = require('./paginator')
  , FileMap = require('./file_map.js').FileMap
  , EventEmitter = require('events').EventEmitter
  , filters = require('./filters')
  , helpers = require('./helpers')
  , userHelpers = {}
  , userFilters = {};

function SiteBuilder(config, fileMap) {
  this.config = config;
  this.root = config.root;

  var helperFile = path.join(this.root, '_lib', 'helpers.js');
  if (path.existsSync(helperFile)) {
    userHelpers = require(helperFile);
  }

  var filterFile = path.join(this.root, '_lib', 'filters.js');
  if (path.existsSync(filterFile)) {
    userFilters = require(filterFile);
  }

  // TODO Make this configurable
  this.outputRoot = config.output || path.join(this.root, '_site');
  this.fileMap = fileMap;
  this.posts = [];
  this.helpers = helpers;
  this.events = new EventEmitter();
  this.includes = {};
}

SiteBuilder.prototype.applyHelpers = function(obj) {
  var self = this
    , key;

  for (key in this.helpers) {
    obj[key] = this.bind(this.helpers[key]);
  }

  for (key in userHelpers) {
    obj[key] = this.bind(userHelpers[key]);
  }

  obj.include = function(template) {
    return self.includes[template];
  };

  if (obj.paginate && obj.paginator)
    obj.paginate = obj.paginate(obj.paginator);

  obj.site = self;

  return obj;
};

SiteBuilder.prototype.bind = function(fn) {
  var self = this;
  return function() {
    return fn.apply(self, arguments);
  };
};

SiteBuilder.prototype.build = function() {
  var self = this;

  function build() {
    var posts = self.findPosts()
      , otherFiles = self.otherRenderedFiles()
      , staticFiles = self.staticFiles()
      , autoGen = self.autoGenerate()
      , postsLeft = posts.length
      , filesLeft;

    // FIXME: In future not all auto generated files will be related to posts
    if (posts.length === 0) autoGen = [];

    filesLeft = posts.length + otherFiles.length + staticFiles.length + autoGen.length;

    function checkFinished() {
      if (filesLeft === 0) {
        self.events.emit('ready');
      }
    }

    posts.forEach(function(file) {
      self.renderPost(file, function() {
        filesLeft--;
        postsLeft--;
        checkFinished();

        if (postsLeft === 0) {
          autoGen.forEach(function(file) {
            self.autoGenerateFile(file, function() {
              filesLeft--;
              checkFinished();
            });
          });
        }
      });
    });

    otherFiles.forEach(function(file) {
      self.renderFile(file, function() {
        filesLeft--;
        checkFinished();
      });
    });

    staticFiles.forEach(function(file) { 
      self.copyStatic(file, function() {
        filesLeft--;
        checkFinished();
      });
    });
  }

  this.events.once('cached includes', build);
  this.cacheIncludes();
};

SiteBuilder.prototype.autoGenerate = function() {
  if (!this.config.autoGenerate) return [];
  return this.config.autoGenerate;
};

SiteBuilder.prototype.autoGenerateFile = function(file, fn) {
  // TODO: Allow this to be easily extended
  var self = this;

  if (file.feed) {
    if (!this.config.url || !this.config.title) {
      console.log('ERROR: Built-in feed generation requires config values for: url and title.'); 
    } else {
      var layoutData = "!{atom('" + this.config.url + "', '" + this.config.title + "', '" + this.config.url + file.feed + "')}";
      var html = jade.render(layoutData, { locals: self.applyHelpers({ }) });
      this.write(this.outFileName(file.feed), html); 
      fn();
    }
  }
};

SiteBuilder.prototype.buildChange = function(file) {
  if (this.fileMap.isExcludedFile(file)) return;

  file = {
    type: this.fileMap.fileType(file)
  , name: file
  };

  if (file.type.indexOf('post') !== -1) {
    this.renderPost(file);
  } else if (file.type === 'file jade') {
    this.renderFile(file);
  } else if (file.type === 'file') {
    this.copyStatic(file);
  }
};

SiteBuilder.prototype.findPosts = function() {
  return this.fileMap.files.filter(function(file) {
    return file.type.indexOf('post') !== -1;
  });
};

SiteBuilder.prototype.otherRenderedFiles = function() {
  return this.fileMap.files.filter(function(file) {
    return file.type === 'file jade' || file.type === 'file styl';
  });
};

SiteBuilder.prototype.staticFiles = function() {
  return this.fileMap.files.filter(function(file) {
    return file.type === 'file';
  });
};

SiteBuilder.prototype.copyStatic = function(file, fn) {
  var outDir = this.outFileName(path.dirname(file.name.replace(this.root, '')))
    , fileName = path.join(outDir, path.basename(file.name))
    , self = this;

  // TODO: Use a configurable ignore list
  if (path.basename(file.name).match(/^_/)) return fn();

  fs.mkdir_p(outDir, 0777, function(err) {
    if (err) {
      console.log('Error creating directory:', outDir);
      throw(err);
    }

    fs.readFile(file.name, function(err, data) {
      if (err) {
        console.log('Error reading file:', file.name);
        throw(err);
      }

      fs.writeFile(fileName, data, function(err) {
        if (err) {
          console.log('Error writing file:', fileName);
          throw(err);
        }

        if (fn) fn.apply(self);
      });
    });
  });
};

SiteBuilder.prototype.parseMeta = function(file, data) {
  function clean(yaml) {
    for (var key in yaml) {
      if (typeof yaml[key] === 'string') {
        var m = yaml[key].match(/^"([^"]*)"$/);
        if (m) yaml[key] = m[1];
      }
    }
    return yaml;
  }

  // FIXME: This shouldn't be used, my articles are badly formatted
  function fix(text) {
    if (!text) return;
    return text.split('\n').map(function(line) {
      if (line.match(/^- /))
        line = '  ' + line;
      return line;
    }).join('\n');
  }

  var dataChunks = data.split('---')
    , parsedYAML = [];

  try {
    if (dataChunks[1]) {
      parsedYAML = clean(yamlish.decode(fix(dataChunks[1] || data)));
      return [parsedYAML, (dataChunks[2] || '').trim()];
    } else {
      return ['', data];
    }
  } catch (e) {
    console.log("Couldn't parse YAML in:", file, ':', e);
  }
};

SiteBuilder.prototype.write = function(fileName, content) {
  if (!content) {
    console.log('No content for:', fileName);
    return;
  }

  fs.mkdir_p(path.dirname(fileName), 0777, function(err) {
    if (err) {
      console.log('Error creating directory:', path.dirname(fileName));
      throw(err);
    }

    fs.writeFile(fileName, content, function(err) {
      if (err) {
        console.log('Error writing file:', fileName);
        throw(err);
      }
    });
  });
};

SiteBuilder.prototype.outFileName = function(subDir, name) {
  return path.join(this.outputRoot, subDir, name);
};

SiteBuilder.prototype.cacheIncludes = function() {
  var self = this;

  function done() {
    self.events.emit('cached includes');
  }

  path.exists(path.join(this.root, '_includes'), function(exists) {
    if (!exists) {
      done();
    } else {
      fs.readdir(path.join(self.root, '_includes'), function(err, files) {
        if (!files) return;
        var file;

        if (files.length === 0) done();

        for (var i = 0; i < files.length; i++) {
          file = files[i];
          // TODO: Configurable templates
          if (path.extname(file) !== '.jade') {
            if (i === files.length) return self.events.emit('cached includes');
          } else {
            fs.readFile(path.join(self.root, '_includes', file), 'utf8', function(err, data) {
              // TODO: This won't cope with _include/file/file, but people will expect this
              var html = jade.render(data, { locals: self.applyHelpers({}) })
                , name = path.basename(file).replace(path.extname(file), '');
              self.includes[name] = html;

              if (i === files.length) done();
            });
          }
        }
      });
    }
  });
};

SiteBuilder.prototype.renderTemplate = function(templateFile, post, content) {
  var self = this;
  templateFile = path.join(this.root, '_layouts', templateFile + '.jade');

  fs.readFile(templateFile, 'utf8', function(err, data) {
    if (err) {
      console.log('Error in: ' + templateFile);
      console.log(err);
      console.log(err.message);
      throw(err);
    }

    try {
      var html = jade.render(data, { locals: self.applyHelpers({ post: post, content: content }) })
        , fileName = self.outFileName(post.fileName, 'index.html')
        , dirName = path.dirname(fileName);
    } catch (e) {
      console.log('Error rendering:', templateFile);
      throw(e);
    }

    path.exists(dirName, function(exists) {
      if (exists) {
        self.write(fileName, html);
      } else {
        fs.mkdir_p(dirName, 0777, function(err) {
          if (err) {
            console.log('Error making directory:', dirName);
            throw(err);
          }
          self.write(fileName, html);
        });
      }
    });
  });
};

SiteBuilder.prototype.renderFile = function(file, fn) {
  var self = this;

  if (file.type === 'file styl') {
    var outFileName = self.outFileName(
      path.dirname(file.name.replace(self.root, '')),
      path.basename(file.name).replace(path.extname(file.name), '.css')
    );

    return fs.readFile(file.name, 'utf8', function(err, fileData) {
      stylus.render(fileData, { filename: path.basename(outFileName) }, function(err, css) {
        if (err) throw err;
        self.write(outFileName, css);
      });
    });
  }

  function render(fileData, paginator, meta, layoutData, dirName) {
    // Use .html for file extensions unless the file has the format file.ext.jade
    var ext = file.name.match('\\.[^.]*\\' + path.extname(file.name) + '$') ? '' : '.html';
    dirName = dirName || '';

    var outFileName = self.outFileName(
      path.dirname(file.name.replace(self.root, '')) + dirName,
      path.basename(file.name).replace(path.extname(file.name), ext)
    );

    var fileContent = jade.render(fileData, {
      locals: self.applyHelpers({ paginator: paginator, page: meta }),
    });

    if (!layoutData) {
      self.write(outFileName, fileContent);
    } else {
      var html = jade.render(layoutData, { locals: self.applyHelpers({ content: fileContent }) });
      self.write(outFileName, html);
    }

    if (fn) fn.apply(self);
  }

  fs.readFile(file.name, 'utf8', function(err, fileData) {
    var meta = self.parseMeta(file.name, fileData)
      , fileContent = '';

    fileData = meta[1];
    meta = meta[0];

    if (!meta.layout) {
      var paginator = new Paginator(self.config.perPage, self.posts);
      render(fileData, paginator, meta);
    } else {
      fs.readFile(path.join(self.root, '_layouts', meta.layout + '.jade'), function(err, layoutData) {
        if (err) {
          console.log('Unable to read layout:', meta.layout + '.jade');
          throw(err);
        }

        // TODO: Per page config
        var paginator = new Paginator(self.config.perPage, self.posts)
        render(fileData, paginator, meta, layoutData);

        if (meta.paginate) {
          while (paginator.items.length) {
            paginator.advancePage();
            render(fileData, paginator, meta, layoutData, '/page' + paginator.page + '/');
          }
        }
      });
    }
  });
};

SiteBuilder.prototype.parseFileName = function(fileName) {
  var format = this.config.permalink
    , parts = fileName.match(/(\d+)-(\d+)-(\d+)-([^.]+)/)
    , year = parts[1]
    , month = parts[2]
    , day = parts[3]
    , title = parts[4];

  return { date:  new Date(year, month, day),
           fileName: format.replace(':year', year).
                       replace(':month', month).
                       replace(':day', day).
                       replace(':title', title) };
};

SiteBuilder.prototype.applyFilters = function(text) {
  for (var key in filters) {
    text = filters[key](text);
  }

  for (key in userFilters) {
    text = userFilters[key].apply(this, [text]);
  }

  return text;
};

SiteBuilder.prototype.renderPost = function(file, fn) {
  var self = this
    , formatter;

  if (file.type.indexOf('textile') !== -1) {
    formatter = textile;
  } else if (file.type.indexOf('md') !== -1) {
    formatter = markdown.makeHtml;
  }

  fs.readFile(file.name, 'utf8', function(err, data) {
    var meta = self.parseMeta(file.name, data);
    data = meta[1];
    meta = meta[0];

    // Categories and tags are synonyms
    if (!meta.tags) meta.tags = meta.categories ? meta.categories : [];

    if (data && meta) {
      var fileDetails = self.parseFileName(file.name);
      meta.fileName = fileDetails.fileName;
      meta.url = fileDetails.fileName;
      meta.date = fileDetails.date;
      meta.content = formatter(self.applyFilters(data));
      self.renderTemplate(meta.layout, meta, meta.content);
      self.posts.push(meta);

      if (fn) fn.apply(self);
    }
  });
};

SiteBuilder.prototype.on = function(eventName, fn) {
  this.events.on(eventName, fn); 
};

module.exports = SiteBuilder;