#  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.

import argparse
import os
import textwrap

from io import StringIO
from unittest import mock

from cliff.formatters import table
from cliff.tests import base
from cliff.tests import test_columns


def _generate_namespace(
    max_width: int = 0, print_empty: bool = False, fit_width: bool = False
) -> argparse.Namespace:
    if max_width == 0:
        # Envvar is only taken into account if CLI parameter not given
        max_width = int(os.environ.get('CLIFF_MAX_TERM_WIDTH', 0))

    return argparse.Namespace(
        max_width=max_width,
        print_empty=print_empty,
        fit_width=fit_width,
    )


def _table_tester_helper(tags, data, extra_args=None):
    """Get table output as a string, formatted according to
    CLI arguments, environment variables and terminal size

    :param tags: tuple of strings for data tags (column headers or fields)
    :param data: tuple of strings for single data row or list of tuples of
        strings for multiple rows of data
    :param extra_args: an instance of argparse.Namespace, a list of strings for
        CLI arguments, or None
    """
    sf = table.TableFormatter()

    if extra_args is None:
        # Default to no CLI arguments
        parsed_args = _generate_namespace()
    elif isinstance(extra_args, argparse.Namespace):
        # Use the given CLI arguments
        parsed_args = extra_args
    else:
        # Parse arguments as if passed on the command-line
        parser = argparse.ArgumentParser(description='Testing...')
        sf.add_argument_group(parser)
        parsed_args = parser.parse_args(extra_args)

    output = StringIO()
    emitter = sf.emit_list if type(data) is list else sf.emit_one
    emitter(tags, data, output, parsed_args)
    return output.getvalue()


class TestTableFormatter(base.TestBase):
    @mock.patch('cliff.utils.terminal_width')
    def test(self, tw):
        tw.return_value = 80
        c = ('a', 'b', 'c', 'd')
        d = ('A', 'B', 'C', 'test\rcarriage\r\nreturn')
        expected = textwrap.dedent(
            '''\
        +-------+---------------+
        | Field | Value         |
        +-------+---------------+
        | a     | A             |
        | b     | B             |
        | c     | C             |
        | d     | test carriage |
        |       | return        |
        +-------+---------------+
        '''
        )
        self.assertEqual(expected, _table_tester_helper(c, d))


