#!/usr/bin/env vpython
# -*- coding: utf-8 -*-
#
# Copyright 2016 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""
Builds applications in release mode:
- Concatenates autostart modules, application modules' module.json descriptors,
and the application loader into a single script.
"""

from io import StringIO
from os import path
from os.path import join
import copy
import os
import re
import shutil
import sys
import subprocess

from modular_build import read_file, write_file, bail_error
import modular_build
import rjsmin

try:
    import simplejson as json
except ImportError:
    import json

try:
    original_sys_path = sys.path
    sys.path = sys.path + [path.join(os.path.dirname(os.path.realpath(__file__)), '..')]
    import devtools_paths
finally:
    sys.path = original_sys_path

FRONT_END_DIRECTORY = path.join(os.path.dirname(path.abspath(__file__)), '..', '..', 'front_end')


def main(argv):
    try:
        input_path_flag_index = argv.index('--input_path')
        input_path = argv[input_path_flag_index + 1]
        output_path_gen_flag_index = argv.index('--output_path_gen')
        output_path_gen = argv[output_path_gen_flag_index + 1]
        application_names = argv[1:input_path_flag_index]
        use_rollup = '--rollup' in argv
    except:
        print('Usage: %s app_1 app_2 ... app_N --input_path <input_path> --output_path <output_path> --rollup true' % argv[0])
        raise

    loader = modular_build.DescriptorLoader(input_path)
    for app in application_names:
        descriptors = loader.load_application(app)
        builder = ReleaseBuilder(app, descriptors, input_path, output_path_gen,
                                 use_rollup)
        builder.build_app()


def resource_source_url(url):
    return '\n/*# sourceURL=' + url + ' */'


def minify_js(javascript):
    return rjsmin.jsmin(javascript)


def concatenated_module_filename(module_name, output_dir):
    return join(output_dir,
                module_name + '/' + path.basename(module_name) + '_module.js')


# Outputs:
#   <app_name>.js
#   <module_name>_module.js
class ReleaseBuilder(object):

    def __init__(self, application_name, descriptors, application_dir,
                 output_path_gen_dir, use_rollup):
        self.application_name = application_name
        self.descriptors = descriptors
        self.application_dir = application_dir
        self.output_path_gen_dir = output_path_gen_dir
        self.use_rollup = use_rollup

    def app_file(self, extension):
        return path.join('entrypoints', self.application_name,
                         self.application_name + '.' + extension)

    def autorun_resource_names(self):
        result = []
        for module in self.descriptors.sorted_modules():
            if self.descriptors.application[module].get('type') != 'autostart':
                continue

            resources = self.descriptors.modules[module].get('resources')
            if not resources:
                continue
            for resource_name in resources:
                result.append(path.join(module, resource_name))
        return result

    def build_app(self):
        self._build_app_script()
        for module in filter(lambda desc: (not desc.get('type')),
                             self.descriptors.application.values()):
            self._concatenate_dynamic_module(module['name'])

    def _build_app_script(self):
        script_name = self.app_file('js')
        output = StringIO()
        self._concatenate_application_script(output)
        minified_content = minify_js(output.getvalue())
        write_file(join(self.output_path_gen_dir, script_name),
                   minified_content)
        output.close()

    def _release_module_descriptors(self):
        module_descriptors = self.descriptors.modules
        result = []
        for name in module_descriptors:
            module = copy.copy(module_descriptors[name])
            module_type = self.descriptors.application[name].get('type')
            resources = module.get('resources', None)
            if resources:
                # Resources are already baked into _module.
                del module['resources']
                if not module_type == 'autostart':
                    # We load the entrypoint of a module no matter what.
                    # Therefore, we don't need to declare any files for
                    # the default case. However, if a module still has
                    # a legacy file, the Runtime performs an array
                    # contains check and will load that instead.
                    module_files_to_load = []
                    declared_module_files = module.get('modules', [])
                    legacyFileName = path.basename(name) + '-legacy.js'
                    if legacyFileName in declared_module_files:
                        module_files_to_load += [legacyFileName]
                    # Non-autostart modules are vulcanized.
                    module['modules'] = [path.basename(name) + '_module.js'
                                         ] + module_files_to_load
            result.append(module)
        return json.dumps(result)

    def _write_module_resources(self, resource_names, output):
        for resource_name in resource_names:
            resource_name = path.normpath(resource_name).replace('\\', '/')
            output.write('RootModule.Runtime.cachedResources.set("%s", "' %
                         resource_name)
            resource_content = read_file(path.join(self.application_dir, resource_name))
            if not (resource_name.endswith('.html')
                    or resource_name.endswith('md')):
                resource_content += resource_source_url(resource_name)
            resource_content = resource_content.replace('\\', '\\\\')
            resource_content = resource_content.replace('\n', '\\n')
            resource_content = resource_content.replace('"', '\\"')
            output.write(resource_content)
            output.write('");\n')

    def _concatenate_autostart_modules(self, output):
        non_autostart = set()
        sorted_module_names = self.descriptors.sorted_modules()
        for name in sorted_module_names:
            desc = self.descriptors.modules[name]
            name = desc['name']
            type = self.descriptors.application[name].get('type')
            if type == 'autostart':
                deps = set(desc.get('dependencies', []))
                non_autostart_deps = deps & non_autostart
                if len(non_autostart_deps):
                    bail_error(
                        'Non-autostart dependencies specified for the autostarted module "%s": %s' % (name, non_autostart_deps))
            else:
                non_autostart.add(name)

    def _concatenate_application_script(self, output):
        output.write('Root.allDescriptors.push(...%s);' % self._release_module_descriptors())
        if self.descriptors.extends:
            output.write(
                'Root.applicationDescriptor.modules.push(...%s);' %
                json.dumps(list(self.descriptors.application.values())))
        else:
            output.write('Root.applicationDescriptor = %s;' % self.descriptors.application_json())

        output.write("import * as RootModule from '../../core/root/root.js';")
        self._write_module_resources(self.autorun_resource_names(), output)

        output.write(minify_js(read_file(join(self.application_dir, self.app_file('js')))))
        self._concatenate_autostart_modules(output)

    def _concatenate_dynamic_module(self, module_name):
        module = self.descriptors.modules[module_name]
        modules = module.get('modules')
        resources = self.descriptors.module_resources(module_name)
        module_dir = join(self.application_dir, module_name)
        output = StringIO()
        if resources:
            relative_file_name = '../core/root/root.js'
            if "/" in module_name:
                relative_file_name = (
                    '../' * module_name.count('/')) + relative_file_name
            output.write("import * as RootModule from '%s';" %
                         relative_file_name)
            self._write_module_resources(resources, output)
        minified_content = minify_js(output.getvalue())
        write_file(
            concatenated_module_filename(module_name,
                                         self.output_path_gen_dir),
            minified_content)
        output.close()


if __name__ == '__main__':
    sys.exit(main(sys.argv))