#!/usr/bin/env python3

import distutils.dir_util
import os
import platform
import shlex
import shutil

import common

class ModulesComponent(common.Component):
    def add_parser_arguments(self, parser):
        parser.add_argument(
            '--make-args',
            default='',
            nargs='*'
        )
        parser.add_argument(
            '--host',
            action='store_true',
            default=False,
            help='''\
Build the Linux kernel modules for the host instead of guest.
Use the host packaged cross toolchain.
''',
        )
        parser.add_argument(
            'kernel_modules',
            default=[],
            help='Which kernel modules to build. Default: build all',
            metavar='kernel-modules',
            nargs='*',
        )

    def do_build(self, args):
        build_dir = self.get_build_dir(args)
        os.makedirs(build_dir, exist_ok=True)
        # I kid you not, out-of-tree build is not possible, O= does not work as for the kernel build:
        #
        # * https://stackoverflow.com/questions/5718899/building-an-out-of-tree-linux-kernel-module-in-a-separate-object-directory
        # * https://stackoverflow.com/questions/12244979/build-kernel-module-into-a-specific-directory
        # * https://stackoverflow.com/questions/18386182/out-of-tree-kernel-modules-multiple-module-single-makefile-same-source-file
        #
        # This copies only modified files as per:
        # https://stackoverflow.com/questions/5718899/building-an-out-of-tree-linux-kernel-module-in-a-separate-object-directory
        distutils.dir_util.copy_tree(
            common.kernel_modules_src_dir,
            os.path.join(build_dir, common.kernel_modules_subdir),
            update=1,
        )
        distutils.dir_util.copy_tree(
            common.include_src_dir,
            os.path.join(build_dir, common.include_subdir),
            update=1,
        )
        all_kernel_modules = []
        for basename in os.listdir(common.kernel_modules_src_dir):
            src = os.path.join(common.kernel_modules_src_dir, basename)
            if os.path.isfile(src):
                noext, ext = os.path.splitext(basename)
                if ext == common.c_ext:
                    all_kernel_modules.append(noext)
        if args.kernel_modules == []:
            kernel_modules = all_kernel_modules
        else:
            kernel_modules = map(lambda x: os.path.splitext(os.path.split(x)[1])[0], args.kernel_modules)
        object_files = map(lambda x: x + common.obj_ext, kernel_modules)
        tool = 'gcc'
        if args.host:
            allowed_toolchains = ['host']
            build_subdir = common.kernel_modules_build_host_subdir
        else:
            allowed_toolchains = None
            build_subdir = common.kernel_modules_build_subdir
        gcc = common.get_toolchain_tool(tool, allowed_toolchains=allowed_toolchains)
        prefix = gcc[:-len(tool)]
        ccache = shutil.which('ccache')
        if ccache is not None:
            cc = '{} {}'.format(ccache, gcc)
        else:
            cc = gcc
        if args.verbose:
            verbose = ['V=1']
        else:
            verbose = []
        if args.host:
            linux_dir = os.path.join('/lib', 'modules', platform.uname().release, 'build')
        else:
            linux_dir = common.linux_build_dir
        common.run_cmd(
            (
                [
                    'make',
                    '-j', str(args.nproc),
                    'ARCH={}'.format(common.linux_arch),
                    'CC={}'.format(cc),
                    'CROSS_COMPILE={}'.format(prefix),
                    'LINUX_DIR={}'.format(linux_dir),
                    'M={}'.format(build_subdir),
                    'OBJECT_FILES={}'.format(' '.join(object_files)),
                ] +
                shlex.split(args.make_args) +
                verbose
            ),
            cwd=os.path.join(common.kernel_modules_build_subdir),
        )
        if not args.host:
            common.copy_dir_if_update_non_recursive(
                srcdir=common.kernel_modules_build_subdir,
                destdir=common.out_rootfs_overlay_dir,
                filter_ext=common.kernel_module_ext,
            )

    def get_argparse_args(self):
        return {
                'description': '''\
Build our Linux kernel modules without using Buildroot.

See also: https://github.com/cirosantilli/linux-kernel-module-cheat#host
'''
        }

    def get_build_dir(self, args):
        if args.host:
            return os.path.join(common.kernel_modules_build_host_dir)
        else:
            return os.path.join(common.kernel_modules_build_dir)

if __name__ == '__main__':
    ModulesComponent().build()