class TestTerminalWidth(base.TestBase):
    # Multi-line output when width is restricted to 42 columns
    expected_ml_val = textwrap.dedent(
        '''\
    +-------+--------------------------------+
    | Field | Value                          |
    +-------+--------------------------------+
    | a     | A                              |
    | b     | B                              |
    | c     | C                              |
    | d     | dddddddddddddddddddddddddddddd |
    |       | dddddddddddddddddddddddddddddd |
    |       | ddddddddddddddddd              |
    +-------+--------------------------------+
    '''
    )

    # Multi-line output when width is restricted to 80 columns
    expected_ml_80_val = textwrap.dedent(
        '''\
    +-------+----------------------------------------------------------------------+
    | Field | Value                                                                |
    +-------+----------------------------------------------------------------------+
    | a     | A                                                                    |
    | b     | B                                                                    |
    | c     | C                                                                    |
    | d     | dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd |
    |       | ddddddddd                                                            |
    +-------+----------------------------------------------------------------------+
    '''
    )  # noqa

    # Single-line output, for when no line length restriction apply
    expected_sl_val = textwrap.dedent(
        '''\
    +-------+-------------------------------------------------------------------------------+
    | Field | Value                                                                         |
    +-------+-------------------------------------------------------------------------------+
    | a     | A                                                                             |
    | b     | B                                                                             |
    | c     | C                                                                             |
    | d     | ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd |
    +-------+-------------------------------------------------------------------------------+
    '''
    )  # noqa

    @mock.patch('cliff.utils.terminal_width')
    def test_table_formatter_no_cli_param(self, tw):
        tw.return_value = 80
        c = ('a', 'b', 'c', 'd')
        d = ('A', 'B', 'C', 'd' * 77)
        self.assertEqual(
            self.expected_ml_80_val,
            _table_tester_helper(
                c, d, extra_args=_generate_namespace(fit_width=True)
            ),
        )

    @mock.patch('cliff.utils.terminal_width')
    def test_table_formatter_cli_param(self, tw):
        tw.return_value = 80
        c = ('a', 'b', 'c', 'd')
        d = ('A', 'B', 'C', 'd' * 77)
        self.assertEqual(
            self.expected_ml_val,
            _table_tester_helper(c, d, extra_args=['--max-width', '42']),
        )

    @mock.patch('cliff.utils.terminal_width')
    def test_table_formatter_no_cli_param_unlimited_tw(self, tw):
        tw.return_value = 0
        c = ('a', 'b', 'c', 'd')
        d = ('A', 'B', 'C', 'd' * 77)
        # output should not be wrapped to multiple lines
        self.assertEqual(
            self.expected_sl_val,
            _table_tester_helper(c, d, extra_args=_generate_namespace()),
        )

    @mock.patch('cliff.utils.terminal_width')
    def test_table_formatter_cli_param_unlimited_tw(self, tw):
        tw.return_value = 0
        c = ('a', 'b', 'c', 'd')
        d = ('A', 'B', 'C', 'd' * 77)
        self.assertEqual(
            self.expected_ml_val,
            _table_tester_helper(c, d, extra_args=['--max-width', '42']),
        )

    @mock.patch('cliff.utils.terminal_width')
    @mock.patch.dict(os.environ, {'CLIFF_MAX_TERM_WIDTH': '666'})
    def test_table_formatter_cli_param_envvar_big(self, tw):
        tw.return_value = 80
        c = ('a', 'b', 'c', 'd')
        d = ('A', 'B', 'C', 'd' * 77)
        self.assertEqual(
            self.expected_ml_val,
            _table_tester_helper(c, d, extra_args=['--max-width', '42']),
        )

    @mock.patch('cliff.utils.terminal_width')
    @mock.patch.dict(os.environ, {'CLIFF_MAX_TERM_WIDTH': '23'})
    def test_table_formatter_cli_param_envvar_tiny(self, tw):
        tw.return_value = 80
        c = ('a', 'b', 'c', 'd')
        d = ('A', 'B', 'C', 'd' * 77)
        self.assertEqual(
            self.expected_ml_val,
            _table_tester_helper(c, d, extra_args=['--max-width', '42']),
        )


class TestMaxWidth(base.TestBase):
    expected_80 = textwrap.dedent(
        '''\
    +--------------------------+---------------------------------------------+
    | Field                    | Value                                       |
    +--------------------------+---------------------------------------------+
    | field_name               | the value                                   |
    | a_really_long_field_name | a value significantly longer than the field |
    +--------------------------+---------------------------------------------+
    '''
    )

    @mock.patch('cliff.utils.terminal_width')
    def test_80(self, tw):
        tw.return_value = 80
        c = ('field_name', 'a_really_long_field_name')
        d = ('the value', 'a value significantly longer than the field')
        self.assertEqual(self.expected_80, _table_tester_helper(c, d))

    @mock.patch('cliff.utils.terminal_width')
    def test_70(self, tw):
        # resize value column
        tw.return_value = 70
        c = ('field_name', 'a_really_long_field_name')
        d = ('the value', 'a value significantly longer than the field')
        expected = textwrap.dedent(
            '''\
        +--------------------------+-----------------------------------------+
        | Field                    | Value                                   |
        +--------------------------+-----------------------------------------+
        | field_name               | the value                               |
        | a_really_long_field_name | a value significantly longer than the   |
        |                          | field                                   |
        +--------------------------+-----------------------------------------+
        '''
        )
        self.assertEqual(
            expected,
            _table_tester_helper(c, d, extra_args=['--fit-width']),
        )

    @mock.patch('cliff.utils.terminal_width')
    def test_50(self, tw):
        # resize both columns
        tw.return_value = 50
        c = ('field_name', 'a_really_long_field_name')
        d = ('the value', 'a value significantly longer than the field')
        expected = textwrap.dedent(
            '''\
        +-----------------------+------------------------+
        | Field                 | Value                  |
        +-----------------------+------------------------+
        | field_name            | the value              |
        | a_really_long_field_n | a value significantly  |
        | ame                   | longer than the field  |
        +-----------------------+------------------------+
        '''
        )
        self.assertEqual(
            expected,
            _table_tester_helper(c, d, extra_args=['--fit-width']),
        )

    @mock.patch('cliff.utils.terminal_width')
    def test_10(self, tw):
        # resize all columns limited by min_width=16
        tw.return_value = 10
        c = ('field_name', 'a_really_long_field_name')
        d = ('the value', 'a value significantly longer than the field')
        expected = textwrap.dedent(
            '''\
        +------------------+------------------+
        | Field            | Value            |
        +------------------+------------------+
        | field_name       | the value        |
        | a_really_long_fi | a value          |
        | eld_name         | significantly    |
        |                  | longer than the  |
        |                  | field            |
        +------------------+------------------+
        '''
        )
        self.assertEqual(
            expected,
            _table_tester_helper(c, d, extra_args=['--fit-width']),
        )


