# Copyright 2025 The Pigweed 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
#
#     https://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.
"""Common utilities for converting CMakeLists.txt to BUILD.bazel."""

from pathlib import Path
import re
from typing import Any, Callable


def translate_relative_path(
    absolute_path: Path, start_dir: Path, target_dir: Path
) -> Path:
    """Translates an absolute_path to a target directory.

    For example, start_dir / some / file -> target_dir / some / file.
    """
    if not absolute_path.is_relative_to(start_dir):
        raise ValueError(f'{absolute_path} is not inside {start_dir}')

    relative_path = absolute_path.relative_to(start_dir)
    return target_dir / relative_path


def process_if_block_start(line: str) -> dict[str, Any]:
    """Processes the start of a CMake if block."""
    condition = re.match(r'^if\s*\((.*)\)', line).group(1).strip()
    if_block = {
        'type': 'if_block',
        'branches': [{'condition': condition, 'body': []}],
        'else_body': None,
    }
    return if_block


def process_if_block_branch(line: str) -> dict[str, Any]:
    """Processes a CMake elseif branch."""
    condition = re.match(r'^elseif\s*\((.*)\)', line).group(1).strip()
    if_block_branch = {'condition': condition, 'body': []}
    return if_block_branch


def merge_bracketed_string(input_text: str) -> str:
    """Merges a CMake statement spanning multiple lines into one line."""
    lines = input_text.splitlines()
    output_lines = []
    buffer = ''
    inside_bracket = False

    for line in lines:
        comment_start_index = line.find('#')

        if comment_start_index != -1:
            line = line[:comment_start_index]

        stripped_line = line.strip()

        if not buffer:
            buffer = stripped_line
        else:
            if inside_bracket:
                if buffer.endswith('(') or stripped_line.startswith(')'):
                    buffer += stripped_line
                else:
                    buffer += ' ' + stripped_line
            else:
                output_lines.append(buffer)
                buffer = stripped_line

        if '(' in line:
            inside_bracket = True
        if ')' in line:
            inside_bracket = False

    if buffer:
        output_lines.append(buffer)

    return '\n'.join(output_lines)


