#!/usr/bin/env python3
# Copyright 2015 gRPC 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
#
#     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.
"""Simple Mako renderer.

Just a wrapper around the mako rendering library.
"""

import getopt
import importlib.util
import os
import pickle
import shutil
import sys

import yaml
from mako.lookup import TemplateLookup
from mako.runtime import Context
from mako.template import Template

import bunch


# Imports a plugin
def import_plugin(path):
    module_name = os.path.basename(path).replace('.py', '')
    spec = importlib.util.spec_from_file_location(module_name, path)
    module = importlib.util.module_from_spec(spec)
    sys.modules[module_name] = module
    spec.loader.exec_module(module)
    return module


def out(msg):
    print(msg, file=sys.stderr)


def showhelp():
    out('mako-renderer.py [-o out] [-m cache] [-P preprocessed_input] [-d dict] [-d dict...]'
        ' [-t template] [-w preprocessed_output]')


def main(argv):
    got_input = False
    module_directory = None
    preprocessed_output = None
    dictionary = {}
    json_dict = {}
    got_output = False
    plugins = []
    output_name = None
    got_preprocessed_input = False
    output_merged = None

    try:
        opts, args = getopt.getopt(argv, 'hM:m:d:o:p:t:P:w:')
    except getopt.GetoptError:
        out('Unknown option')
        showhelp()
        sys.exit(2)

    for opt, arg in opts:
        if opt == '-h':
            out('Displaying showhelp')
            showhelp()
            sys.exit()
        elif opt == '-o':
            if got_output:
                out('Got more than one output')
                showhelp()
                sys.exit(3)
            got_output = True
            output_name = arg
        elif opt == '-m':
            if module_directory is not None:
                out('Got more than one cache directory')
                showhelp()
                sys.exit(4)
            module_directory = arg
        elif opt == '-M':
            if output_merged is not None:
                out('Got more than one output merged path')
                showhelp()
                sys.exit(5)
            output_merged = arg
        elif opt == '-P':
            assert not got_preprocessed_input
            assert json_dict == {}
            sys.path.insert(
                0,
                os.path.abspath(
                    os.path.join(os.path.dirname(sys.argv[0]), 'plugins')))
            with open(arg, 'rb') as dict_file:
                dictionary = pickle.load(dict_file)
            got_preprocessed_input = True
        elif opt == '-d':
            assert not got_preprocessed_input
            with open(arg, 'r') as dict_file:
                bunch.merge_json(
                    json_dict,
                    yaml.load(dict_file.read(), Loader=yaml.FullLoader))
        elif opt == '-p':
            plugins.append(import_plugin(arg))
        elif opt == '-w':
            preprocessed_output = arg

    if not got_preprocessed_input:
        for plugin in plugins:
            plugin.mako_plugin(json_dict)
        if output_merged:
            with open(output_merged, 'w') as yaml_file:
                yaml_file.write(yaml.dump(json_dict))
        for k, v in json_dict.items():
            dictionary[k] = bunch.to_bunch(v)

    if preprocessed_output:
        with open(preprocessed_output, 'wb') as dict_file:
            pickle.dump(dictionary, dict_file)

    cleared_dir = False
    for arg in args:
        got_input = True
        with open(arg) as f:
            srcs = list(yaml.load_all(f.read(), Loader=yaml.FullLoader))
        for src in srcs:
            if isinstance(src, str):
                assert len(srcs) == 1
                template = Template(src,
                                    filename=arg,
                                    module_directory=module_directory,
                                    lookup=TemplateLookup(directories=['.']))
                with open(output_name, 'w') as output_file:
                    template.render_context(Context(output_file, **dictionary))
            else:
                # we have optional control data: this template represents
                # a directory
                if not cleared_dir:
                    if not os.path.exists(output_name):
                        pass
                    elif os.path.isfile(output_name):
                        os.unlink(output_name)
                    else:
                        shutil.rmtree(output_name, ignore_errors=True)
                    cleared_dir = True
                items = []
                if 'foreach' in src:
                    for el in dictionary[src['foreach']]:
                        if 'cond' in src:
                            args = dict(dictionary)
                            args['selected'] = el
                            if not eval(src['cond'], {}, args):
                                continue
                        items.append(el)
                    assert items
                else:
                    items = [None]
                for item in items:
                    args = dict(dictionary)
                    args['selected'] = item
                    item_output_name = os.path.join(
                        output_name,
                        Template(src['output_name']).render(**args))
                    if not os.path.exists(os.path.dirname(item_output_name)):
                        os.makedirs(os.path.dirname(item_output_name))
                    template = Template(
                        src['template'],
                        filename=arg,
                        module_directory=module_directory,
                        lookup=TemplateLookup(directories=['.']))
                    with open(item_output_name, 'w') as output_file:
                        template.render_context(Context(output_file, **args))

    if not got_input and not preprocessed_output:
        out('Got nothing to do')
        showhelp()


if __name__ == '__main__':
    main(sys.argv[1:])