class TestListFormatter(base.TestBase):
    _col_names = ('one', 'two', 'three')
    _col_data = [('one one one one one', 'two two two two', 'three three')]

    _expected_mv = {
        80: textwrap.dedent(
            '''\
        +---------------------+-----------------+-------------+
        | one                 | two             | three       |
        +---------------------+-----------------+-------------+
        | one one one one one | two two two two | three three |
        +---------------------+-----------------+-------------+
        '''
        ),
        50: textwrap.dedent(
            '''\
        +----------------+-----------------+-------------+
        | one            | two             | three       |
        +----------------+-----------------+-------------+
        | one one one    | two two two two | three three |
        | one one        |                 |             |
        +----------------+-----------------+-------------+
        '''
        ),
        47: textwrap.dedent(
            '''\
        +---------------+---------------+-------------+
        | one           | two           | three       |
        +---------------+---------------+-------------+
        | one one one   | two two two   | three three |
        | one one       | two           |             |
        +---------------+---------------+-------------+
        '''
        ),
        45: textwrap.dedent(
            '''\
        +--------------+--------------+-------------+
        | one          | two          | three       |
        +--------------+--------------+-------------+
        | one one one  | two two two  | three three |
        | one one      | two          |             |
        +--------------+--------------+-------------+
        '''
        ),
        40: textwrap.dedent(
            '''\
        +------------+------------+------------+
        | one        | two        | three      |
        +------------+------------+------------+
        | one one    | two two    | three      |
        | one one    | two two    | three      |
        | one        |            |            |
        +------------+------------+------------+
        '''
        ),
        10: textwrap.dedent(
            '''\
        +----------+----------+----------+
        | one      | two      | three    |
        +----------+----------+----------+
        | one one  | two two  | three    |
        | one one  | two two  | three    |
        | one      |          |          |
        +----------+----------+----------+
        '''
        ),
    }

    @mock.patch('cliff.utils.terminal_width')
    def test_table_list_formatter(self, tw):
        tw.return_value = 80
        c = ('a', 'b', 'c')
        d1 = ('A', 'B', 'C')
        d2 = ('D', 'E', 'test\rcarriage\r\nreturn')
        data = [d1, d2]
        expected = textwrap.dedent(
            '''\
        +---+---+---------------+
        | a | b | c             |
        +---+---+---------------+
        | A | B | C             |
        | D | E | test carriage |
        |   |   | return        |
        +---+---+---------------+
        '''
        )
        self.assertEqual(expected, _table_tester_helper(c, data))

    @mock.patch('cliff.utils.terminal_width')
    def test_table_formatter_formattable_column(self, tw):
        tw.return_value = 0
        c = ('a', 'b', 'c', 'd')
        d = ('A', 'B', 'C', test_columns.FauxColumn(['the', 'value']))
        expected = textwrap.dedent(
            '''\
        +-------+---------------------------------------------+
        | Field | Value                                       |
        +-------+---------------------------------------------+
        | a     | A                                           |
        | b     | B                                           |
        | c     | C                                           |
        | d     | I made this string myself: ['the', 'value'] |
        +-------+---------------------------------------------+
        '''
        )
        self.assertEqual(expected, _table_tester_helper(c, d))

    @mock.patch('cliff.utils.terminal_width')
    def test_formattable_column(self, tw):
        tw.return_value = 80
        c = ('a', 'b', 'c')
        d1 = ('A', 'B', test_columns.FauxColumn(['the', 'value']))
        data = [d1]
        expected = textwrap.dedent(
            '''\
        +---+---+---------------------------------------------+
        | a | b | c                                           |
        +---+---+---------------------------------------------+
        | A | B | I made this string myself: ['the', 'value'] |
        +---+---+---------------------------------------------+
        '''
        )
        self.assertEqual(expected, _table_tester_helper(c, data))

    @mock.patch('cliff.utils.terminal_width')
    def test_max_width_80(self, tw):
        # no resize
        width = tw.return_value = 80
        self.assertEqual(
            self._expected_mv[width],
            _table_tester_helper(self._col_names, self._col_data),
        )

    @mock.patch('cliff.utils.terminal_width')
    def test_max_width_50(self, tw):
        # resize 1 column
        width = tw.return_value = 50
        actual = _table_tester_helper(
            self._col_names, self._col_data, extra_args=['--fit-width']
        )
        self.assertEqual(self._expected_mv[width], actual)
        self.assertEqual(width, len(actual.splitlines()[0]))

    @mock.patch('cliff.utils.terminal_width')
    def test_max_width_45(self, tw):
        # resize 2 columns
        width = tw.return_value = 45
        actual = _table_tester_helper(
            self._col_names, self._col_data, extra_args=['--fit-width']
        )
        self.assertEqual(self._expected_mv[width], actual)
        self.assertEqual(width, len(actual.splitlines()[0]))

    @mock.patch('cliff.utils.terminal_width')
    def test_max_width_40(self, tw):
        # resize all columns
        width = tw.return_value = 40
        actual = _table_tester_helper(
            self._col_names, self._col_data, extra_args=['--fit-width']
        )
        self.assertEqual(self._expected_mv[width], actual)
        self.assertEqual(width, len(actual.splitlines()[0]))

    @mock.patch('cliff.utils.terminal_width')
    def test_max_width_10(self, tw):
        # resize all columns limited by min_width=8
        width = tw.return_value = 10
        actual = _table_tester_helper(
            self._col_names, self._col_data, extra_args=['--fit-width']
        )
        self.assertEqual(self._expected_mv[width], actual)
        # 3 columns each 8 wide, plus table spacing and borders
        expected_width = 11 * 3 + 1
        self.assertEqual(expected_width, len(actual.splitlines()[0]))

    # Force a wide terminal by overriding its width with envvar
    @mock.patch('cliff.utils.terminal_width')
    @mock.patch.dict(os.environ, {'CLIFF_MAX_TERM_WIDTH': '666'})
    def test_max_width_and_envvar_max(self, tw):
        # no resize
        tw.return_value = 80
        self.assertEqual(
            self._expected_mv[80],
            _table_tester_helper(self._col_names, self._col_data),
        )

        # resize 1 column
        tw.return_value = 50
        self.assertEqual(
            self._expected_mv[80],
            _table_tester_helper(self._col_names, self._col_data),
        )

        # resize 2 columns
        tw.return_value = 45
        self.assertEqual(
            self._expected_mv[80],
            _table_tester_helper(self._col_names, self._col_data),
        )

        # resize all columns
        tw.return_value = 40
        self.assertEqual(
            self._expected_mv[80],
            _table_tester_helper(self._col_names, self._col_data),
        )

        # resize all columns limited by min_width=8
        tw.return_value = 10
        self.assertEqual(
            self._expected_mv[80],
            _table_tester_helper(self._col_names, self._col_data),
        )

    # Force a narrow terminal by overriding its width with envvar
    @mock.patch('cliff.utils.terminal_width')
    @mock.patch.dict(os.environ, {'CLIFF_MAX_TERM_WIDTH': '47'})
    def test_max_width_and_envvar_mid(self, tw):
        # no resize
        tw.return_value = 80
        self.assertEqual(
            self._expected_mv[47],
            _table_tester_helper(self._col_names, self._col_data),
        )

        # resize 1 column
        tw.return_value = 50
        actual = _table_tester_helper(self._col_names, self._col_data)
        self.assertEqual(self._expected_mv[47], actual)
        self.assertEqual(47, len(actual.splitlines()[0]))

        # resize 2 columns
        tw.return_value = 45
        actual = _table_tester_helper(self._col_names, self._col_data)
        self.assertEqual(self._expected_mv[47], actual)
        self.assertEqual(47, len(actual.splitlines()[0]))

        # resize all columns
        tw.return_value = 40
        actual = _table_tester_helper(self._col_names, self._col_data)
        self.assertEqual(self._expected_mv[47], actual)
        self.assertEqual(47, len(actual.splitlines()[0]))

        # resize all columns limited by min_width=8
        tw.return_value = 10
        actual = _table_tester_helper(self._col_names, self._col_data)
        self.assertEqual(self._expected_mv[47], actual)
        self.assertEqual(47, len(actual.splitlines()[0]))

    @mock.patch.dict(os.environ, {'CLIFF_MAX_TERM_WIDTH': '80'})
    def test_env_maxwidth_noresize(self):
        # no resize
        self.assertEqual(
            self._expected_mv[80],
            _table_tester_helper(self._col_names, self._col_data),
        )

    @mock.patch.dict(os.environ, {'CLIFF_MAX_TERM_WIDTH': '50'})
    def test_env_maxwidth_resize_one(self):
        # resize 1 column
        actual = _table_tester_helper(self._col_names, self._col_data)
        self.assertEqual(self._expected_mv[50], actual)
        self.assertEqual(50, len(actual.splitlines()[0]))

    @mock.patch.dict(os.environ, {'CLIFF_MAX_TERM_WIDTH': '45'})
    def test_env_maxwidth_resize_two(self):
        # resize 2 columns
        actual = _table_tester_helper(self._col_names, self._col_data)
        self.assertEqual(self._expected_mv[45], actual)
        self.assertEqual(45, len(actual.splitlines()[0]))

    @mock.patch.dict(os.environ, {'CLIFF_MAX_TERM_WIDTH': '40'})
    def test_env_maxwidth_resize_all(self):
        # resize all columns
        actual = _table_tester_helper(self._col_names, self._col_data)
        self.assertEqual(self._expected_mv[40], actual)
        self.assertEqual(40, len(actual.splitlines()[0]))

    @mock.patch.dict(os.environ, {'CLIFF_MAX_TERM_WIDTH': '8'})
    def test_env_maxwidth_resize_all_tiny(self):
        # resize all columns limited by min_width=8
        actual = _table_tester_helper(self._col_names, self._col_data)
        self.assertEqual(self._expected_mv[10], actual)
        # 3 columns each 8 wide, plus table spacing and borders
        expected_width = 11 * 3 + 1
        self.assertEqual(expected_width, len(actual.splitlines()[0]))

    @mock.patch.dict(os.environ, {'CLIFF_MAX_TERM_WIDTH': '42'})
    def test_env_maxwidth_args_big(self):
        self.assertEqual(
            self._expected_mv[80],
            _table_tester_helper(
                self._col_names,
                self._col_data,
                extra_args=_generate_namespace(666),
            ),
        )

    @mock.patch.dict(os.environ, {'CLIFF_MAX_TERM_WIDTH': '42'})
    def test_env_maxwidth_args_tiny(self):
        self.assertEqual(
            self._expected_mv[40],
            _table_tester_helper(
                self._col_names,
                self._col_data,
                extra_args=_generate_namespace(40),
            ),
        )

    @mock.patch('cliff.utils.terminal_width')
    def test_empty(self, tw):
        tw.return_value = 80
        c = ('a', 'b', 'c')
        expected = '\n'
        self.assertEqual(expected, _table_tester_helper(c, []))

    @mock.patch('cliff.utils.terminal_width')
    def test_empty_table(self, tw):
        tw.return_value = 80
        c = ('a', 'b', 'c')
        expected = textwrap.dedent(
            '''\
        +---+---+---+
        | a | b | c |
        +---+---+---+
        +---+---+---+
        '''
        )
        self.assertEqual(
            expected,
            _table_tester_helper(c, [], extra_args=['--print-empty']),
        )


class TestFieldWidths(base.TestBase):
    def test(self):
        tf = table.TableFormatter
        self.assertEqual(
            {'a': 1, 'b': 2, 'c': 3, 'd': 10},
            tf._field_widths(
                ['a', 'b', 'c', 'd'], '+---+----+-----+------------+'
            ),
        )

    def test_zero(self):
        tf = table.TableFormatter
        self.assertEqual(
            {'a': 0, 'b': 0, 'c': 0},
            tf._field_widths(['a', 'b', 'c'], '+--+-++'),
        )

    def test_info(self):
        tf = table.TableFormatter
        self.assertEqual((49, 4), (tf._width_info(80, 10)))
        self.assertEqual((76, 76), (tf._width_info(80, 1)))
        self.assertEqual((79, 0), (tf._width_info(80, 0)))
        self.assertEqual((0, 0), (tf._width_info(0, 80)))