def _process_zephyr_cmake_functions(
    line: str,
) -> dict[str, str | list[str]] | None:
    if line.startswith('zephyr_library_sources('):
        srcs = (
            re.search(r'zephyr_library_sources\((.*)\)', line).group(1).strip()
        )
        if srcs == 'uart_native_pty.c':
            srcs += ' uart_native_pty_bottom.c'
        if srcs == 'uart_native_tty.c':
            srcs += ' uart_native_tty_bottom.c'
        return {'type': 'unconditional_source', 'srcs': srcs.split()}
    elif line.startswith('zephyr_library_sources_ifdef('):
        config, srcs = re.search(
            r'zephyr_library_sources_ifdef\((\S+)\s+(.*)\)', line
        ).groups()
        if srcs == 'uart_native_pty.c':
            srcs += ' uart_native_pty_bottom.c'
        if srcs == 'uart_native_tty.c':
            srcs += ' uart_native_tty_bottom.c'
        return {
            'type': 'conditional_source',
            'config': config.strip(),
            'srcs': srcs.strip().split(),
        }
    elif line.startswith('zephyr_library_sources_ifndef('):
        config, srcs = re.search(
            r'zephyr_library_sources_ifndef\((\S+)\s+(.*)\)', line
        ).groups()
        return {
            'type': 'conditional_source_inverse',
            'config': config.strip(),
            'srcs': srcs.strip().split(),
        }
    elif line.startswith('zephyr_sources('):
        srcs = re.search(r'zephyr_sources\((.*)\)', line).group(1).strip()
        return {'type': 'unconditional_source', 'srcs': srcs.split()}
    elif line.startswith('zephyr_sources_ifdef('):
        config, srcs = re.search(
            r'zephyr_sources_ifdef\((\S+)\s+(.*)\)', line
        ).groups()
        return {
            'type': 'conditional_source',
            'config': config.strip(),
            'srcs': srcs.strip().split(),
        }
    elif line.startswith('zephyr_sources_ifndef('):
        config, srcs = re.search(
            r'zephyr_sources_ifndef\((\S+)\s+(.*)\)', line
        ).groups()
        return {
            'type': 'conditional_source_inverse',
            'config': config.strip(),
            'srcs': srcs.strip().split(),
        }
    elif line.startswith('zephyr_syscall_header('):
        syscall_client_files = (
            re.search(r'zephyr_syscall_header\((.*)\)', line).group(1).strip()
        )
        return {
            'type': 'unconditional_syscall_client_files',
            'files': syscall_client_files.split(),
        }
    elif line.startswith('zephyr_syscall_header_ifdef('):
        config, syscall_client_files = re.search(
            r'zephyr_syscall_header_ifdef\((\S+)\s+(.*)\)', line
        ).groups()
        return {
            'type': 'conditional_syscall_client_files',
            'config': config.strip(),
            'files': syscall_client_files.strip().split(),
        }
    elif line.startswith('add_subdirectory('):
        subdir_name = re.search(r'add_subdirectory\((\S+)\)', line).group(1)
        return {
            'type': 'unconditional_subdir',
            'subdir_name': subdir_name,
        }
    elif line.startswith('add_subdirectory_ifdef('):
        config, subdir_name = re.search(
            r'add_subdirectory_ifdef\((\S+)\s+(\S+)\)', line
        ).groups()
        if subdir_name.startswith('./'):
            subdir_name = subdir_name.removeprefix('./')
        return {
            'type': 'conditional_subdir',
            'config': config,
            'subdir_name': subdir_name,
        }
    elif line.startswith('zephyr_linker_sources('):
        # zephyr_linker_sources() supports two usages:
        # 1. zephyr_linker_sources(<location> <files>)
        # 2. zephyr_linker_sources(<location> SORT_KEY <key> <files>)
        #
        # Regex breakdown:
        # 1. zephyr_linker_sources\(\s* -> Match function name and opening paren
        # 2. (?P<location>\S+)           -> Capture first arg (location)
        # 3. \s+                         -> Require whitespace separator
        # 4. (?:SORT_KEY\s+(?P<key>\S+)\s+)? -> Optional group: Literal "SORT_KEY", space, capture <key>, space
        # 5. (?P<files>.+?)              -> Capture a list of files
        # 6. \s*\)                       -> Match trailing whitespace and closing paren
        pattern = (
            r'zephyr_linker_sources\(\s*'
            r'(?P<location>\S+)\s+'  # Capture location
            r'(?:SORT_KEY\s+(?P<key>\S+)\s+)?'  # Optional SORT_KEY group
            r'(?P<files>.+?)\s*\)'  # Capture files list
        )

        match = re.search(pattern, line)
        if match:
            location = match.group('location')
            files_list = match.group('files').split()
            # If 'key' was not found in the optional group, default it to 'default'
            sort_key = match.group('key') if match.group('key') else 'default'
            return {
                'type': 'linker_fragment',
                'location': location,
                'sort_key': sort_key,
                'files': files_list,
            }
        print(f'Failed to parse "{line}", skipping...')
        return None
    elif line.startswith('zephyr_linker_sources_ifdef('):
        # zephyr_linker_sources_ifdef() supports two usages:
        # 1. zephyr_linker_sources_ifdef(<condition> <location> <files>)
        # 2. zephyr_linker_sources_ifdef(<condition> <location> SORT_KEY <key> <files>)
        pattern = (
            r'zephyr_linker_sources_ifdef\(\s*'
            r'(?P<condition>\S+)\s+'  # Capture condition
            r'(?P<location>\S+)\s+'  # Capture location
            r'(?:SORT_KEY\s+(?P<key>\S+)\s+)?'  # Optional SORT_KEY group
            r'(?P<files>.+?)\s*\)'  # Capture files list
        )

        match = re.search(pattern, line)
        if match:
            return {
                'type': 'conditional_linker_fragment',
                'condition': match.group('condition'),
                'location': match.group('location'),
                # Default to "default" if key is missing
                'sort_key': (
                    match.group('key') if match.group('key') else 'default'
                ),
                'files': match.group('files').split(),
            }
        print(f'Failed to parse "{line}", skipping...')
        return None
    else:
        return None


