bridle

# Copyright (c) 2021-2026 TiaC Systems
# Copyright (c) 2021 Nordic Semiconductor ASA
#
# SPDX-License-Identifier: Apache-2.0

# The code for this directive is based on the include directive from
# docutils, which is public-domain, stripped of lots of its original
# options, and with added support for TiaC Systems documentation sets
# and indentation of the included rST.

import os
import os.path

from docutils import io, statemachine
from docutils.parsers.rst import directives
from sphinx.util.docutils import SphinxDirective


class TsnInclude(SphinxDirective):
    required_arguments = 1
    optional_arguments = 0
    final_argument_whitespace = True
    option_spec = {
        'docset': directives.unchanged,
        'indent': int,
        'dedent': int,
        'auto-dedent': directives.flag,
        'tab-width': int,
        'start-line': int,
        'end-line': int,
        'start-at': directives.unchanged_required,
        'start-after': directives.unchanged_required,
        'end-at': directives.unchanged_required,
        'end-before': directives.unchanged_required,
    }

    def run(self):
        if not isinstance(self.config.tsn_include_mapping, dict):
            raise self.severe('Invalid "tsn_include_mapping" config')

        docset = self.options.get('docset', None)
        if docset is not None and docset not in self.config.tsn_include_mapping:
            raise self.severe(f'The supplied "docset" was not found: "{docset}"')

        indent = self.options.get('indent', 0)
        dedent = self.options.get('dedent', 0)
        auto_dedent = 'auto-dedent' in self.options

        if indent and (dedent or auto_dedent):
            raise self.severe(
                'Both "indent" and one of the "dedent" options ' 'are set, please use only one'
            )

        if dedent and auto_dedent:
            raise self.severe('Choose one of "dedent" and "auto-dedent" only')

        if not self.state.document.settings.file_insertion_enabled:
            raise self.warning(f'"{self.name}" directive disabled.')

        if docset is None:
            # without a docset fallback to Sphinx style include
            _, path = self.env.relfn2path(self.arguments[0])
        else:
            path = os.path.join(self.config.tsn_include_mapping[docset], self.arguments[0])

        encoding = self.options.get('encoding', self.state.document.settings.input_encoding)
        e_handler = self.state.document.settings.input_encoding_error_handler
        tab_width = self.options.get('tab-width', self.state.document.settings.tab_width)
        try:
            self.state.document.settings.record_dependencies.add(path)
            include_file = io.FileInput(
                source_path=path, encoding=encoding, error_handler=e_handler
            )
        except UnicodeEncodeError:
            raise self.severe(
                f'Problems with "{self.name}" directive path:\n'
                f'Cannot encode input file path "{str(path)}" '
                '(wrong locale?).'
            ) from None
        except OSError as error:
            raise self.severe(
                f'Problems with "{self.name}" directive path:\n{io.error_string(error)}.'
            ) from error

        # Get to-be-included content
        startline = self.options.get('start-line', None)
        endline = self.options.get('end-line', None)
        try:
            if startline or (endline is not None):
                lines = include_file.readlines()
                rawtext = ''.join(lines[startline:endline])
            else:
                rawtext = include_file.read()
        except UnicodeError as error:
            raise self.severe(
                f'Problem with "{self.name}" directive:\n{io.error_string(error)}'
            ) from error
        # start-at/start-after and end-at/end-before: no restrictions on
        # newlines in match-text, and no restrictions on matching inside
        # lines vs. line boundaries
        at_text = self.options.get('start-at', None)
        if at_text:
            # skip content in rawtext before *and incl.* a matching text
            at_index = rawtext.find(at_text)
            if at_index < 0:
                raise self.severe(
                    f'Problem with "start-at" option of "{self.name}" '
                    'directive:\nText not found.'
                )
            rawtext = rawtext[at_index :]
        after_text = self.options.get('start-after', None)
        if after_text:
            # skip content in rawtext before *and incl.* a matching text
            after_index = rawtext.find(after_text)
            if after_index < 0:
                raise self.severe(
                    f'Problem with "start-after" option of "{self.name}" '
                    'directive:\nText not found.'
                )
            rawtext = rawtext[after_index + len(after_text) :]
        at_text = self.options.get('end-at', None)
        if at_text:
            # skip content in rawtext after *and incl.* a matching text
            at_index = rawtext.find(at_text)
            if at_index < 0:
                raise self.severe(
                    f'Problem with "end-at" option of "{self.name}" '
                    'directive:\nText not found.'
                )
            rawtext = rawtext[:at_index + len(at_text)]
        before_text = self.options.get('end-before', None)
        if before_text:
            # skip content in rawtext after *and incl.* a matching text
            before_index = rawtext.find(before_text)
            if before_index < 0:
                raise self.severe(
                    f'Problem with "end-before" option of "{self.name}" '
                    'directive:\nText not found.'
                )
            rawtext = rawtext[:before_index]

        include_lines = statemachine.string2lines(rawtext, tab_width, convert_whitespace=True)

        def is_blank(line):
            # XXX might need to check for a stripped line
            return len(line) == 0

        if auto_dedent:
            min_spaces = None
            for _i, line in enumerate(include_lines):
                if is_blank(line):
                    continue
                spaces = len(line) - len(line.lstrip(' '))
                if min_spaces is None:
                    min_spaces = spaces
                else:
                    min_spaces = min(spaces, min_spaces)
                print(min_spaces, line)
                # it can't get smaller, so leave early
                if min_spaces == 0:
                    break
            amount = min_spaces

            for i, line in enumerate(include_lines):
                if is_blank(line):
                    continue
                include_lines[i] = line[amount:]

        if dedent:
            for i, line in enumerate(include_lines):
                if is_blank(line):
                    continue
                spaces = len(line) - len(line.lstrip())
                amount = min(spaces, dedent)
                include_lines[i] = line[amount:]

        if indent:
            spaces = ' ' * indent
            for i, line in enumerate(include_lines):
                if is_blank(line):
                    continue
                include_lines[i] = spaces + line

        self.state_machine.insert_input(include_lines, path)
        return []


def setup(app):
    app.add_config_value('tsn_include_mapping', {}, True)
    directives.register_directive('tsn-include', TsnInclude)