#!/usr/bin/env python3
#
# Copyright 2019 - The Android Open Source Project
#
# 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
#
#     http://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.

"""It is an AIDEGen sub task: generate the .project file for Eclipse."""

import os

from aidegen import constant
from aidegen.lib import common_util
from aidegen.lib import project_file_gen


class EclipseConf(project_file_gen.ProjectFileGenerator):
    """Class to generate project file under the module path for Eclipse.

    Attributes:
        module_abspath: The absolute path of the target project.
        module_relpath: The relative path of the target project.
        module_name: The name of the target project.
        jar_module_paths: A dict records a mapping of jar file and module path.
        r_java_paths: A list contains the relative folder paths of the R.java
                      files.
        project_file: The absolutely path of .project file.
        template_project_content: A string of a template project_file content.
        project_content: A string ready to be written into project_file.
        src_paths: A list contains the project's source paths.
        classpath_file: The absolutely path of .classpath file.
        classpath_content: A string ready to be written into classpath_file.
    """
    # Constants of .project file
    _TEMPLATE_PROJECT_FILE = os.path.join(common_util.get_aidegen_root_dir(),
                                          'templates/eclipse/project.xml')
    _PROJECT_LINK = ('                <link><name>{}</name><type>2</type>'
                     '<location>{}</location></link>\n')
    _PROJECT_FILENAME = '.project'

    # constans of .classpath file
    _TEMPLATE_CLASSPATH_FILE = os.path.join(common_util.get_aidegen_root_dir(),
                                            'templates/eclipse/classpath.xml')
    _CLASSPATH_SRC_ENTRY = '    <classpathentry kind="src" path="{}"/>\n'
    _EXCLUDE_ANDROID_BP_ENTRY = ('    <classpathentry excluding="Android.bp" '
                                 'kind="src" path="{}"/>\n')
    _CLASSPATH_LIB_ENTRY = ('    <classpathentry exported="true" kind="lib" '
                            'path="{}" sourcepath="{}"/>\n')
    _CLASSPATH_FILENAME = '.classpath'

    def __init__(self, project):
        """Initialize class.

        Args:
            project: A ProjectInfo instance.
        """
        super().__init__(project)
        self.module_abspath = project.project_absolute_path
        self.module_relpath = project.project_relative_path
        self.module_name = project.module_name
        self.jar_module_paths = project.source_path['jar_module_path']
        self.r_java_paths = list(project.source_path['r_java_path'])
        # Related value for generating .project.
        self.project_file = os.path.join(self.module_abspath,
                                         self._PROJECT_FILENAME)
        self.template_project_content = common_util.read_file_content(
            self._TEMPLATE_PROJECT_FILE)
        self.project_content = ''
        # Related value for generating .classpath.
        self.src_paths = list(project.source_path['source_folder_path'])
        self.src_paths.extend(project.source_path['test_folder_path'])
        self.classpath_file = os.path.join(self.module_abspath,
                                           self._CLASSPATH_FILENAME)
        self.classpath_content = common_util.read_file_content(
            self._TEMPLATE_CLASSPATH_FILE)

    def _gen_r_link(self):
        """Generate the link resources of the R paths.

        E.g.
            <link>
                <name>dependencies/out/target/common/R</name>
                <type>2</type>
                <location>{ANDROID_ROOT_PATH}/out/target/common/R</location>
            </link>

        Returns: A set contains R paths link resources strings.
        """
        return {self._gen_link(r_path) for r_path in self.r_java_paths}

    def _gen_src_links(self, relpaths):
        """Generate the link resources from relpaths.

        Args:
            relpaths: A list of module paths which are relative to
                      ANDROID_BUILD_TOP.
                      e.g. ['relpath/to/module1', 'relpath/to/module2', ...]

        Returns: A set includes all unique link resources.
        """
        return {self._gen_link(relpath) for relpath in relpaths}

    @classmethod
    def _gen_link(cls, relpath):
        """Generate a link resource from a relative path.

         E.g.
            <link>
                <name>dependencies/path/to/relpath</name>
                <type>2</type>
                <location>/absolute/path/to/relpath</location>
            </link>

        Args:
            relpath: A string of a relative path to Android_BUILD_TOP.

        Returns: A string of link resource.
        """
        alias_name = os.path.join(constant.KEY_DEPENDENCIES, relpath)
        abs_path = os.path.join(common_util.get_android_root_dir(), relpath)
        return cls._PROJECT_LINK.format(alias_name, abs_path)

    def _create_project_content(self):
        """Create the project file .project under the module."""
        # links is a set to save unique link resources.
        links = self._gen_src_links(self.jar_module_paths.values())
        links.update(self._gen_r_link())
        self.project_content = self.template_project_content.format(
            PROJECTNAME=self.module_name,
            LINKEDRESOURCES=''.join(sorted(list(links))))

    def _gen_r_path_entries(self):
        """Generate the class path entries for the R paths.

        E.g.
            <classpathentry kind="src"
                path="dependencies/out/target/common/R"/>
            <classpathentry kind="src"
                path="dependencies/out/soong/.intermediates/packages/apps/
                      Settings/Settings/android_common/gen/aapt2/R"/>

        Returns: A list of the R path's class path entry.
        """
        r_entry_list = []
        for r_path in self.r_java_paths:
            alias_path = os.path.join(constant.KEY_DEPENDENCIES, r_path)
            r_entry_list.append(self._CLASSPATH_SRC_ENTRY.format(alias_path))
        return r_entry_list

    def _gen_src_path_entries(self):
        """Generate the class path entries from srcs.

        If the Android.bp file exists, generate the following content in
        .classpath file to avoid copying the Android.bp to the bin folder under
        current project directory.
        <classpathentry excluding="Android.bp" kind="src"
                        path="clearcut_client"/>

        E.g.
            The source folder paths list:
                ['packages/apps/Settings/src',
                 'packages/apps/Settings/tests/robotests/src',
                 'packages/apps/Settings/tests/uitests/src',
                 'packages/apps/Settings/tests/unit/src'
                ]
            It will generate the related <classpathentry> list:
                ['<classpathentry kind="src" path="src"/>',
                 '<classpathentry kind="src" path="tests/robotests/src"/>',
                 '<classpathentry kind="src" path="tests/uitests/src"/>',
                 '<classpathentry kind="src" path="tests/unit/src"/>'
                ]

        Returns: A list of source folders' class path entries.
        """
        src_path_entries = []
        for src in self.src_paths:
            src_abspath = os.path.join(common_util.get_android_root_dir(), src)
            src = src.replace(self.module_relpath, '').strip(os.sep)
            if common_util.exist_android_bp(src_abspath):
                src_path_entries.append(
                    self._EXCLUDE_ANDROID_BP_ENTRY.format(src))
            else:
                src_path_entries.append(self._CLASSPATH_SRC_ENTRY.format(src))
        return src_path_entries

    def _gen_jar_path_entries(self):
        """Generate the jar files' class path entries.

        The self.jar_module_paths is a dictionary.
        e.g.
            {'/abspath/to/the/file.jar': 'relpath/to/the/module'}
        This method will generate the <classpathentry> for each jar file.
        The format of <classpathentry> looks like:
        <classpathentry exported="true" kind="lib"
            path="/abspath/to/the/file.jar"
            sourcepath="dependencies/relpath/to/the/module"/>

        Returns: A list of jar files' class path entries.
        """
        jar_entries = []
        for jar_relpath, module_relpath in self.jar_module_paths.items():
            jar_abspath = os.path.join(common_util.get_android_root_dir(),
                                       jar_relpath)
            alias_module_path = os.path.join(constant.KEY_DEPENDENCIES,
                                             module_relpath)
            jar_entries.append(self._CLASSPATH_LIB_ENTRY.format(
                jar_abspath, alias_module_path))
        return jar_entries

    def _create_classpath_content(self):
        """Create the project file .classpath under the module."""
        src_entries = self._gen_src_path_entries()
        src_entries.extend(self._gen_r_path_entries())
        jar_entries = self._gen_jar_path_entries()
        self.classpath_content = self.classpath_content.format(
            SRC=''.join(sorted(src_entries)),
            LIB=''.join(sorted(jar_entries)))

    def generate_project_file(self):
        """Generate .project file of the target module."""
        self._create_project_content()
        common_util.file_generate(self.project_file, self.project_content)

    def generate_classpath_file(self):
        """Generate .classpath file of the target module."""
        self._create_classpath_content()
        common_util.file_generate(self.classpath_file, self.classpath_content)

    @classmethod
    def generate_ide_project_files(cls, projects):
        """Generate Eclipse project files by a list of ProjectInfo instances.

        Args:
            projects: A list of ProjectInfo instances.
        """
        for project in projects:
            eclipse_configure = EclipseConf(project)
            eclipse_configure.generate_project_file()
            eclipse_configure.generate_classpath_file()