define([
        "dojo/_base/declare",
        "dojo/_base/lang",
        "dojo/when",
        "cluster",
        "os",
        "implab/safe",
        "./HttpResponse",
        "./BaseResponse",
        "dojo/Deferred",
        "./HttpException",
        "@implab/core/log/trace!"],
    function (declare, lang, when, cluster, os, safe, HttpResponse, BaseResponse, Deferred, HttpException, trace) {
        return declare(null, {
            _container: null,
            _serverPort: null,
            _bindAddr: null,

            _useCluster: null,

            _requestConfig: null,
            _restartFailedWorkers: null,

            // модули, обрабатывающие запрос.
            _modules: null,
            _handlers: null,

            constructor: function (options) {
                safe.argumentNotNull(options, "options");
                safe.argumentNotNull(options.container, "options.container");
                safe.argumentNotNull(options.serverPort, "options.serverPort");
                safe.argumentNotNull(options.useCluster, "options.useCluster");
                safe.argumentNotEmptyString(options.bindAddr, "options.bindAddr");
                safe.argumentNotEmptyString(options.requestConfig, "options.requestConfig");

                this.options = options || {};
                this._modules = [];

                this._container = options.container;

                this._serverPort = options.serverPort;
                this._bindAddr = options.bindAddr;
                this._useCluster = options.useCluster;
                this._restartFailedWorkers = options.restartFailedWorkers;

                this._requestConfig = options.requestConfig;

                this._container.getService("httpHandlers").forEach(handler => {
                    this.handle(handler);
                });
            },

            start: function () {
                let me = this;
                const numCPUs = os.cpus().length;
                if (cluster.isMaster && me._useCluster) {
                    // Fork workers.
                    for (let i = 0; i < numCPUs; i++) {
                        cluster.fork();
                    }

                    cluster.on('exit', function (worker, code, signal) {
                        if(me._restartFailedWorkers){
                            trace.log("worker {0} died. Signal {1}. Restarting ...", worker.process.pid, signal);
                            cluster.fork();
                        } else {
                            trace.log("worker {0} died.", worker.process.pid);
                        }
                    });
                } else {
                    // Workers can share any TCP connection
                    // In this case it is an HTTP server
                    this.listen(this._serverPort, this._bindAddr);
                }
            },

            listen: function (port, host) {
                this._host = host;
                this._port = port;

                this._createServer(this.options, lang.hitch(this, "_handler")).listen(port, host, lang.hitch(this, "_listening"));
            },

            handle: function (module) {
                if (module instanceof Function)
                    this._modules.push(module);
                else if (module.invoke instanceof Function)
                    this._modules.push(function (req, next) {
                        return module.invoke(req, next);
                    });
                else
                    throw "module shoud be a function or should have an invoke method";
            },

            _createServer: function () {
                throw "NOT IMPLEMENTED";
            },

            _createRequest: function (container, req, res) {
                return container.configure(this._requestConfig)
                    .then(function () {
                        let httpRequest = container.getService("httpRequest");
                        httpRequest.init(req, res);
                        return httpRequest;
                    });
            },

            //handler function to pass to the approperate server (like node.http)
            _handler: function (req, res) {
                let i = 0;
                let me = this;

                let requestContainer = this._container.createChildContainer();

                when(this._createRequest(requestContainer, req, res), function (httpRequest) {
                    let next = function () {
                        if (i < me._modules.length) {
                            let module = me._modules[i];
                            i++;
                            try {
                                return when(module(httpRequest, next));
                            } catch (err) {
                                let d = new Deferred();
                                d.reject(err);
                                return d;
                            }
                        }
                    };

                    when(next(), function (result) {
                        if (!result)
                            throw "no response is provided, this is a serious bug";

                        if (result instanceof BaseResponse) {
                            result.send(res);
                        } else {
                            let httpResp = new HttpResponse();
                            httpResp.content = "BUG: " + result.toString();
                            httpResp.send(res);
                        }
                        requestContainer.dispose();
                    }).then(null, function (err) {
                        if (res.finished) {
                            trace.log("caught exception after the response is sent: {0}", err);
                            return;
                        }
                        let httpResp;
                        if (err instanceof HttpException)
                            httpResp = new HttpResponse(err.message, {
                                statusCode: err.code,
                                headers: err.headers
                            });
                        else
                            httpResp = new HttpResponse(err.toString(), {
                                statusCode: 500
                            });
                        httpResp.send(res);
                        requestContainer.dispose();
                    });
                });
            },
            _listening: function () {
                trace.log("Listening {0}:{1}", this._host, this._port);
            },

        });
    });