// Copyright 2012 Mark Cavage, Inc.  All rights reserved.

'use strict';

var Stream = require('stream').Stream;
var util = require('util');

var assert = require('assert-plus');
var bunyan = require('bunyan');
var LRU = require('lru-cache');
var uuid = require('uuid');

///--- Globals

var sprintf = util.format;
var DEFAULT_REQ_ID = uuid.v4();
var STR_FMT = '[object %s<level=%d, limit=%d, maxRequestIds=%d>]';

///--- Helpers

/**
 * Appends streams
 *
 * @private
 * @function appendStream
 * @param    {Stream}    streams - the stream to append to
 * @param    {Stream}    s       - the stream to append
 * @returns  {undefined} no return value
 */
function appendStream(streams, s) {
    assert.arrayOfObject(streams, 'streams');
    assert.object(s, 'stream');

    if (s instanceof Stream) {
        streams.push({
            raw: false,
            stream: s
        });
    } else {
        assert.optionalBool(s.raw, 'stream.raw');
        assert.object(s.stream, 'stream.stream');
        streams.push(s);
    }
}

///--- API
/**
 * A Bunyan stream to capture records in a ring buffer and only pass through
 * on a higher-level record. E.g. buffer up all records but only dump when
 * getting a WARN or above.
 *
 * @public
 * @class
 * @param {Object} opts -                contains the parameters:
 * @param {Object} opts.stream -         The stream to which to write when
 *                                       dumping captured records.
 *                                       One of `stream`
 *                                       or `streams` must be specified.
 * @param {Array} opts.streams -         One of `stream` or `streams` must be
 *                                       specified.
 * @param {Number | String} opts.level - The level at which to trigger dumping
 *                                       captured records. Defaults to
 *                                       bunyan.WARN.
 * @param {Number} opts.maxRecords -     Number of records to capture. Default
 *                                       100.
 * @param {Number} opts.maxRequestIds -  Number of simultaneous request id
 *                                       capturing buckets to maintain. Default
 *                                       1000.
 * @param {Boolean} opts.dumpDefault -   If true, then dump captured records on
 *                                       the *default* request id when dumping.
 *                                       I.e. dump records logged without
 *                                       "req_id" field. Default false.
 */
function RequestCaptureStream(opts) {
    assert.object(opts, 'options');
    assert.optionalObject(opts.stream, 'options.stream');
    assert.optionalArrayOfObject(opts.streams, 'options.streams');
    assert.optionalNumber(opts.level, 'options.level');
    assert.optionalNumber(opts.maxRecords, 'options.maxRecords');
    assert.optionalNumber(opts.maxRequestIds, 'options.maxRequestIds');
    assert.optionalBool(opts.dumpDefault, 'options.dumpDefault');

    var self = this;
    Stream.call(this);

    this.level = opts.level ? bunyan.resolveLevel(opts.level) : bunyan.WARN;
    this.limit = opts.maxRecords || 100;
    this.maxRequestIds = opts.maxRequestIds || 1000;
    // eslint-disable-next-line new-cap
    // need to initialize using `new`
    this.requestMap = new LRU({
        max: self.maxRequestIds
    });
    this.dumpDefault = opts.dumpDefault;

    this._offset = -1;
    this._rings = [];

    this.streams = [];

    if (opts.stream) {
        appendStream(this.streams, opts.stream);
    }

    if (opts.streams) {
        opts.streams.forEach(appendStream.bind(null, this.streams));
    }

    this.haveNonRawStreams = false;

    for (var i = 0; i < this.streams.length; i++) {
        if (!this.streams[i].raw) {
            this.haveNonRawStreams = true;
            break;
        }
    }
}
util.inherits(RequestCaptureStream, Stream);

/**
 * Write to the stream
 *
 * @public
 * @function write
 * @param    {Object}    record - a bunyan log record
 * @returns  {undefined} no return value
 */
RequestCaptureStream.prototype.write = function write(record) {
    var req_id = record.req_id || DEFAULT_REQ_ID;
    var ring;
    var self = this;

    if (!(ring = this.requestMap.get(req_id))) {
        if (++this._offset > this.maxRequestIds) {
            this._offset = 0;
        }

        if (this._rings.length <= this._offset) {
            this._rings.push(
                new bunyan.RingBuffer({
                    limit: self.limit
                })
            );
        }

        ring = this._rings[this._offset];
        ring.records.length = 0;
        this.requestMap.set(req_id, ring);
    }

    assert.ok(ring, 'no ring found');

    // write the record to the ring.
    ring.write(record);
    // triger dumping of all the records
    if (record.level >= this.level) {
        var i, r, ser;

        for (i = 0; i < ring.records.length; i++) {
            r = ring.records[i];

            if (this.haveNonRawStreams) {
                ser = JSON.stringify(r, bunyan.safeCycles()) + '\n';
            }
            self.streams.forEach(function forEach(s) {
                s.stream.write(s.raw ? r : ser);
            });
        }
        ring.records.length = 0;

        if (this.dumpDefault) {
            var defaultRing = self.requestMap.get(DEFAULT_REQ_ID);

            for (i = 0; i < defaultRing.records.length; i++) {
                r = defaultRing.records[i];

                if (this.haveNonRawStreams) {
                    ser = JSON.stringify(r, bunyan.safeCycles()) + '\n';
                }
                self.streams.forEach(function forEach(s) {
                    s.stream.write(s.raw ? r : ser);
                });
            }
            defaultRing.records.length = 0;
        }
    }
};

/**
 * toString() serialization
 *
 * @public
 * @function toString
 * @returns  {String} stringified instance
 */
RequestCaptureStream.prototype.toString = function toString() {
    return sprintf(
        STR_FMT,
        this.constructor.name,
        this.level,
        this.limit,
        this.maxRequestIds
    );
};

///--- Serializers

var SERIALIZERS = {
    err: bunyan.stdSerializers.err,
    req: bunyan.stdSerializers.req,
    res: bunyan.stdSerializers.res,
    client_req: clientReq,
    client_res: clientRes
};

/**
 * A request serializer. returns a stripped down object for logging.
 *
 * @private
 * @function clientReq
 * @param    {Object} req - the request object
 * @returns  {Object} serialized req
 */
function clientReq(req) {
    if (!req) {
        return req;
    }

    var host;

    try {
        host = req.host.split(':')[0];
    } catch (e) {
        host = false;
    }

    return {
        method: req ? req.method : false,
        url: req ? req.path : false,
        address: host,
        port: req ? req.port : false,
        headers: req ? req.headers : false
    };
}

/**
 * A response serializer. returns a stripped down object for logging.
 *
 * @private
 * @function clientRes
 * @param    {Object} res - the response object
 * @returns  {Object} serialized response
 */
function clientRes(res) {
    if (!res || !res.statusCode) {
        return res;
    }

    return {
        statusCode: res.statusCode,
        headers: res.headers
    };
}

/**
 * Create a bunyan logger.
 *
 * @public
 * @function createLogger
 * @param    {String}     name - of the logger
 * @returns  {Object}          bunyan logger
 */
function createLogger(name) {
    return bunyan.createLogger({
        name: name,
        serializers: SERIALIZERS,
        streams: [
            {
                level: 'warn',
                stream: process.stderr
            },
            {
                level: 'debug',
                type: 'raw',
                stream: new RequestCaptureStream({
                    stream: process.stderr
                })
            }
        ]
    });
}

///--- Exports

module.exports = {
    RequestCaptureStream: RequestCaptureStream,
    serializers: SERIALIZERS,
    createLogger: createLogger
};