#
#    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.

from oslo_log import log as logging
import six

from heat.common import exception
from heat.common.i18n import repr_wrapper
from heat.engine import dependencies
from heat.engine import resource
from heat.engine import scheduler
from heat.engine import stk_defn
from heat.objects import resource as resource_objects

LOG = logging.getLogger(__name__)


@repr_wrapper
class StackUpdate(object):
    """A Task to perform the update of an existing stack to a new template."""

    def __init__(self, existing_stack, new_stack, previous_stack,
                 rollback=False):
        """Initialise with the existing stack and the new stack."""
        self.existing_stack = existing_stack
        self.new_stack = new_stack
        self.previous_stack = previous_stack

        self.rollback = rollback

        self.existing_snippets = dict((n, r.frozen_definition())
                                      for n, r in self.existing_stack.items())

    def __repr__(self):
        if self.rollback:
            return '%s Rollback' % str(self.existing_stack)
        else:
            return '%s Update' % str(self.existing_stack)

    @scheduler.wrappertask
    def __call__(self):
        """Return a co-routine that updates the stack."""

        cleanup_prev = scheduler.DependencyTaskGroup(
            self.previous_stack.dependencies,
            self._remove_backup_resource,
            reverse=True)

        def get_error_wait_time(resource):
            return resource.cancel_grace_period()

        updater = scheduler.DependencyTaskGroup(
            self.dependencies(),
            self._resource_update,
            error_wait_time=get_error_wait_time)

        if not self.rollback:
            yield cleanup_prev()

        try:
            yield updater()
        finally:
            self.previous_stack.reset_dependencies()

    def _resource_update(self, res):
        if res.name in self.new_stack and self.new_stack[res.name] is res:
            return self._process_new_resource_update(res)
        else:
            return self._process_existing_resource_update(res)

    @scheduler.wrappertask
    def _remove_backup_resource(self, prev_res):
        if prev_res.state not in ((prev_res.INIT, prev_res.COMPLETE),
                                  (prev_res.DELETE, prev_res.COMPLETE)):
            LOG.debug("Deleting backup resource %s", prev_res.name)
            yield prev_res.destroy()

    @staticmethod
    def _exchange_stacks(existing_res, prev_res):
        resource_objects.Resource.exchange_stacks(existing_res.stack.context,
                                                  existing_res.id, prev_res.id)
        prev_stack, existing_stack = prev_res.stack, existing_res.stack
        prev_stack.add_resource(existing_res)
        existing_stack.add_resource(prev_res)

    @scheduler.wrappertask
    def _create_resource(self, new_res):
        res_name = new_res.name

        # Clean up previous resource
        if res_name in self.previous_stack:
            prev_res = self.previous_stack[res_name]

            if prev_res.state not in ((prev_res.INIT, prev_res.COMPLETE),
                                      (prev_res.DELETE, prev_res.COMPLETE)):
                # Swap in the backup resource if it is in a valid state,
                # instead of creating a new resource
                if prev_res.status == prev_res.COMPLETE:
                    LOG.debug("Swapping in backup Resource %s", res_name)
                    self._exchange_stacks(self.existing_stack[res_name],
                                          prev_res)
                    return

                LOG.debug("Deleting backup Resource %s", res_name)
                yield prev_res.destroy()

        # Back up existing resource
        if res_name in self.existing_stack:
            LOG.debug("Backing up existing Resource %s", res_name)
            existing_res = self.existing_stack[res_name]
            self.previous_stack.add_resource(existing_res)
            existing_res.state_set(existing_res.UPDATE, existing_res.COMPLETE)

        self.existing_stack.add_resource(new_res)

        # Save new resource definition to backup stack if it is not
        # present in backup stack template already
        # it allows to resolve all dependencies that existing resource
        # can have if it was copied to backup stack
        if (res_name not in
                self.previous_stack.t[self.previous_stack.t.RESOURCES]):
            LOG.debug("Storing definition of new Resource %s", res_name)
            self.previous_stack.t.add_resource(new_res.t)
            self.previous_stack.t.store(self.previous_stack.context)

        yield new_res.create()

        self._update_resource_data(new_res)

    def _check_replace_restricted(self, res):
        registry = res.stack.env.registry
        restricted_actions = registry.get_rsrc_restricted_actions(res.name)
        existing_res = self.existing_stack[res.name]
        if 'replace' in restricted_actions:
            ex = exception.ResourceActionRestricted(action='replace')
            failure = exception.ResourceFailure(ex, existing_res,
                                                existing_res.UPDATE)
            existing_res._add_event(existing_res.UPDATE, existing_res.FAILED,
                                    six.text_type(ex))
            raise failure

    def _update_resource_data(self, resource):
        # Use the *new* template to determine the attrs to cache
        node_data = resource.node_data(self.new_stack.defn)
        stk_defn.update_resource_data(self.existing_stack.defn,
                                      resource.name, node_data)

        # Also update the new stack's definition with the data, so that
        # following resources can calculate dep_attr values correctly (e.g. if
        # the actual attribute name in a get_attr function also comes from a
        # get_attr function.)
        stk_defn.update_resource_data(self.new_stack.defn,
                                      resource.name, node_data)

    @scheduler.wrappertask
    def _process_new_resource_update(self, new_res):
        res_name = new_res.name

        if res_name in self.existing_stack:
            existing_res = self.existing_stack[res_name]
            is_substituted = existing_res.check_is_substituted(type(new_res))
            if type(existing_res) is type(new_res) or is_substituted:
                try:
                    yield self._update_in_place(existing_res,
                                                new_res,
                                                is_substituted)
                except resource.UpdateReplace:
                    pass
                else:
                    # Save updated resource definition to backup stack
                    # cause it allows the backup stack resources to be
                    # synchronized
                    LOG.debug("Storing definition of updated Resource %s",
                              res_name)
                    self.previous_stack.t.add_resource(new_res.t)
                    self.previous_stack.t.store(self.previous_stack.context)

                    LOG.info("Resource %(res_name)s for stack "
                             "%(stack_name)s updated",
                             {'res_name': res_name,
                              'stack_name': self.existing_stack.name})

                    self._update_resource_data(existing_res)
                    return
            else:
                self._check_replace_restricted(new_res)

        yield self._create_resource(new_res)

    def _update_in_place(self, existing_res, new_res, is_substituted=False):
        existing_snippet = self.existing_snippets[existing_res.name]
        prev_res = self.previous_stack.get(new_res.name)

        # Note the new resource snippet is resolved in the context
        # of the existing stack (which is the stack being updated)
        # but with the template of the new stack (in case the update
        # is switching template implementations)
        new_snippet = new_res.t.reparse(self.existing_stack.defn,
                                        self.new_stack.t)
        if is_substituted:
            substitute = type(new_res)(existing_res.name,
                                       existing_res.t,
                                       existing_res.stack)
            existing_res.stack.resources[existing_res.name] = substitute
            existing_res = substitute
        existing_res.converge = self.new_stack.converge
        return existing_res.update(new_snippet, existing_snippet,
                                   prev_resource=prev_res)

    @scheduler.wrappertask
    def _process_existing_resource_update(self, existing_res):
        res_name = existing_res.name

        if res_name in self.previous_stack:
            yield self._remove_backup_resource(self.previous_stack[res_name])

        if res_name in self.new_stack:
            new_res = self.new_stack[res_name]
            if new_res.state == (new_res.INIT, new_res.COMPLETE):
                # Already updated in-place
                return

        if existing_res.stack is not self.previous_stack:
            yield existing_res.destroy()

        if res_name not in self.new_stack:
            self.existing_stack.remove_resource(res_name)

    def dependencies(self):
        """Return the Dependencies graph for the update.

        Returns a Dependencies object representing the dependencies between
        update operations to move from an existing stack definition to a new
        one.
        """
        existing_deps = self.existing_stack.dependencies
        new_deps = self.new_stack.dependencies

        def edges():
            # Create/update the new stack's resources in create order
            for e in new_deps.graph().edges():
                yield e
            # Destroy/cleanup the old stack's resources in delete order
            for e in existing_deps.graph(reverse=True).edges():
                yield e
            # Don't cleanup old resources until after they have been replaced
            for name, res in six.iteritems(self.existing_stack):
                if name in self.new_stack:
                    yield (res, self.new_stack[name])

        return dependencies.Dependencies(edges())

    def preview(self):
        upd_keys = set(self.new_stack.resources.keys())
        cur_keys = set(self.existing_stack.resources.keys())

        common_keys = cur_keys.intersection(upd_keys)
        deleted_keys = cur_keys.difference(upd_keys)
        added_keys = upd_keys.difference(cur_keys)

        updated_keys = []
        replaced_keys = []

        for key in common_keys:
            current_res = self.existing_stack.resources[key]
            updated_res = self.new_stack.resources[key]

            current_props = current_res.frozen_definition().properties(
                current_res.properties_schema, current_res.context)
            updated_props = updated_res.frozen_definition().properties(
                updated_res.properties_schema, updated_res.context)

            # type comparison must match that in _process_new_resource_update
            if type(current_res) is not type(updated_res):
                replaced_keys.append(key)
                continue

            try:
                if current_res.preview_update(updated_res.frozen_definition(),
                                              current_res.frozen_definition(),
                                              updated_props, current_props,
                                              None):
                    updated_keys.append(key)
            except resource.UpdateReplace:
                replaced_keys.append(key)

        return {
            'unchanged': list(set(common_keys).difference(
                set(updated_keys + replaced_keys))),
            'updated': updated_keys,
            'replaced': replaced_keys,
            'added': list(added_keys),
            'deleted': list(deleted_keys),
        }
