#!/usr/bin/env python3

# Copyright 2025 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Modularize modularizes a platform."""

import argparse
import concurrent.futures
import logging
import pathlib
import re
import subprocess
import sys
import traceback

from compiler import Compiler
from config import fix_graph
from graph import IncludeDir
from graph import run_build
from platforms import Cpu
from platforms import Os
import render

SOURCE_ROOT = pathlib.Path(__file__).parents[3].resolve()
_OS_OPTS = '|'.join(os.value for os in Os)
_CPU_OPTS = '|'.join(cpu.value for cpu in Cpu)
_PLATFORM = re.compile(
    '^'
    + ''.join(
        [
            f'(?P<os>{_OS_OPTS})',
            f'(?:-(?P<cpu>{_CPU_OPTS}))?',
            r'(?P<xcode_suffix>_xcode\d+)?',
        ]
    )
    + '$'
)


def main(args):
    logging.basicConfig(level=logging.getLevelNamesMapping()[args.verbosity])
    existing_platforms = [
        f.name for f in (SOURCE_ROOT / 'build/modules').iterdir()
    ]

    filter = {
        'os': args.os,
        'cpu': args.cpu,
    }

    calls = {}
    for platform in existing_platforms:
        match = _PLATFORM.match(platform)
        if match is None:
            continue

        props = match.groupdict()
        os = Os(props['os'])
        # If no CPU is provided, we support all CPUs with a single BUILD.gn.
        # But we do need to be consistent about the CPU we target, so we arbitrarily
        # pick x64 since it's probably the most supported CPU.
        cpu = Cpu(props['cpu'] or 'x64')

        # We want to reconstruct the platform to dedupe xcode versions, and ensure
        # that we always have the correct cpu arch.
        platform = f"{os.value}-{cpu.value}"

        skip = False
        for k, v in filter.items():
            if v is not None and props[k] != v:
                skip = True
        if skip:
            continue
        out_dir = SOURCE_ROOT / 'out' / platform
        args_gn = out_dir / 'args.gn'
        if not args_gn.exists():
            out_dir.mkdir(exist_ok=True, parents=True)
            args_gn.write_text(
                '\n'.join(
                    [
                        # These are required
                        f'target_os = "{os.value}"',
                        f'target_cpu = "{cpu.value}"',
                        # This is required (see README.md)
                        'use_clang_modules = true',
                        # This is strongly recommended, otherwise you may accidentally
                        # test manual modules.
                        'use_autogenerated_modules = true',
                        # Some useful defaults. User is free to change these.
                        'use_remoteexec = true',
                        'symbol_level = 0',
                        'is_debug = false',
                        'running_modularize = true',
                    ]
                )
            )

        error_log = (
            None if args.error_log is None else args.error_log / platform
        )
        calls[platform] = dict(
            out_dir=out_dir,
            error_log=error_log,
            use_cache=args.cache,
            compile=args.compile,
            os=os,
            cpu=cpu,
        )

    if not calls:
        print(
            'No matching platforms. Try copying an existing one',
            file=sys.stderr,
        )
    elif len(calls) == 1:
        _modularize(**next(iter(calls.values())))
        return

    # Use a ProcessPoolExecutor rather than a ThreadPoolExecutor because:
    # * No shared state between instances
    # * GIL prevents a performance benefit from a thread pool executor.
    with concurrent.futures.ProcessPoolExecutor() as executor:
        futures = {
            k: executor.submit(_modularize, **kwargs)
            for k, kwargs in calls.items()
        }

    success = True
    for platform, future in sorted(futures.items()):
        exc = future.exception()
        if exc is not None:
            success = False
            print(f'{platform} raised an exception:', file=sys.stderr)
            traceback.print_exception(exc)
    if not success:
        exit(1)


def _modularize(
    out_dir: pathlib.Path,
    error_log: pathlib.Path | None,
    use_cache: bool,
    compile: bool,
    cpu: Cpu,
    os: Os,
):
    # Modularize requires gn gen to have been run at least once.
    if not (out_dir / 'build.ninja').is_file():
        subprocess.run(['gn', 'gen', out_dir], check=True)
    compiler = Compiler(
        source_root=SOURCE_ROOT,
        gn_out=out_dir,
        error_dir=error_log,
        use_cache=use_cache,
        cpu=cpu,
        os=os,
    )

    if compile:
        ps, files = compiler.compile_one(compile)
        print('stderr:', ps.stderr.decode('utf-8'), file=sys.stderr)
        print('Files used:')
        print('\n'.join(sorted(map(str, files))))
        print('Setting breakpoint to allow further debugging')
        breakpoint()
        return

    graph = compiler.compile_all()
    replacements = fix_graph(graph, compiler)
    targets = run_build(graph)

    platform = (out_dir / 'gen/module_platform.txt').read_text()
    logging.info('Detected platform %s', platform)

    out_dir = SOURCE_ROOT / 'build/modules' / platform
    out_dir.mkdir(exist_ok=True, parents=False)
    if compiler.sysroot_dir == IncludeDir.Sysroot:
        render.render_modulemap(
            out_dir=out_dir, replacements=replacements, targets=targets
        )
    render.render_build_gn(
        out_dir=out_dir,
        targets=targets,
        compiler=compiler,
    )


def _optional_path(s: str) -> pathlib.Path | None:
    if s:
        return pathlib.Path(s).resolve()


if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument(
        '--cpu',
        help='Only update platforms matching this cpu',
        type=lambda x: None if x is None else Cpu(x),
        default=None,
        choices=[cpu.value for cpu in Cpu],
    )
    parser.add_argument(
        '--os',
        help='Only update platforms matching this cpu',
        type=lambda x: None if x is None else Os(x),
        default=None,
        choices=[os.value for os in Os],
    )

    # Make it required so the user understands how compilation works.
    cache = parser.add_mutually_exclusive_group(required=True)
    cache.add_argument(
        '--cache',
        action='store_true',
        help='Enable caching. Will attempt to reuse the compilation results.',
    )
    cache.add_argument(
        '--no-cache',
        action='store_false',
        dest='cache',
        help='Disable caching. Will attempt to recompile the whole libcxx, '
        + 'builtins, and sysroot on every invocation',
    )

    parser.add_argument(
        '--compile',
        help='Compile a single header file (eg. --compile=sys/types.h) instead '
        + 'of the whole sysroot. Useful for debugging.',
    )

    parser.add_argument('--error-log', type=_optional_path)

    parser.add_argument(
        '--verbosity',
        help='Verbosity of logging',
        default='INFO',
        choices=logging.getLevelNamesMapping().keys(),
        type=lambda x: x.upper(),
    )

    main(parser.parse_args())