# Copyright (c) 2024 Broadcom. All Rights Reserved.
# The term "Broadcom" refers to Broadcom Inc.
# and/or its subsidiaries.

import re

from lib.environment import Environment


class TextFilter(object):
    """
    A utility class for filtering multi-line text. The filtering methods in this
    class will return self to allow method chaining

    Example of usage:
    result = TextFilter(text).contain(filter).head(1).remove(unwanted_chars).get_text()
    """

    def __init__(self, text):
        self.lines = text.splitlines()
        self.before_lines = 0
        self.after_lines = 0
        self.invert_match = False

    def get_text(self):
        """
        Return the result as a string, joined by '\n'
        """
        return "\n".join(self.lines)

    def get_lines(self):
        """
        Return the current filtering result as a string list
        """
        return self.lines

    def set_options(self, before_lines=0, after_lines=0, invert_match=False):
        """
        Set the matching option

        :param before_lines: the result will also contain the before_lines lines
            before the matched line
        :param after_lines:  the result will also contain the after_lines lines
            after the matched lines
        :param invert_match: If True, the match operations will return lines that
            that don't match to the search pattern
        """
        self.before_lines = before_lines
        self.after_lines = after_lines
        self.invert_match = invert_match
        return self

    def reset_options(self):
        """
        Reset the matching option
        """
        self.before_lines = self.after_lines = 0
        self.invert_match = False
        return self

    def mod_match_result(self, match_result):
        return not match_result if self.invert_match else match_result

    def get_lines_with_extended_indices(self, indices):
        """
        Extend the matching lines indices by applying before_lines and after_lines
        matching options

        :param indices: indices to extend
        :return: extended indices
        """
        if self.before_lines > 0 or self.after_lines > 0:
            new_indices = []
            for index in indices:
                if self.before_lines > 0:
                    begin_index = index - self.before_lines
                    if begin_index < 0:
                        begin_index = 0
                    new_indices.extend([idx for idx in range(begin_index, index)])
                if self.after_lines > 0:
                    end_index = index + self.after_lines + 1
                    if end_index > len(self.lines):
                        end_index = len(self.lines)
                    new_indices.extend([idx for idx in range(index + 1, end_index)])
            indices.extend(new_indices)
            indices = sorted(set(indices))
        return [line for idx, line in enumerate(self.lines) if idx in indices]

    def match(self, pattern):
        """
        Filter lines using regular expression match

        :param pattern: regular expression pattern for matching the lines
        """
        indices = [idx for idx, line in enumerate(self.lines)
                   if self.mod_match_result(re.match(pattern, line))]
        self.lines = self.get_lines_with_extended_indices(indices)
        return self

    def contain(self, keyword):
        """
        Filter the lines using simple keywords

        :param keyword: keyword for matching the lines
        """
        indices = [idx for idx, line in enumerate(self.lines)
                   if self.mod_match_result(keyword in line)]
        self.lines = self.get_lines_with_extended_indices(indices)
        return self

    def start_with(self, text):
        """
        Filter the lines that started with {text}

        :param text: text for filtering
        """
        indices = [idx for idx, line in enumerate(self.lines)
                   if self.mod_match_result(line.find(text) == 0)]
        self.lines = self.get_lines_with_extended_indices(indices)
        return self

    def head(self, count=1):
        """
        Include only the first {count} lines to be included in the result

        :param count: total of lines to be included in the result. If the value is
            a negative value between -1 and -[number of lines], it will include all
            lines except of the last {count} lines at the end
        """
        if count < 0:
            count += len(self.lines)
            if count < 0:
                count = 0
        self.lines = [line for i, line in enumerate(self.lines) if i < count]
        return self

    def tail(self, count=1):
        """
        Includes only the last {count} lines

        :param count: total of lines to be included. If the value is a negative
            value between -1 and -[#lines], it will include all lines except the
            first {count} lines at the beginning
        :return:
        """
        length = len(self.lines)
        if count < 0:
            count += length
        self.lines = [line for i, line in enumerate(self.lines) if i >= length - count]
        return self

    def match_block(self, pattern_begin, pattern_end, concatenate=False):
        """
        Filter the lines using begin and end pattern

        :param pattern_begin: the pattern for starting the matching block
        :param pattern_end: the pattern for stopping the matching block
        :param concatenate: if True, the matching block will be concatenated
            as a single string joined using `\n' character
        """
        lines = []
        block = []
        matching = False
        for line in self.lines:
            if not matching and re.match(pattern_begin, line):
                matching = True
                block = []
            if matching:
                block.append(line)
            if matching and re.match(pattern_end, line):
                matching = False
                if concatenate:
                    lines.append('\n'.join(block))
                else:
                    lines.extend(block)
        self.lines = lines
        return self

    def apply(self, method):
        """
        Apply method on all lines. The lines will be replaced using the values returned
        by the method

        :param method:  method to be applied
        """
        self.lines = [method(line) for line in self.lines]
        return self

    def replace(self, keyword1, keyword2):
        """
        Update the lines by replacing keywords

        :param keyword1: keyword to be replaced
        :param keyword2: keyword to be used for replacing
        """
        self.lines = [line.replace(keyword1, keyword2) for line in self.lines]
        return self

    def remove(self, keyword):
        """
        Update all lines by removing {keyword}

        :param keyword: text to be removed
        """
        return self.replace(keyword, '')

    def remove_white_spaces(self):
        """
        Remove white spaces in all lines
        """
        return self.apply(remove_white_spaces_method)

    def cut(self, delimiter=' ', fields=None, new_delimiter=' ', include_empty=False):
        """
        Split the line using delimiter and include only the required fields.
        This method tries to mimics cut(1) command

        :param delimiter: The delimiter to be used for split the line
        :param fields: list of indices to be included (0 based index)
        :param new_delimiter: If specified, the result will be concenated back
            using the new_delimiter
        :param include_empty: If True, the result may also contain empty lines
            when the request fields are not available (default: False)
        """
        lines = []
        if fields is None:
            fields = []
        for line in self.lines:
            result = []
            words = line.split(delimiter)
            for idx in fields:
                if idx == -1:
                    idx = len(words) - 1
                if idx < len(words):
                    result.append(words[idx])
            if result or include_empty:
                lines.append(new_delimiter.join(result))
        self.lines = lines
        return self

    def get_count(self):
        """
        Get the count of lines in the current result
        """
        return len(self.lines)

    def dump(self):
        """
        Dump the current contents. This can be use for debugging purpose
        """
        print('Contents:', '\n'.join(self.lines), sep='\n')
        return self


def remove_white_spaces_method(text):
    """
    Method for removing white spaces to be specified to TextUtil.apply
    """
    return re.sub(r'\s+', '', text)


def translate_text(*text, sep=''):
    """
    Reformat text using mapping in the environment variables

    :param text: String parameters
    :param sep: Separator if the text contains multiple string parameters
    :return: reformatted text
    """
    text = sep.join(text)
    if text and '{' in text:
        env_map = Environment.get_environment().get_map()
        text = text.format_map(env_map)
    return text