def build_ast(
    lines: list[str],
) -> list[dict[str, Any]]:
    """Builds an Abstract Syntax Tree from CMakeLists.txt lines."""
    ast = []
    stack = [ast]

    for line in lines:
        line = line.strip()

        if re.match(r'^if\s*\(', line):
            if_block = process_if_block_start(line)
            stack[-1].append(if_block)
            stack.append(if_block)
            stack.append(if_block['branches'][0]['body'])
            continue

        elif re.match(r'^elseif\s*\(', line):
            stack.pop()
            if_block = stack[-1]
            if if_block['type'] != 'if_block':
                raise ValueError('elseif without a preceding if')
            if_block_branch = process_if_block_branch(line)
            if_block['branches'].append(if_block_branch)
            stack.append(if_block_branch['body'])
            continue

        elif re.match(r'^else\s*\(', line):
            stack.pop()
            if_block = stack[-1]
            if if_block['type'] != 'if_block':
                raise ValueError('else without a preceding if')
            if_block['else_body'] = []
            stack.append(if_block['else_body'])
            continue

        elif re.match(r'^endif\s*\(', line):
            stack.pop()
            if stack and stack[-1]['type'] == 'if_block':
                stack.pop()
            continue

        source_file_item = _process_zephyr_cmake_functions(line)
        if source_file_item:
            node_body = stack[-1]
            node_body.append(source_file_item)

    return ast


# Int type Kconfig symbols that we should take care of in converting
# CMakeLists.txt. An ifdef() on these symbols means the source is added only if
# the int flag value is nonzero.
_INT_CONFIGS_TO_PROCESS = [
    'CONFIG_SYS_HEAP_ARRAY_SIZE',
]


def _get_unique_target_name(
    start_name: str, names_list: list[str]
) -> tuple[str, str]:
    """Generates a unique target name not already in names_list."""
    target_name = start_name + '.target'
    target_name_bazel_str = f'":{target_name}"'
    while target_name_bazel_str in names_list:
        # Name collision. Modify the target name.
        target_name += '#'
        target_name_bazel_str = f'":{target_name}"'
    return target_name, target_name_bazel_str


