#  Copyright (c) 2014, Canon Inc. All rights reserved.
#  Redistribution and use in source and binary forms, with or without
#  modification, are permitted provided that the following conditions
#  are met:
#  1.  Redistributions of source code must retain the above copyright
#      notice, this list of conditions and the following disclaimer.
#  2.  Redistributions in binary form must reproduce the above copyright
#      notice, this list of conditions and the following disclaimer in the
#      documentation and/or other materials provided with the distribution.
#  3.  Neither the name of Canon Inc. nor the names of
#      its contributors may be used to endorse or promote products derived
#      from this software without specific prior written permission.
#  THIS SOFTWARE IS PROVIDED BY CANON INC. AND ITS CONTRIBUTORS "AS IS" AND ANY
#  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
#  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
#  DISCLAIMED. IN NO EVENT SHALL CANON INC. AND ITS CONTRIBUTORS BE LIABLE FOR
#  ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
#  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
#  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
#  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
#  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
#  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

import json
import logging
import sys
import time

from webkitpy.layout_tests.servers import http_server_base

_log = logging.getLogger(__name__)


def doc_root(port_obj):
    doc_root = port_obj.get_option("wptserver_doc_root")
    if doc_root is None:
        return port_obj.host.filesystem.join("imported", "w3c", "web-platform-tests")
    return doc_root


def wpt_config_json(port_obj):
    config_wk_filepath = port_obj._filesystem.join(port_obj.layout_tests_dir(), "imported", "w3c", "resources", "config.json")
    if not port_obj.host.filesystem.isfile(config_wk_filepath):
        return
    json_data = port_obj._filesystem.read_text_file(config_wk_filepath)
    return json.loads(json_data)


def base_http_url(port_obj):
    config = wpt_config_json(port_obj)
    if not config:
        # This should only be hit by webkitpy unit tests
        _log.debug("No WPT config file found")
        return "http://localhost:8800/"
    ports = config["ports"]
    return "http://" + config["browser_host"] + ":" + str(ports["http"][0]) + "/"


def base_https_url(port_obj):
    config = wpt_config_json(port_obj)
    if not config:
        # This should only be hit by webkitpy unit tests
        _log.debug("No WPT config file found")
        return "https://localhost:9443/"
    ports = config["ports"]
    return "https://" + config["browser_host"] + ":" + str(ports["https"][0]) + "/"


def is_wpt_server_running(port_obj):
    config = wpt_config_json(port_obj)
    if not config:
        return False
    return http_server_base.HttpServerBase._is_running_on_port(config["ports"]["http"][0])


class WebPlatformTestServer(http_server_base.HttpServerBase):
    def __init__(self, port_obj, name, pidfile=None):
        http_server_base.HttpServerBase.__init__(self, port_obj)
        self._output_dir = port_obj.results_directory()

        self._name = name
        self._log_file_name = '%s_process_log.out.txt' % (self._name)

        self._output_log_path = None
        self._wsout = None
        self._process = None
        self._pid_file = pidfile
        if not self._pid_file:
            self._pid_file = self._filesystem.join(self._runtime_path, '%s.pid' % self._name)

        self._filesystem = port_obj.host.filesystem
        self._layout_root = port_obj.layout_tests_dir()
        self._doc_root = self._filesystem.join(self._layout_root, doc_root(port_obj))

        self._doc_root_path = self._filesystem.join(self._layout_root, self._doc_root)
        self._config_filename = self._filesystem.join(self._doc_root_path, "config.json")

        # FIXME https://webkit.org/b/222703
        python_interp = sys.executable
        if sys.version_info < (3, 0):
            python_interp = 'python3'

        wpt_file = self._filesystem.join(self._doc_root_path, "wpt.py")
        self._start_cmd = [python_interp, wpt_file, "serve", "--config", self._config_filename]

        self._mappings = []
        config = wpt_config_json(port_obj)
        if config:
            ports = config["ports"]
            for key in ports:
                for value in ports[key]:
                    port = {"port": value}
                    if key == "https":
                        port["sslcert"] = True
                    self._mappings.append(port)

    def ports_to_forward(self):
        return [mapping['port'] for mapping in self._mappings]

    def _prepare_config(self):
        self._filesystem.maybe_make_directory(self._output_dir)
        self._output_log_path = self._filesystem.join(self._output_dir, self._log_file_name)
        self._wsout = self._filesystem.open_text_file_for_writing(self._output_log_path)

        _log.debug('Copying WebKit web platform server config.json')
        config_wk_filename = self._filesystem.join(self._layout_root, "imported", "w3c", "resources", "config.json")
        if self._filesystem.isfile(config_wk_filename):
            config = json.loads(self._filesystem.read_text_file(config_wk_filename))
            config['ssl']['openssl']['base_path'] = self._filesystem.join(self._output_dir, "_wpt_certs")
            self._filesystem.write_text_file(self._config_filename, json.dumps(config))

    def _spawn_process(self):
        self._process = self._executive.popen(self._start_cmd, cwd=self._doc_root_path, shell=False, stdin=self._executive.PIPE, stdout=self._wsout, stderr=self._wsout)
        self._filesystem.write_text_file(self._pid_file, str(self._process.pid))

        # Wait a second for the server to actually start so that tests do not start until server is running.
        time.sleep(1)

        # The server is not running after 1 second, something went wrong.
        if self._process.poll() is not None:
            self._stop_running_server()
            error_log = ('WPT Server process exited prematurely with status code %s\n' % self._process.returncode
                         + 'The cmdline for running the WPT server was: %s\n' % self._start_cmd
                         + 'The working dir was: %s\n' % self._doc_root_path)
            if self._output_log_path is not None and self._filesystem.exists(self._output_log_path):
                error_log += 'Check the logfile for the command at: %s\n' % self._output_log_path
            raise http_server_base.ServerError(error_log)

        return self._process.pid

    def _stop_running_server(self):
        _log.debug('Cleaning WPT web platform server config.json')
        if self._filesystem.isfile(self._config_filename):
            self._filesystem.remove(self._config_filename)

        if self._wsout:
            self._wsout.close()
            self._wsout = None

        if self._process is not None:
            self._process.poll()

        if self._pid:
            # kill_process will not kill the subprocesses, interrupt does the job.
            self._executive.interrupt(self._pid)

        self._remove_pid_file()