# Copyright 2016 gRPC authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""HTTP2 Test Server"""

import argparse
import logging
import sys

import http2_base_server
import test_data_frame_padding
import test_goaway
import test_max_streams
import test_ping
import test_rst_after_data
import test_rst_after_header
import test_rst_during_data
import twisted
import twisted.internet
import twisted.internet.endpoints
import twisted.internet.reactor

_TEST_CASE_MAPPING = {
    'rst_after_header': test_rst_after_header.TestcaseRstStreamAfterHeader,
    'rst_after_data': test_rst_after_data.TestcaseRstStreamAfterData,
    'rst_during_data': test_rst_during_data.TestcaseRstStreamDuringData,
    'goaway': test_goaway.TestcaseGoaway,
    'ping': test_ping.TestcasePing,
    'max_streams': test_max_streams.TestcaseSettingsMaxStreams,

    # Positive tests below:
    'data_frame_padding': test_data_frame_padding.TestDataFramePadding,
    'no_df_padding_sanity_test': test_data_frame_padding.TestDataFramePadding,
}

_exit_code = 0


class H2Factory(twisted.internet.protocol.Factory):

    def __init__(self, testcase):
        logging.info('Creating H2Factory for new connection (%s)', testcase)
        self._num_streams = 0
        self._testcase = testcase

    def buildProtocol(self, addr):
        self._num_streams += 1
        logging.info('New Connection: %d' % self._num_streams)
        if not _TEST_CASE_MAPPING.has_key(self._testcase):
            logging.error('Unknown test case: %s' % self._testcase)
            assert (0)
        else:
            t = _TEST_CASE_MAPPING[self._testcase]

        if self._testcase == 'goaway':
            return t(self._num_streams).get_base_server()
        elif self._testcase == 'no_df_padding_sanity_test':
            return t(use_padding=False).get_base_server()
        else:
            return t().get_base_server()


def parse_arguments():
    parser = argparse.ArgumentParser()
    parser.add_argument(
        '--base_port',
        type=int,
        default=8080,
        help='base port to run the servers (default: 8080). One test server is '
        'started on each incrementing port, beginning with base_port, in the '
        'following order: data_frame_padding,goaway,max_streams,'
        'no_df_padding_sanity_test,ping,rst_after_data,rst_after_header,'
        'rst_during_data')
    return parser.parse_args()


def listen(endpoint, test_case):
    deferred = endpoint.listen(H2Factory(test_case))

    def listen_error(reason):
        # If listening fails, we stop the reactor and exit the program
        # with exit code 1.
        global _exit_code
        _exit_code = 1
        logging.error('Listening failed: %s' % reason.value)
        twisted.internet.reactor.stop()

    deferred.addErrback(listen_error)


def start_test_servers(base_port):
    """ Start one server per test case on incrementing port numbers
  beginning with base_port """
    index = 0
    for test_case in sorted(_TEST_CASE_MAPPING.keys()):
        portnum = base_port + index
        logging.warning('serving on port %d : %s' % (portnum, test_case))
        endpoint = twisted.internet.endpoints.TCP4ServerEndpoint(
            twisted.internet.reactor, portnum, backlog=128)
        # Wait until the reactor is running before calling endpoint.listen().
        twisted.internet.reactor.callWhenRunning(listen, endpoint, test_case)

        index += 1


if __name__ == '__main__':
    logging.basicConfig(
        format=
        '%(levelname) -10s %(asctime)s %(module)s:%(lineno)s | %(message)s',
        level=logging.INFO)
    args = parse_arguments()
    start_test_servers(args.base_port)
    twisted.internet.reactor.run()
    sys.exit(_exit_code)
