# Copyright 2014 Cloudbase Solutions Srl
#
#    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.


import functools
import os
import re
import tempfile
import uuid

from cloudbaseinit.openstack.common import log as logging
from cloudbaseinit.osutils import factory as osutils_factory
from cloudbaseinit.plugins.common import base


__all__ = (
    'BaseCommand',
    'Shell',
    'Python',
    'Bash',
    'Powershell',
    'PowershellSysnative',
    'CommandExecutor',
    'EC2Config',
)

LOG = logging.getLogger(__name__)

# used with ec2 config files (xmls)
SCRIPT_TAG = 1
POWERSHELL_TAG = 2
# regexp and temporary file extension for each tag
TAG_REGEX = {
    SCRIPT_TAG: (
        re.compile(br"<script>([\s\S]+?)</script>"),
        "cmd"
    ),
    POWERSHELL_TAG: (
        re.compile(br"<powershell>([\s\S]+?)</powershell>"),
        "ps1"
    )
}

# important return values range
RET_START = 1001
RET_END = 1003


def _ec2_find_sections(data):
    """An intuitive script generator.

    Is able to detect and extract code between:
        - <script>...</script>
        - <powershell>...</powershell>
    tags. Yields data with each specific block of code.
    Note that, regardless of data structure, all cmd scripts are
    yielded before the rest of powershell scripts.
    """
    # extract code blocks between the tags
    blocks = {
        SCRIPT_TAG: TAG_REGEX[SCRIPT_TAG][0].findall(data),
        POWERSHELL_TAG: TAG_REGEX[POWERSHELL_TAG][0].findall(data)
    }
    # build and yield blocks (preserve order)
    for script_type in (SCRIPT_TAG, POWERSHELL_TAG):
        for code in blocks[script_type]:
            code = code.strip()
            if not code:
                continue    # skip the empty ones
            yield code, script_type


def _split_sections(multicmd):
    for code, stype in _ec2_find_sections(multicmd):
        if stype == SCRIPT_TAG:
            command = Shell.from_data(code)
        else:
            command = PowershellSysnative.from_data(code)
        yield command


def get_plugin_return_value(ret_val):
    plugin_status = base.PLUGIN_EXECUTION_DONE
    reboot = False

    try:
        ret_val = int(ret_val)
    except (ValueError, TypeError):
        ret_val = 0

    if ret_val and RET_START <= ret_val <= RET_END:
        reboot = bool(ret_val & 1)
        if ret_val & 2:
            plugin_status = base.PLUGIN_EXECUTE_ON_NEXT_BOOT

    return plugin_status, reboot


class BaseCommand(object):
    """Implements logic for executing an user command.

    This is intended to be subclassed and each subclass should change the
    attributes which controls the behaviour of the execution.
    It must be instantiated with a file.
    It can also execute string commands, by using the alternate
    constructor :meth:`~from_data`.

    The following attributes can control the behaviour of the command:

       * shell: Run the command as a shell command.
       * extension:

           A string, which will be appended to a generated script file.
           This is important for certain commands, e.g. Powershell,
           which can't execute something without the `.ps1` extension.

       * command:

           A program which will execute the underlying command,
           e.g. `python`, `bash` etc.

    """
    shell = False
    extension = None
    command = None

    def __init__(self, target_path, cleanup=None):
        """Instantiate the command.

        The parameter *target_path* represents the file which will be
        executed. The optional parameter *cleanup* can be a callable,
        which will be called after executing a command, no matter if the
        execution was succesful or not.
        """

        self._target_path = target_path
        self._cleanup = cleanup
        self._osutils = osutils_factory.get_os_utils()

    @property
    def args(self):
        """Return a list of commands.

        The list will be passed to :meth:`~execute_process`.
        """
        if not self.command:
            # Then we can assume it's a shell command.
            return [self._target_path]
        else:
            return [self.command, self._target_path]

    def get_execute_method(self):
        """Return a callable, which will be called by :meth:`~execute`."""
        return functools.partial(self._osutils.execute_process,
                                 self.args, shell=self.shell)

    def execute(self):
        """Execute the underlying command."""
        try:
            return self.get_execute_method()()
        finally:
            if self._cleanup:
                self._cleanup()

    __call__ = execute

    @classmethod
    def from_data(cls, command):
        """Create a new command class from the given command data."""
        def safe_remove(target_path):
            try:
                os.remove(target_path)
            except OSError:  # pragma: no cover
                pass

        tmp = os.path.join(tempfile.gettempdir(), str(uuid.uuid4()))
        if cls.extension:
            tmp += cls.extension
        with open(tmp, 'wb') as stream:
            stream.write(command)
        return cls(tmp, cleanup=functools.partial(safe_remove, tmp))


class Shell(BaseCommand):
    shell = True
    extension = '.cmd'


class Python(BaseCommand):
    extension = '.py'
    command = 'python'


class Bash(BaseCommand):
    extension = '.sh'
    command = 'bash'


class PowershellSysnative(BaseCommand):
    extension = '.ps1'
    sysnative = True

    def get_execute_method(self):
        return functools.partial(
            self._osutils.execute_powershell_script,
            self._target_path,
            self.sysnative)


class Powershell(PowershellSysnative):
    sysnative = False


class CommandExecutor(object):

    """Execute multiple commands and gather outputs."""

    SEP = b"\n"            # multistring separator

    def __init__(self, commands):
        self._commands = commands

    def execute(self):
        out_total = []
        err_total = []
        ret_total = 0
        for command in self._commands:
            out = err = b""
            ret_val = 0
            try:
                out, err, ret_val = command()
            except Exception as exc:
                LOG.exception(
                    "An error occurred during part execution: %s",
                    exc
                )
            else:
                out_total.append(out)
                err_total.append(err)
                ret_total += ret_val
        return (
            self.SEP.join(out_total),
            self.SEP.join(err_total),
            ret_total
        )

    __call__ = execute


class EC2Config(object):

    @classmethod
    def from_data(cls, multicmd):
        """Create multiple `CommandExecutor` objects.

        These are created using data chunks
        parsed from the given command data.
        """
        return CommandExecutor(_split_sections(multicmd))