"""

RenderPipeline

Copyright (c) 2014-2016 tobspr <tobias.springer1@gmail.com>

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

"""

from rplibs.six import iteritems, iterkeys
from rplibs.yaml import load_yaml_file

from panda3d.core import Filename
from direct.stdpy.file import open

from rpcore.rpobject import RPObject
from rpcore.loader import RPLoader


class Effect(RPObject):

    """ This class represents an instance of a compiled effect. It can be loaded
    from a file. """

    # Configuration options which can be set per effect instance. These control
    # which features are available in the effect, and which passes to render.
    _DEFAULT_OPTIONS = {
        "render_gbuffer": True,
        "render_shadow": True,
        "render_voxelize": True,
        "render_envmap": True,
        "render_forward": False,
        "alpha_testing": True,
        "normal_mapping": True,
        "parallax_mapping": False,
    }

    # All supported render passes, should match the available passes in the
    # TagStateManager class.
    _PASSES = ("gbuffer", "shadow", "voxelize", "envmap", "forward")

    # Effects are cached based on their source filename and options, this is
    # the cache where compiled are effects stored.
    _GLOBAL_CACHE = {}

    # Global counter to store the amount of generated effects, used to create
    # a unique id used for writing temporary files.
    _EFFECT_ID = 0

    @classmethod
    def load(cls, filename, options):
        """ Loads an effect from a given filename with the specified options.
        This lookups in the global effect cache, and checks if a similar effect
        (i.e. with the same hash) was already loaded, and in that case returns it.
        Otherwise a new effect with the given options is created. """
        effect_hash = cls._generate_hash(filename, options)
        if effect_hash in cls._GLOBAL_CACHE:
            return cls._GLOBAL_CACHE[effect_hash]
        effect = cls()
        effect.set_options(options)
        if not effect.do_load(filename):
            RPObject.global_error("Effect", "Could not load effect!")
            return None
        return effect

    @classmethod
    def _generate_hash(cls, filename, options):
        """ Generates an unique hash for the effect. The effect hash is based
        on the filename and the configured options, and is ensured to make the
        effect unique. This is important to make sure the caching works as
        intended. All options not present in options are set to the default value"""

        # Set all options which are not present in the dict to its defaults
        options = {k: options.get(k, v) for k, v in iteritems(cls._DEFAULT_OPTIONS)}

        # Hash filename, make sure it has the right format and also resolve
        # it to an absolute path, to make sure that relative paths are cached
        # correctly (otherwise, specifying a different path to the same file
        # will cause a cache miss)
        filename = Filename(filename)
        filename.make_absolute()
        file_hash = str(hash(filename.to_os_generic()))

        # Hash the options, that is, sort the keys to make sure the values
        # are always in the same order, and then convert the flags to strings using
        # '1' for a set flag, and '0' for a unset flag
        options_hash = "".join(["1" if options[key] else "0" for key in sorted(iterkeys(options))])
        return file_hash + "-" + options_hash

    def __init__(self):
        """ Constructs a new empty effect, this is a private constructor and
        should not be called. Instead, use Effect.load() """
        RPObject.__init__(self)
        self.effect_id = Effect._EFFECT_ID
        Effect._EFFECT_ID += 1
        self.filename = None
        self._options = self._DEFAULT_OPTIONS.copy()
        self._generated_shader_paths = {}
        self._shader_objs = {}

    def get_option(self, name):
        """ Returns a given option value by name """
        return self._options[name]

    def set_options(self, options):
        """ Sets the effect options, overriding the default options """
        for key, val in iteritems(options):
            if key not in self._options:
                self.error("Unkown option:", key)
                continue
            self._options[key] = val

    def do_load(self, filename):
        """ Internal method to load the effect from the given filename, do
        not use this directly, instead use load(). """
        self.filename = filename
        self.effect_name = self._convert_filename_to_name(filename)
        self.effect_hash = self._generate_hash(filename, self._options)

        # Load the YAML file
        parsed_yaml = load_yaml_file(filename) or {}
        self._parse_content(parsed_yaml)

        # Construct a shader object for each pass
        for pass_id in self._PASSES:
            vertex_src = self._generated_shader_paths["vertex-" + pass_id]
            fragment_src = self._generated_shader_paths["fragment-" + pass_id]
            self._shader_objs[pass_id] = RPLoader.load_shader(vertex_src, fragment_src)
        return True

    def get_shader_obj(self, pass_id):
        """ Returns a handle to the compiled shader object for a given render
        pass. """
        if pass_id not in self._shader_objs:
            self.warn("Pass '" + pass_id + "' not found!")
            return False
        return self._shader_objs[pass_id]

    def _convert_filename_to_name(self, filename):
        """ Constructs an effect name from a filename, this is used for writing
        out temporary files """
        return filename.replace(".yaml", "").replace("effects/", "")\
            .replace("/", "_").replace("\\", "_").replace(".", "-")

    def _parse_content(self, parsed_yaml):
        """ Internal method to construct the effect from a yaml object """
        vtx_data = parsed_yaml.get("vertex", None) or {}
        frag_data = parsed_yaml.get("fragment", None) or {}

        for pass_id in self._PASSES:
            self._parse_shader_template(pass_id, "vertex", vtx_data)
            self._parse_shader_template(pass_id, "fragment", frag_data)

    def _parse_shader_template(self, pass_id, stage, data):
        """ Parses a fragment template. This just finds the default template
        for the shader, and redirects that to construct_shader_from_data """
        if stage == "fragment":
            shader_ext = {"vertex": "vert", "fragment": "frag"}[stage]
            template_src = "/$$rp/shader/templates/{}.{}.glsl".format(pass_id, shader_ext)
        elif stage == "vertex":
            # Using a shared vertex shader
            template_src = "/$$rp/shader/templates/vertex.vert.glsl"

        shader_path = self._construct_shader_from_data(pass_id, stage, template_src, data)
        self._generated_shader_paths[stage + "-" + pass_id] = shader_path

    def _construct_shader_from_data(self, pass_id, stage, template_src, data):  # noqa # pylint: disable=too-many-branches
        """ Constructs a shader from a given dataset """
        injects = {"defines": []}

        for key, val in iteritems(self._options):
            if isinstance(val, bool):
                val_str = "1" if val else "0"
            else:
                val_str = str(val)
            injects["defines"].append("#define OPT_{} {}".format(key.upper(), val_str))

        injects["defines"].append("#define IN_" + stage.upper() + "_SHADER 1")
        injects["defines"].append("#define IN_" + pass_id.upper() + "_SHADER 1")
        injects["defines"].append("#define IN_RENDERING_PASS 1")

        # Parse dependencies
        if "dependencies" in data:
            injects["includes"] = []
            for dependency in data["dependencies"]:
                include_str = "#pragma include \"{}\"".format(dependency)
                injects["includes"].append(include_str)
            del data["dependencies"]

        # Append aditional injects
        for key, val in iteritems(data):
            if val is None:
                self.warn("Empty insertion: '" + key + "'")
                continue

            if isinstance(val, (list, tuple)):
                self.warn("Invalid syntax, you used a list but you should have used a string:")
                self.warn(val)
                continue
            injects[key] = injects.get(key, []) + [i for i in val.split("\n")]

        cache_key = self.effect_name + "@" + stage + "-" + pass_id + "@" + self.effect_hash
        return self._process_shader_template(template_src, cache_key, injects)

    def _process_shader_template(self, template_src, cache_key, injections):  # noqa # pylint: disable=too-many-branches
        """ Generates a compiled shader object from a given shader
        source location and code injection definitions. """
        with open(template_src, "r") as handle:
            shader_lines = handle.readlines()

        parsed_lines = ["\n\n"]
        parsed_lines.append("/* Compiled Shader Template")
        parsed_lines.append(" * generated from: '" + template_src + "'")
        parsed_lines.append(" * cache key: '" + cache_key + "'")
        parsed_lines.append(" *")
        parsed_lines.append(" * !!! Autogenerated, do not edit! Your changes will be lost. !!!")
        parsed_lines.append(" */\n\n")

        # Store whether we are in the main function already - we need this
        # to properly insert scoped code blocks
        in_main = False

        for line in shader_lines:  # pylint: disable=too-many-nested-blocks
            stripped_line = line.strip().lower()

            # Check if we are already in the main function
            if "void main()" in stripped_line:
                in_main = True

            # Check if the current line is a hook
            if stripped_line.startswith("%") and stripped_line.endswith("%"):

                # If the line is a hook, get the hook name and save the
                # indent so we can indent all injected lines properly.
                hook_name = stripped_line[1:-1]
                indent = " " * (len(line) - len(line.lstrip()))

                # Inject all registered template values into the hook
                if hook_name in injections:

                    # Directly remove the value from the list so we can check which
                    # hooks were not found in the template
                    insertions = injections.pop(hook_name)

                    if len(insertions) > 0:

                        # When we are in the main function, we have to make sure we
                        # use a seperate scope, so there are no conflicts with variable
                        # declarations
                        header = indent + "/* Hook: " + hook_name + " */" + (" {" if in_main else "")  # noqa # pylint: disable=line-too-long
                        parsed_lines.append(header)

                        for line_to_insert in insertions:
                            if line_to_insert is None:
                                self.warn("Empty insertion '" + hook_name + "'")
                                continue

                            if not isinstance(line_to_insert, str):
                                self.warn("Invalid line type: ", line_to_insert)
                                continue

                            # Dont indent defines and pragmas
                            if line_to_insert.startswith("#"):
                                parsed_lines.append(line_to_insert)
                            else:
                                parsed_lines.append(indent + line_to_insert)

                        if in_main:
                            parsed_lines.append(indent + "}")

            else:
                parsed_lines.append(line.rstrip())

        # Add a closing newline to the file
        parsed_lines.append("")

        # Warn the user about all unused hooks
        for key in injections:
            self.warn("Hook '" + key + "' not found in template '" + template_src + "'!")

        # Write the constructed shader and load it back
        shader_content = "\n".join(parsed_lines)
        temp_path = "/$$rptemp/$$effect-" + cache_key + ".glsl"

        with open(temp_path, "w") as handle:
            handle.write(shader_content)

        return temp_path