def traverse_ast(
    ast: list[dict[str, Any]],
    target_name: str,
    update_rules_fn: Callable[[list[str], ...], list[str]],
    is_root=False,
    # Ignore linker fragments by default.
    ignore_node_types=['linker_fragment', 'conditional_linker_fragment'],
) -> list[str]:
    """Recursively generates Bazel rules from the AST."""
    rules = []
    unconditional_srcs = []
    toplevel_conditional_srcs = []
    unconditional_deps = []
    deps_selects = []

    # Process all nodes at the current level
    for node in ast:
        if node['type'] in ignore_node_types:
            continue

        if node['type'] == 'unconditional_source':
            for src in node['srcs']:
                unconditional_srcs.append(f'        "{src}",')
        elif node['type'] == 'conditional_source':
            if node['config'] in _INT_CONFIGS_TO_PROCESS:
                # For int symbols in the conditional case, add source if the
                # value is NON-ZERO.
                toplevel_conditional_srcs.append(
                    '\n'.join([
                        ' + select({',
                        f'        "@zephyr_kconfig//:{node["config"]}=0": [],',
                        '        "//conditions:default": [',
                        *[f'            "{src}",' for src in node['srcs']],
                        '        ],',
                        '    })',
                    ])
                )
            else:
                toplevel_conditional_srcs.append(
                    '\n'.join([
                        ' + select({',
                        '        "//conditions:default": [],',
                        f'        "@zephyr_kconfig//:{node["config"]}=true": [',
                        *[f'            "{src}",' for src in node['srcs']],
                        '        ],',
                        '    })',
                    ])
                )
        elif node['type'] == 'conditional_source_inverse':
            toplevel_conditional_srcs.append(
                '\n'.join([
                    ' + select({',
                    f'        "@zephyr_kconfig//:{node["config"]}=true": [],',
                    '        "//conditions:default": [',
                    *[f'            "{src}",' for src in node['srcs']],
                    '        ],',
                    '    })',
                ])
            )
        elif node['type'] == 'unconditional_subdir':
            unconditional_deps.append(
                f'"//" + package_name() + "/{node["subdir_name"]}"'
            )
        elif node['type'] == 'conditional_subdir':
            conditional_subdir_target_name = (
                f'"//" + package_name() + "/{node["subdir_name"]}"'
            )
            select_str = '\n'.join([
                ' + select({',
                f'        "@zephyr_kconfig//:{node["config"]}=true": [',
                f'            {conditional_subdir_target_name},',
                '        ],',
                '        "//conditions:default": [],',
                '    })',
            ])
            deps_selects.append(select_str)
        elif node['type'] == 'linker_fragment':
            # Use the linker file name as the base of the target name.
            local_target_name, local_target_name_bazel_str = (
                _get_unique_target_name(node['files'][0], unconditional_deps)
            )
            rules.append(f"""zephyr_linker_fragment(
    name = "{local_target_name}",
    srcs = {node['files']},
    location = "{node['location']}",
    sort_key = "{node['sort_key']}",
)
""")
            # Track this rule so that the umbrella linker fragment rule can
            # depend on it.
            unconditional_deps.append(local_target_name_bazel_str)
        elif node['type'] == 'conditional_linker_fragment':
            # Use the linker file name as the base of the target name.
            local_target_name, local_target_name_bazel_str = (
                _get_unique_target_name(node['files'][0], unconditional_deps)
            )
            rules.append(f"""zephyr_linker_fragment(
    name = "{local_target_name}",
    srcs = select({{
        "@zephyr_kconfig//:{node['condition']}=true": {node['files']},
        "//conditions:default": [],
    }}),
    location = "{node['location']}",
    sort_key = "{node['sort_key']}",
)
""")
            # Track this rule so that the umbrella linker fragment rule can
            # depend on it.
            unconditional_deps.append(local_target_name_bazel_str)
        elif node['type'] == 'if_block':
            if_block_rules, deps_select = parse_if_block_ast_node(
                node,
                target_name,
                lambda child, child_name: traverse_ast(
                    child,
                    child_name,
                    update_rules_fn,
                    ignore_node_types=ignore_node_types,
                ),
            )
            rules.extend(if_block_rules)
            if deps_select:
                deps_selects.append(deps_select)

    # Merge unconditional and top-level conditional sources.
    srcs_content = '[\n'
    for unconditional_src in unconditional_srcs:
        srcs_content += unconditional_src + '\n'
    srcs_content += '    ]'
    srcs_content += ''.join(toplevel_conditional_srcs)

    defines_content = ''
    if target_name in ('uart_native_pty', 'uart_native_tty'):
        defines_content = ',\n    defines = ["_POSIX_C_SOURCE=200809L"]'

    # AST node has been parsed.
    # Call the provided hook to update the Bazel rules.
    rules = update_rules_fn(
        rules,
        target_name,
        srcs_content + defines_content,
        unconditional_deps,
        deps_selects,
        is_root,
    )
    return rules


def _user_ack(prompt: str) -> bool:
    while True:
        response = input(f'{prompt} (y/n): ').lower()

        if response == 'y' or response == 'yes':
            return True
        elif response == 'n' or response == 'no':
            return False
        else:
            print("Invalid input. Please enter 'y' or 'n'")


