// vim: set softtabstop=16 shiftwidth=16:

try {
                var fs = require("graceful-fs")
} catch (er) {
                var fs = require("fs")
}


module.exports = readJson

var LRU = require("lru-cache")
readJson.cache = new LRU({max: 1000})
var path = require("path")
var glob = require("glob")
var normalizeData = require("normalize-package-data")

// put more stuff on here to customize.
readJson.extraSet = [
                gypfile,
                serverjs,
                authors,
                readme,
                mans,
                bins,
                githead
]

var typoWarned = {}


function readJson (file, log_, strict_, cb_) {
                var log, strict, cb
                for (var i = 1; i < arguments.length - 1; i++) {
                                if (typeof arguments[i] === 'boolean')
                                                strict = arguments[i]
                                else if (typeof arguments[i] === 'function')
                                                log = arguments[i]
                }
                if (!log) log = function () {};
                cb = arguments[ arguments.length - 1 ]

                var c = readJson.cache.get(file)
                if (c) {
                                cb = cb.bind(null, null, c)
                                return process.nextTick(cb);
                }
                cb = (function (orig) { return function (er, data) {
                                if (data) readJson.cache.set(file, data);
                                return orig(er, data)
                } })(cb)
                readJson_(file, log, strict, cb)
}


function readJson_ (file, log, strict, cb) {
                fs.readFile(file, "utf8", function (er, d) {
                                parseJson(file, er, d, log, strict, cb)
                })
}


function stripBOM(content) {
                // Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)
                // because the buffer-to-string conversion in `fs.readFileSync()`
                // translates it to FEFF, the UTF-16 BOM.
                if (content.charCodeAt(0) === 0xFEFF) {
                                content = content.slice(1);
                }
                return content;
}


function parseJson (file, er, d, log, strict, cb) {
                if (er && er.code === "ENOENT") {
                                indexjs(file, er, log, strict, cb)
                                return
                }
                if (er) return cb(er);
                try {
                                d = JSON.parse(stripBOM(d))
                } catch (er) {
                                d = parseIndex(d)
                                if (!d) return cb(parseError(er, file));
                }
                extras(file, d, log, strict, cb)
}


function indexjs (file, er, log, strict, cb) {
                if (path.basename(file) === "index.js") {
                                return cb(er);
                }
                var index = path.resolve(path.dirname(file), "index.js")
                fs.readFile(index, "utf8", function (er2, d) {
                                if (er2) return cb(er);
                                d = parseIndex(d)
                                if (!d) return cb(er);
                                extras(file, d, log, strict, cb)
                })
}


readJson.extras = extras
function extras (file, data, log_, strict_, cb_) {
                var log, strict, cb
                for (var i = 2; i < arguments.length - 1; i++) {
                                if (typeof arguments[i] === 'boolean')
                                                strict = arguments[i]
                                else if (typeof arguments[i] === 'function')
                                                log = arguments[i]
                }
                cb = arguments[i]
                var set = readJson.extraSet
                var n = set.length
                var errState = null
                set.forEach(function (fn) {
                                fn(file, data, then)
                })
                function then(er) {
                                if (errState) return;
                                if (er) return cb(errState = er);
                                if (--n > 0) return;
                                final(file, data, log, strict, cb);
                }
}

function gypfile (file, data, cb) {
                var dir = path.dirname(file)
                var s = data.scripts || {}
                if (s.install || s.preinstall)
                                return cb(null, data);
                glob("*.gyp", { cwd: dir }, function (er, files) {
                                if (er) return cb(er);
                                gypfile_(file, data, files, cb)
                })
}

function gypfile_ (file, data, files, cb) {
                if (!files.length) return cb(null, data);
                var s = data.scripts || {}
                s.install = "node-gyp rebuild"
                data.scripts = s
                data.gypfile = true
                return cb(null, data);
}

function serverjs (file, data, cb) {
                var dir = path.dirname(file)
                var s = data.scripts || {}
                if (s.start) return cb(null, data)
                glob("server.js", { cwd: dir }, function (er, files) {
                                if (er) return cb(er);
                                serverjs_(file, data, files, cb)
                })
}
function serverjs_ (file, data, files, cb) {
                if (!files.length) return cb(null, data);
                var s = data.scripts || {}
                s.start = "node server.js"
                data.scripts = s
                return cb(null, data)
}

function authors (file, data, cb) {
                if (data.contributors) return cb(null, data);
                var af = path.resolve(path.dirname(file), "AUTHORS")
                fs.readFile(af, "utf8", function (er, ad) {
                                // ignore error.  just checking it.
                                if (er) return cb(null, data);
                                authors_(file, data, ad, cb)
                })
}
function authors_ (file, data, ad, cb) {
                ad = ad.split(/\r?\n/g).map(function (line) {
                                return line.replace(/^\s*#.*$/, '').trim()
                }).filter(function (line) {
                                return line
                })
                data.contributors = ad
                return cb(null, data)
}

var defDesc = "Unnamed repository; edit this file " +
              "'description' to name the repository."
function gitDescription (file, data, cb) {
                if (data.description) return cb(null, data);
                var dir = path.dirname(file)
                // just cuz it'd be nice if this file mattered...
                var gitDesc = path.resolve(dir, '.git/description')
                fs.readFile(gitDesc, 'utf8', function (er, desc) {
                                if (desc) desc = desc.trim()
                                if (!er && desc !== defDesc)
                                                data.description = desc
                                return cb(null, data)
                })
}

function readmeDescription (file, data) {
                if (data.description) return cb(null, data);
                var d = data.readme
                if (!d) return;
                // the first block of text before the first heading
                // that isn't the first line heading
                d = d.trim().split('\n')
                for (var s = 0; d[s] && d[s].trim().match(/^(#|$)/); s ++);
                var l = d.length
                for (var e = s + 1; e < l && d[e].trim(); e ++);
                data.description = d.slice(s, e).join(' ').trim()
}

function readme (file, data, cb) {
                if (data.readme) return cb(null, data);
                var dir = path.dirname(file)
                var globOpts = { cwd: dir, nocase: true, mark: true }
                glob("README?(.*)", globOpts, function (er, files) {
                                if (er) return cb(er);
                                // don't accept directories.
                                files = files.filter(function (file) {
                                                return !file.match(/\/$/)
                                })
                                if (!files.length) return cb();
                                var rm = path.resolve(dir, files[0])
                                readme_(file, data, rm, cb)
                })
}
function readme_(file, data, rm, cb) {
                var rmfn = path.basename(rm);
                fs.readFile(rm, "utf8", function (er, rm) {
                                // maybe not readable, or something.
                                if (er) return cb()
                                data.readme = rm
                                data.readmeFilename = rmfn
                                return cb(er, data)
                })
}

function mans (file, data, cb) {
                var m = data.directories && data.directories.man
                if (data.man || !m) return cb(null, data);
                m = path.resolve(path.dirname(file), m)
                glob("**/*.[0-9]", { cwd: m }, function (er, mans) {
                                if (er) return cb(er);
                                mans_(file, data, mans, cb)
                })
}
function mans_ (file, data, mans, cb) {
                var m = data.directories && data.directories.man
                data.man = mans.map(function (mf) {
                                return path.resolve(path.dirname(file), m, mf)
                })
                return cb(null, data)
}

function bins (file, data, cb) {
                if (Array.isArray(data.bin)) {
                                return bins_(file, data, data.bin, cb)
                }
                var m = data.directories && data.directories.bin
                if (data.bin || !m) return cb(null, data);
                m = path.resolve(path.dirname(file), m)
                glob("**", { cwd: m }, function (er, bins) {
                                if (er) return cb(er);
                                bins_(file, data, bins, cb)
                })
}
function bins_ (file, data, bins, cb) {
                var m = data.directories && data.directories.bin || '.'
                data.bin = bins.reduce(function (acc, mf) {
                                if (mf && mf.charAt(0) !== '.') {
                                                var f = path.basename(mf)
                                                acc[f] = path.join(m, mf)
                                }
                                return acc
                }, {})
                return cb(null, data)
}

function githead (file, data, cb) {
                if (data.gitHead) return cb(null, data);
                var dir = path.dirname(file)
                var head = path.resolve(dir, '.git/HEAD')
                fs.readFile(head, 'utf8', function (er, head) {
                                if (er) return cb(null, data);
                                githead_(file, data, dir, head, cb)
                })
}
function githead_ (file, data, dir, head, cb) {
                if (!head.match(/^ref: /)) {
                                data.gitHead = head.trim()
                                return cb(null, data)
                }
                var headFile = head.replace(/^ref: /, '').trim()
                headFile = path.resolve(dir, '.git', headFile)
                fs.readFile(headFile, 'utf8', function (er, head) {
                                if (er || !head) return cb(null, data)
                                head = head.replace(/^ref: /, '').trim()
                                data.gitHead = head
                                return cb(null, data)
                })
}

function final (file, data, log, strict, cb) {
                var pId = makePackageId(data)
                function warn(msg) {
                                if (typoWarned[pId]) return;
                                if (log) log("package.json", pId, msg);
                }
                try {
                                normalizeData(data, warn, strict)
                }
                catch (error) {
                                return cb(error)
                }
                typoWarned[pId] = true
                readJson.cache.set(file, data)
                cb(null, data)
}

function makePackageId (data) {
                return cleanString(data.name) + "@" + cleanString(data.version)
}

function cleanString(str) {
                return (!str || typeof(str) !== "string") ? "" : str.trim()
}

// /**package { "name": "foo", "version": "1.2.3", ... } **/
function parseIndex (data) {
                data = data.split(/^\/\*\*package(?:\s|$)/m)
                if (data.length < 2) return null
                data = data[1]
                data = data.split(/\*\*\/$/m)
                if (data.length < 2) return null
                data = data[0]
                data = data.replace(/^\s*\*/mg, "")
                try {
                                return JSON.parse(data)
                } catch (er) {
                                return null
                }
}

function parseError (ex, file) {
                var e = new Error("Failed to parse json\n"+ex.message)
                e.code = "EJSONPARSE"
                e.file = file
                return e
}