def parse_if_block_ast_node(
    node: dict[str, Any], target_name: str, recursive_callback: Callable
) -> tuple[list[str], str]:
    rules = []
    select_dict_entries = []
    else_condition = '//conditions:default'

    # Process if/elseif branches
    for i, branch in enumerate(node['branches']):
        # Track compound condition rules created so that we can
        # backtrack.
        config_setting_rules_created = 0
        condition = branch['condition']
        branch_body = branch['body']
        sanitized_condition = re.sub(r'[^a-zA-Z0-9_]', '_', condition).lower()
        child_target_name = f'{target_name}_{sanitized_condition}_deps'

        compound_types = 0
        for compound_type in [' OR ', ' AND ']:
            if compound_type in condition:
                compound_types += 1
        if compound_types > 1:
            if _user_ack(
                f'Cannot handle complex compound condition {condition},'
                ' please confirm okay to skip'
            ):
                continue
            else:
                raise ValueError(
                    f'Cannot handle complex compound condition: {condition}'
                )

        if re.match(r'NOT\s+CONFIG_\S+', condition):
            # NOT CONFIG_XXX
            real_condition = re.search(r'^NOT\s+(\S+)', condition).group(1)
            # Invert else condition.
            else_condition = f'@zephyr_kconfig//:{real_condition}=true'
            select_dict_entries.append(
                f'        "//conditions:default": [":{child_target_name}"],'
            )
        elif re.match(r'\S+\s+OR\s+', condition):
            or_conditions = re.split(r'\s+OR\s+', condition)
            to_match = []
            for or_condition in or_conditions:
                if re.match(r'NOT\s+CONFIG_\S+', or_condition):
                    real_condition = re.search(
                        r'^NOT\s+(\S+)', or_condition
                    ).group(1)
                    # Define the inverse config_setting to use in match_any below.
                    inverse_condition_name = or_condition.replace(
                        ' ', '_'
                    ).lower()
                    rules.append(f"""config_setting(
    name = "{inverse_condition_name}",
    flag_values = {{
        "@zephyr_kconfig//:{real_condition}": "false",
    }},
)""")
                    to_match.append(f':{inverse_condition_name}')
                else:
                    to_match.append(f'@zephyr_kconfig//:{or_condition}=true')
            rules.append(f"""selects.config_setting_group(
    name = "{sanitized_condition}",
    match_any = {to_match},
)""")
            config_setting_rules_created += 1
            select_dict_entries.append(
                f'        ":{sanitized_condition}": [":{child_target_name}"],'
            )
        elif re.match(r'\S+\s+AND\s+', condition):
            and_conditions = re.split(r'\s+AND\s+', condition)
            to_match = []
            for and_condition in and_conditions:
                if re.match(r'NOT\s+CONFIG_\S+', and_condition):
                    real_condition = re.search(
                        r'^NOT\s+(\S+)', and_condition
                    ).group(1)
                    # Define the inverse config_setting to use in match_all below.
                    inverse_condition_name = and_condition.replace(
                        ' ', '_'
                    ).lower()
                    rules.append(f"""config_setting(
    name = "{inverse_condition_name}",
    flag_values = {{
        "@zephyr_kconfig//:{real_condition}": "false",
    }},
)""")
                    config_setting_rules_created += 1
                    to_match.append(f':{inverse_condition_name}')
                else:
                    to_match.append(f'@zephyr_kconfig//:{and_condition}=true')
            rules.append(f"""selects.config_setting_group(
    name = "{sanitized_condition}",
    match_all = {to_match},
)""")
            config_setting_rules_created += 1
            select_dict_entries.append(
                f'        ":{sanitized_condition}": [":{child_target_name}"],'
            )
        elif re.match(r'CONFIG_\S+', condition):
            # Regular CONFIG_XXX without AND, OR, NOT.
            select_dict_entries.append(
                f'        "@zephyr_kconfig//:{condition}=true":'
                f' [":{child_target_name}"],'
            )
        else:
            print(f'Cannot process condition {condition}, skipping...')
            continue

        # Recursively generate rules for the branch body
        child_rules = recursive_callback(branch_body, child_target_name)

        if child_rules:
            rules.extend(child_rules)
        else:
            # Child does not have any content, remove the empty select.
            select_dict_entries.pop()
            # Since the select is empty, compound condition rules are
            # useless too.
            for _ in range(config_setting_rules_created):
                rules.pop()

    # Process else branch
    if node['else_body'] is not None:
        child_target_name = f'{target_name}_else_deps'
        child_rules = recursive_callback(node['else_body'], child_target_name)
        if child_rules:
            rules.extend(child_rules)
            select_dict_entries.append(
                f'        "{else_condition}": [":{child_target_name}"],'
            )
    elif select_dict_entries:
        # Else condition is only meaningful if there exist other
        # conditions already.
        select_dict_entries.append(f'        "{else_condition}": [],')

    deps_select = ''
    if select_dict_entries:
        deps_select = '\n'.join([
            ' + select({',
            *select_dict_entries,
            '    })',
        ])

    return rules, deps_select