#!/usr/bin/env python
"""
Mozilla Public License, version 2.0

1. Definitions

1.1. “Contributor”

     means each individual or legal entity that creates, contributes to the
     creation of, or owns Covered Software.

1.2. “Contributor Version”

     means the combination of the Contributions of others (if any) used by a
     Contributor and that particular Contributor’s Contribution.

1.3. “Contribution”

     means Covered Software of a particular Contributor.

1.4. “Covered Software”

     means Source Code Form to which the initial Contributor has attached the
     notice in Exhibit A, the Executable Form of such Source Code Form, and
     Modifications of such Source Code Form, in each case including portions
     thereof.

1.5. “Incompatible With Secondary Licenses”
     means

     a. that the initial Contributor has attached the notice described in
        Exhibit B to the Covered Software; or

     b. that the Covered Software was made available under the terms of version
        1.1 or earlier of the License, but not also under the terms of a
        Secondary License.

1.6. “Executable Form”

     means any form of the work other than Source Code Form.

1.7. “Larger Work”

     means a work that combines Covered Software with other material, in a separate
     file or files, that is not Covered Software.

1.8. “License”

     means this document.

1.9. “Licensable”

     means having the right to grant, to the maximum extent possible, whether at the
     time of the initial grant or subsequently, any and all of the rights conveyed by
     this License.

1.10. “Modifications”

     means any of the following:

     a. any file in Source Code Form that results from an addition to, deletion
        from, or modification of the contents of Covered Software; or

     b. any new file in Source Code Form that contains any Covered Software.

1.11. “Patent Claims” of a Contributor

      means any patent claim(s), including without limitation, method, process,
      and apparatus claims, in any patent Licensable by such Contributor that
      would be infringed, but for the grant of the License, by the making,
      using, selling, offering for sale, having made, import, or transfer of
      either its Contributions or its Contributor Version.

1.12. “Secondary License”

      means either the GNU General Public License, Version 2.0, the GNU Lesser
      General Public License, Version 2.1, the GNU Affero General Public
      License, Version 3.0, or any later versions of those licenses.

1.13. “Source Code Form”

      means the form of the work preferred for making modifications.

1.14. “You” (or “Your”)

      means an individual or a legal entity exercising rights under this
      License. For legal entities, “You” includes any entity that controls, is
      controlled by, or is under common control with You. For purposes of this
      definition, “control” means (a) the power, direct or indirect, to cause
      the direction or management of such entity, whether by contract or
      otherwise, or (b) ownership of more than fifty percent (50%) of the
      outstanding shares or beneficial ownership of such entity.


2. License Grants and Conditions

2.1. Grants

     Each Contributor hereby grants You a world-wide, royalty-free,
     non-exclusive license:

     a. under intellectual property rights (other than patent or trademark)
        Licensable by such Contributor to use, reproduce, make available,
        modify, display, perform, distribute, and otherwise exploit its
        Contributions, either on an unmodified basis, with Modifications, or as
        part of a Larger Work; and

     b. under Patent Claims of such Contributor to make, use, sell, offer for
        sale, have made, import, and otherwise transfer either its Contributions
        or its Contributor Version.

2.2. Effective Date

     The licenses granted in Section 2.1 with respect to any Contribution become
     effective for each Contribution on the date the Contributor first distributes
     such Contribution.

2.3. Limitations on Grant Scope

     The licenses granted in this Section 2 are the only rights granted under this
     License. No additional rights or licenses will be implied from the distribution
     or licensing of Covered Software under this License. Notwithstanding Section
     2.1(b) above, no patent license is granted by a Contributor:

     a. for any code that a Contributor has removed from Covered Software; or

     b. for infringements caused by: (i) Your and any other third party’s
        modifications of Covered Software, or (ii) the combination of its
        Contributions with other software (except as part of its Contributor
        Version); or

     c. under Patent Claims infringed by Covered Software in the absence of its
        Contributions.

     This License does not grant any rights in the trademarks, service marks, or
     logos of any Contributor (except as may be necessary to comply with the
     notice requirements in Section 3.4).

2.4. Subsequent Licenses

     No Contributor makes additional grants as a result of Your choice to
     distribute the Covered Software under a subsequent version of this License
     (see Section 10.2) or under the terms of a Secondary License (if permitted
     under the terms of Section 3.3).

2.5. Representation

     Each Contributor represents that the Contributor believes its Contributions
     are its original creation(s) or it has sufficient rights to grant the
     rights to its Contributions conveyed by this License.

2.6. Fair Use

     This License is not intended to limit any rights You have under applicable
     copyright doctrines of fair use, fair dealing, or other equivalents.

2.7. Conditions

     Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted in
     Section 2.1.


3. Responsibilities

3.1. Distribution of Source Form

     All distribution of Covered Software in Source Code Form, including any
     Modifications that You create or to which You contribute, must be under the
     terms of this License. You must inform recipients that the Source Code Form
     of the Covered Software is governed by the terms of this License, and how
     they can obtain a copy of this License. You may not attempt to alter or
     restrict the recipients’ rights in the Source Code Form.

3.2. Distribution of Executable Form

     If You distribute Covered Software in Executable Form then:

     a. such Covered Software must also be made available in Source Code Form,
        as described in Section 3.1, and You must inform recipients of the
        Executable Form how they can obtain a copy of such Source Code Form by
        reasonable means in a timely manner, at a charge no more than the cost
        of distribution to the recipient; and

     b. You may distribute such Executable Form under the terms of this License,
        or sublicense it under different terms, provided that the license for
        the Executable Form does not attempt to limit or alter the recipients’
        rights in the Source Code Form under this License.

3.3. Distribution of a Larger Work

     You may create and distribute a Larger Work under terms of Your choice,
     provided that You also comply with the requirements of this License for the
     Covered Software. If the Larger Work is a combination of Covered Software
     with a work governed by one or more Secondary Licenses, and the Covered
     Software is not Incompatible With Secondary Licenses, this License permits
     You to additionally distribute such Covered Software under the terms of
     such Secondary License(s), so that the recipient of the Larger Work may, at
     their option, further distribute the Covered Software under the terms of
     either this License or such Secondary License(s).

3.4. Notices

     You may not remove or alter the substance of any license notices (including
     copyright notices, patent notices, disclaimers of warranty, or limitations
     of liability) contained within the Source Code Form of the Covered
     Software, except that You may alter any license notices to the extent
     required to remedy known factual inaccuracies.

3.5. Application of Additional Terms

     You may choose to offer, and to charge a fee for, warranty, support,
     indemnity or liability obligations to one or more recipients of Covered
     Software. However, You may do so only on Your own behalf, and not on behalf
     of any Contributor. You must make it absolutely clear that any such
     warranty, support, indemnity, or liability obligation is offered by You
     alone, and You hereby agree to indemnify every Contributor for any
     liability incurred by such Contributor as a result of warranty, support,
     indemnity or liability terms You offer. You may include additional
     disclaimers of warranty and limitations of liability specific to any
     jurisdiction.

4. Inability to Comply Due to Statute or Regulation

   If it is impossible for You to comply with any of the terms of this License
   with respect to some or all of the Covered Software due to statute, judicial
   order, or regulation then You must: (a) comply with the terms of this License
   to the maximum extent possible; and (b) describe the limitations and the code
   they affect. Such description must be placed in a text file included with all
   distributions of the Covered Software under this License. Except to the
   extent prohibited by statute or regulation, such description must be
   sufficiently detailed for a recipient of ordinary skill to be able to
   understand it.

5. Termination

5.1. The rights granted under this License will terminate automatically if You
     fail to comply with any of its terms. However, if You become compliant,
     then the rights granted under this License from a particular Contributor
     are reinstated (a) provisionally, unless and until such Contributor
     explicitly and finally terminates Your grants, and (b) on an ongoing basis,
     if such Contributor fails to notify You of the non-compliance by some
     reasonable means prior to 60 days after You have come back into compliance.
     Moreover, Your grants from a particular Contributor are reinstated on an
     ongoing basis if such Contributor notifies You of the non-compliance by
     some reasonable means, this is the first time You have received notice of
     non-compliance with this License from such Contributor, and You become
     compliant prior to 30 days after Your receipt of the notice.

5.2. If You initiate litigation against any entity by asserting a patent
     infringement claim (excluding declaratory judgment actions, counter-claims,
     and cross-claims) alleging that a Contributor Version directly or
     indirectly infringes any patent, then the rights granted to You by any and
     all Contributors for the Covered Software under Section 2.1 of this License
     shall terminate.

5.3. In the event of termination under Sections 5.1 or 5.2 above, all end user
     license agreements (excluding distributors and resellers) which have been
     validly granted by You or Your distributors under this License prior to
     termination shall survive termination.

6. Disclaimer of Warranty

   Covered Software is provided under this License on an “as is” basis, without
   warranty of any kind, either expressed, implied, or statutory, including,
   without limitation, warranties that the Covered Software is free of defects,
   merchantable, fit for a particular purpose or non-infringing. The entire
   risk as to the quality and performance of the Covered Software is with You.
   Should any Covered Software prove defective in any respect, You (not any
   Contributor) assume the cost of any necessary servicing, repair, or
   correction. This disclaimer of warranty constitutes an essential part of this
   License. No use of  any Covered Software is authorized under this License
   except under this disclaimer.

7. Limitation of Liability

   Under no circumstances and under no legal theory, whether tort (including
   negligence), contract, or otherwise, shall any Contributor, or anyone who
   distributes Covered Software as permitted above, be liable to You for any
   direct, indirect, special, incidental, or consequential damages of any
   character including, without limitation, damages for lost profits, loss of
   goodwill, work stoppage, computer failure or malfunction, or any and all
   other commercial damages or losses, even if such party shall have been
   informed of the possibility of such damages. This limitation of liability
   shall not apply to liability for death or personal injury resulting from such
   party’s negligence to the extent applicable law prohibits such limitation.
   Some jurisdictions do not allow the exclusion or limitation of incidental or
   consequential damages, so this exclusion and limitation may not apply to You.

8. Litigation

   Any litigation relating to this License may be brought only in the courts of
   a jurisdiction where the defendant maintains its principal place of business
   and such litigation shall be governed by laws of that jurisdiction, without
   reference to its conflict-of-law provisions. Nothing in this Section shall
   prevent a party’s ability to bring cross-claims or counter-claims.

9. Miscellaneous

   This License represents the complete agreement concerning the subject matter
   hereof. If any provision of this License is held to be unenforceable, such
   provision shall be reformed only to the extent necessary to make it
   enforceable. Any law or regulation which provides that the language of a
   contract shall be construed against the drafter shall not be used to construe
   this License against a Contributor.


10. Versions of the License

10.1. New Versions

      Mozilla Foundation is the license steward. Except as provided in Section
      10.3, no one other than the license steward has the right to modify or
      publish new versions of this License. Each version will be given a
      distinguishing version number.

10.2. Effect of New Versions

      You may distribute the Covered Software under the terms of the version of
      the License under which You originally received the Covered Software, or
      under the terms of any subsequent version published by the license
      steward.

10.3. Modified Versions

      If you create software not governed by this License, and you want to
      create a new license for such software, you may create and use a modified
      version of this License if you rename the license and remove any
      references to the name of the license steward (except to note that such
      modified license differs from this License).

10.4. Distributing Source Code Form that is Incompatible With Secondary Licenses
      If You choose to distribute Source Code Form that is Incompatible With
      Secondary Licenses under the terms of this version of the License, the
      notice described in Exhibit B of this License must be attached.

Exhibit A - Source Code Form License Notice

      This Source Code Form is subject to the
      terms of the Mozilla Public License, v.
      2.0. If a copy of the MPL was not
      distributed with this file, You can
      obtain one at
      http://mozilla.org/MPL/2.0/.

If it is not possible or desirable to put the notice in a particular file, then
You may include the notice in a location (such as a LICENSE file in a relevant
directory) where a recipient would be likely to look for such a notice.

You may add additional accurate notices of copyright ownership.

Exhibit B - “Incompatible With Secondary Licenses” Notice

      This Source Code Form is “Incompatible
      With Secondary Licenses”, as defined by
      the Mozilla Public License, v. 2.0.

"""
from __future__ import (absolute_import, division, print_function)
__metaclass__ = type

import jinja2
from textwrap import dedent
import os
import sys
import shutil
import re
import json
from datetime import datetime
from ansible.module_utils._text import to_text
from ansible.module_utils.six import iteritems
from ansible.module_utils.six import ensure_str
from ansible.module_utils.six import string_types

DEFAULT_TF_DIR = '/var/tmp/ansible/ibmcloud/'
RM_OBJECT_SUBDIRS = True


def ibmcloud_terraform(
        resource_type,
        tf_type,
        parameters,
        ibm_provider_version,
        tl_required_params,
        tl_all_params,
        terraform_dir=None):
    """
    Use Terraform to interact with IBM Cloud resources

    Args:
        resource_type (str): Resource type (e.g.: 'ibm_is_vpc')
        tf_type (str): Terraform block type ('resource' or 'data')
        parameters (dict): Resource parameter dictionary
        ibm_provider_version (str): IBM Cloud Terraform provider version
        tl_required_params (list of tuple): Top Level Parameters
            required by TF. Each tuple consists of two strings:
            (<name>, <type>)
        tl_all_params (list): Top Level Parameters supported by TF.
            Each tuple consists of two strings:(<name>, <type>)
        terraform_dir (str, optional): Path to Terraform working
            directory. Can also be set using the
            'IBMCLOUD_ANSIBLE_TERRAFORM_DIR' environment variable.

    Returns:
        dict: Ansible 'result' dictionary. The 'resource' key contains
              the resource's primary.attributes dictionary retrieved
              from tfstate data. e.g.:
              {
                  'changed': <bool>,
                  'resource': <dict>,
                  'rc': <int>,
                  'stdout': <str>,
                  'stderr': <str>,
                  'warnings': <list of str>
              }
    """
    # Initialize environment variable mapping
    # Import any env vars set within ansible
    env = dict(os.environ)
    # Set 'no_log' provider parameters via env vars to prevent
    # exposing key in plaintext provider file
    if ('ibmcloud_api_key' in parameters and
            parameters['ibmcloud_api_key'] is not None):
        env['IC_API_KEY'] = parameters['ibmcloud_api_key']
    if ('iaas_classic_username' in parameters and
            parameters['iaas_classic_username'] is not None):
        env['IAAS_CLASSIC_USERNAME'] = parameters['iaas_classic_username']
    if ('iaas_classic_api_key' in parameters and
            parameters['iaas_classic_api_key'] is not None):
        env['IAAS_CLASSIC_API_KEY'] = parameters['iaas_classic_api_key']

    # Initialize result dictionary
    result = {
        'changed': False,
        'resource': {},
        'rc': 0,
        'stdout': '',
        'stderr': '',
        'warnings': []
    }

    # Set terraform directory
    if terraform_dir is None:
        if 'IBMCLOUD_ANSIBLE_TERRAFORM_DIR' in env:
            terraform_dir = env['IBMCLOUD_ANSIBLE_TERRAFORM_DIR']
        else:
            terraform_dir = DEFAULT_TF_DIR

    # Initialize Terraform object
    terraform = Terraform(
        parameters,
        terraform_dir,
        ibm_provider_version,
        env=env)

    resource = Resource(
        resource_type,
        tf_type,
        parameters,
        tl_required_params,
        tl_all_params)
    terraform.add_resource(resource)
    terraform.init()

    if tf_type == 'data':
        result['rc'], result['stdout'], result['stderr'] = (
            terraform.apply())
        result['resource'] = terraform.get_tfstate_attributes(resource.target)

    elif tf_type == 'resource':
        resource_absent = False

        # Attempt to import resource tfstate if 'id' is given
        if resource.tf_type == 'resource' and resource.id_ is not None:
            if not terraform.set_existing_args(resource):
                resource_absent = True
                if resource.parameters['state'] == 'available':
                    result['warnings'].append(
                        "Unable to import resource id '{}' (type {}). "
                        "Attempting to create new resource."
                        .format(resource.id_, resource.resource_type))

        # Create/update resource
        if resource.parameters['state'] == 'available':
            result['rc'], result['stdout'], result['stderr'] = (
                terraform.apply())
            # Determine 'changed' result value
            if (result['rc'] == 0 and not re.search(
                    '0 added, 0 changed, 0 destroyed', result['stdout'])):
                result['changed'] = True
            # Load resource return data
            result['resource'] = terraform.get_tfstate_attributes(
                resource.target)

        # Remove resource
        elif resource.parameters['state'] == 'absent':
            if not resource_absent:
                result['rc'], result['stdout'], result['stderr'] = (
                    terraform.destroy(None))
                # Determine 'changed' result value
                if (result['rc'] == 0 and not re.search(
                        'Resources: 0 destroyed', result['stdout'])):
                    result['changed'] = True

    terraform.cleanup(result, RM_OBJECT_SUBDIRS)
    return result


def to_unicode(string):
    """
    Ensure string is unicode

    Args:
        string (str or bytes): String can be type 'str' or 'bytes'

    Returns:
        str: Unicode string (utf-8 encoding)
    """
    try:
        unicode_string = to_text(string, errors='surrogate_or_strict')
    except UnicodeError:
        unicode_string = string
    return unicode_string


def run_process(command, cwd=None, env=None):
    """
    Run system subprocess

    Args:
        command (str): Full command string
        cwd (str, optional): Process current working directory
        env (dict, optional): Mapping of environment variables

    Returns:
        (int, str, str): Tuple with (return code, stdout, stderr)
    """
    import subprocess
    import shlex

    args = shlex.split(command)

    process = subprocess.Popen(
        args, cwd=cwd, env=env, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    stdout, stderr = process.communicate()
    returncode = process.returncode

    return (returncode, to_unicode(stdout), to_unicode(stderr))


class Resource:
    """
    TODO: Docstring

    Args:
        resource_type (str): Resouce type (e.g.: 'ibm_is_vpc')
        tf_type (str): Terraform block type ('resource' or 'data')
        parameters (dict): Resource parameter dictionary
        tl_required_params (list of tuple): Top Level Parameters
            required by TF. Each tuple consists of two strings:
            (<name>, <type>)
        tl_all_params (list): Top Level Parameters supported by TF.
            Each tuple consists of two strings:(<name>, <type>)
    """
    def __init__(
            self,
            resource_type,
            tf_type,
            parameters,
            tl_required_params,
            tl_all_params):
        self.resource_type = resource_type
        self.tf_type = tf_type
        self.parameters = parameters
        self.tl_required_params = tl_required_params
        self.tl_all_params = tl_all_params

        # Terraform requires a name, if no 'name' paramter set use
        # timestamp
        if 'name' in self.parameters and self.parameters['name'] is not None:
            # To avoid special characters in the resource name removing special character.
            tfname = ''.join(e for e in self.parameters['name'] if e.isalnum())
            self.tf_name = "ansible_" + tfname
        else:
            self.tf_name = (
                "ansible_" + datetime.now().strftime("%Y%m%d-%H%M%S"))

        # Target is used to identify resource within Terraform
        self.target = '{}.{}'.format(
            self.resource_type, self.tf_name)
        # if self.tf_type == 'data':
        #     self.target = 'data.' + self.target

        self.id_ = None
        if 'id' in parameters and parameters['id'] is not None:
            self.id_ = parameters['id']
            if (self.resource_type.startswith('ibm_pi') and
                    'pi_cloud_instance_id' in parameters and
                    parameters['pi_cloud_instance_id'] is not None):
                self.id_ = parameters['pi_cloud_instance_id'] + '/' + self.id_


class Terraform:
    """
    Interaction with Terraform

    Constructor looks for Terraform executable and IBM Cloud Terraform
    provider that satisfy version requirements passed into arguments. If
    specified versions are not found they will be downloaded and
    installed within the 'terraform_dir'.

    Args:
        parameters (dict): Resource parameter dictionary
        terraform_dir (str): Terraform working directory
        ibm_provider_version (str): IBM Cloud Terraform provider version
        terraform_version (str, optional): Terraform version. TODO: If
                                           not specified version is set
                                           via table lookup.
        env (dict, optional): Mapping of environment variables
    """
    IBM_PROVIDER_BASE_URL = (
        "https://github.com"
        "/IBM-Cloud/terraform-provider-ibm/releases/download/")
    TERRAFORM_BASE_URL = "https://releases.hashicorp.com/terraform/"
    TF_PROVIDER_TEMPLATE = """\
    provider "ibm" {{
        version          = ">= {ibm_provider_version}"
    {{% if generation is not none %}}
        generation       = "{{{{ generation }}}}"
    {{% endif %}}
    {{% if region is not none %}}
        region           = "{{{{ region }}}}"
    {{% endif %}}
    {{% if zone is not none %}}
        zone             = "{{{{ zone }}}}"
    {{% endif %}}
    {{% if function_namespace is not none %}}
        function_namespace = "{{{{ function_namespace }}}}"
    {{% endif %}}
    }}
    """

    def __init__(
            self,
            parameters,
            terraform_dir,
            ibm_provider_version,
            terraform_version='0.12.20',
            env=None):

        self.generation = None
        if 'generation' in parameters:
            self.generation = parameters['generation']
        self.region = None
        if 'region' in parameters:
            self.region = parameters['region']
        self.zone = None
        if 'zone' in parameters:
            self.zone = parameters['zone']
        self.function_namespace = None
        if 'function_namespace' in parameters:
            self.function_namespace = parameters['function_namespace']
        self.terraform_dir = terraform_dir
        self.ibm_provider_version = ibm_provider_version
        self.terraform_version = terraform_version
        self.executable = os.path.join(terraform_dir, 'terraform')
        self.env = env
        self.platform = sys.platform
        if self.platform.startswith('linux'):
            self.platform = 'linux'

        # Create global 'terraform_dir' accessible by all system users
        if not os.path.isdir(self.terraform_dir):
            orig_umask = os.umask(0o000)
            os.makedirs(self.terraform_dir)
            os.umask(orig_umask)

        # Create a subdirectory in 'terraform_dir' to use as a working
        # directory for a single object instance
        def tf_subdir_path():
            timestamp = datetime.now().strftime("%Y%m%d%H%M%S%f")
            return os.path.join(self.terraform_dir, timestamp)
        path = tf_subdir_path()
        while os.path.isdir(path):
            path = tf_subdir_path()
        else:
            self.directory = path
            os.makedirs(self.directory)

        # Create provider file in object subdir
        self._render_provider_file()

        # Check for existing Terraform executable
        if os.path.isfile(self.executable):
            returncode, stdout, stderr = run_process(
                '{} version'.format(self.executable))
            try:
                existing_version = re.findall(
                    r"Terraform v(\d+\.\d+\.\d+)\n", stdout)[0]
            except IndexError:
                existing_version = None

        # Download and install Terraform if desired version not found
        if (not os.path.isfile(self.executable) or
                existing_version != self.terraform_version):
            self._install_terraform()

        # Check for existing IBM Cloud provider
        provider_found = False
        for item in os.listdir(self.terraform_dir):
            if item.startswith('terraform-provider-ibm_v'):
                if item == 'terraform-provider-ibm_v' + ibm_provider_version:
                    provider_found = True
                else:
                    os.remove(os.path.join(self.terraform_dir, item))

        # Download and install IBM Cloud provider if desired version not
        # found
        if not provider_found:
            self._install_ibmcloud_tf_provider()

        # Initialize Terraform
        self.init()
        self.refresh()

    def _download_extract_zip(self, url):
        from ansible.module_utils.urls import open_url
        from ansible.module_utils.six import BytesIO
        from zipfile import ZipFile
        if not os.path.isdir(self.directory):
            os.makedirs(self.directory)
        resp = open_url(url)
        zip_archive = ZipFile(BytesIO(resp.read()))
        try:
            zip_archive.extractall(path=self.terraform_dir)
        except OSError as err:
            if err.errno != 26:  # [Errno 26] Text file busy usually caused by another thread downloading terraform
                raise err

    def _install_terraform(self):
        filename = 'terraform'
        filepath = os.path.join(self.terraform_dir, filename)
        if os.path.isfile(filepath):
            os.remove(filepath)
        self._download_extract_zip(
            "{0}{1}/terraform_{1}_{2}_amd64.zip".format(
                self.TERRAFORM_BASE_URL, self.terraform_version, self.platform))
        os.chmod(filepath, 0o777)
        self.executable = filepath

    def _install_ibmcloud_tf_provider(self):
        filename = 'terraform-provider-ibm_v' + self.ibm_provider_version
        self._download_extract_zip(
            "{0}v{1}/terraform-provider-ibm_{1}_{2}_amd64.zip".format(
                self.IBM_PROVIDER_BASE_URL, self.ibm_provider_version, self.platform))
        os.chmod(os.path.join(self.terraform_dir, filename), 0o777)

    def _render_provider_file(self):
        # Render terraform provider file
        templateEnv = jinja2.Environment(trim_blocks=True)
        provider_template = templateEnv.from_string(
            dedent(self.TF_PROVIDER_TEMPLATE.format(
                ibm_provider_version=self.ibm_provider_version)))
        with open(
                os.path.join(self.directory, 'provider.tf'), 'w') as file_obj:
            file_obj.write(provider_template.render(
                {'generation': self.generation,
                 'region': self.region,
                 'zone': self.zone,
                 'function_namespace': self.function_namespace}))
            file_obj.write("\n")

    def cleanup(self, result, rm_subdir):
        """
        Clean up Terraform environment

        Args:
            result (dict): Ansible result dictionary. If returncode is
                           non-zero subdir is saved, renamed with
                           '_failed' suffix, and the result is written
                           to file.
            rm_subdir (bool): If True subdir and all contents are
                              removed
        """
        if os.path.isdir(self.directory):
            if result['rc'] != 0:
                result_path = os.path.join(
                    self.directory, 'ansible_result.json')
                with open(result_path, 'w') as file_obj:
                    file_obj.write(json.dumps(result))
                os.rename(self.directory, self.directory + '_fail')
            elif rm_subdir:
                shutil.rmtree(self.directory)

    def init(self):
        """
        Run Terraform init to 'Initialize a Terraform working directory'

        Returns:
            (int, str, str): Tuple with (return code, stdout, stderr)
        """
        command = '{} init -no-color'.format(self.executable)
        return run_process(command, cwd=self.directory, env=self.env)

    def refresh(self):
        """
        Run Terraform refresh to 'Update local state file against real
        resources'

        Returns:
            (int, str, str): Tuple with (return code, stdout, stderr)
        """
        returncode, stdout, stderr = self.init()
        if returncode > 0:
            return (returncode, stdout, stderr)
        command = '{} refresh -no-color'.format(self.executable)
        return run_process(command, cwd=self.directory, env=self.env)

    def apply(self, target=None):
        """
        Run Terraform apply to 'Build or change infrastructure'

        Args:
            target (str, optional): Resource Address to target

        Returns:
            (int, str, str): Tuple with (return code, stdout, stderr)
        """
        returncode, stdout, stderr = self.init()
        if returncode > 0:
            return (returncode, stdout, stderr)
        command = '{} apply '.format(self.executable)
        if target is not None:
            command += '-target={} '.format(target)
        command += '-no-color -auto-approve'
        return run_process(command, cwd=self.directory, env=self.env)

    def destroy(self, target):
        """
        Run Terraform destroy to 'Destroy Terraform-managed
        infrastructure'

        Args:
            target (str): Resource Address to target

        Returns:
            (int, str, str): Tuple with (return code, stdout, stderr)
        """
        command = '{} destroy '.format(self.executable)
        if target is not None:
            command += '-target={} '.format(target)
        command += '-no-color -auto-approve'
        return run_process(command, cwd=self.directory, env=self.env)

    def import_(self, target, resource_id):
        """
        Run Terraform import to 'Import existing infrastructure into
        Terraform'

        Args:
            target (str, optional): Resource Address to target

        Returns:
            (int, str, str): Tuple with (return code, stdout, stderr)
        """
        command = '{} import {} {} -no-color'.format(
            self.executable, target, resource_id)
        return run_process(command, cwd=self.directory, env=self.env)

    def set_existing_args(self, resource):
        """
        Set any missing required arguments for an existing resource.
        This method requires the 'resource.id_' attribute to be set in
        order to call the 'self.import()' method.

        Args:
            resource (Resource): Resource object

        Returns:
            bool: True if TF is able to import the resource ID, else false
        """
        def filter_args(args):
            if isinstance(args, string_types):
                return args
            elif isinstance(args, list):
                safe_list = []
                for arg in args:
                    if isinstance(arg, dict):
                        _dict = {}
                        if 'name' in arg:
                            _dict['name'] = arg['name']
                        if 'subnet' in arg:
                            _dict['subnet'] = arg['subnet']
                        if 'network_id' in arg:
                            _dict['network_id'] = arg['network_id']
                        safe_list.append(_dict)
                    else:
                        safe_list.append(arg)
                return safe_list
            elif isinstance(args, dict):
                return args

        return_code, _, _ = self.import_(resource.target, resource.id_)
        if return_code != 0:
            return False
        existing_args = self.get_tfstate_attributes(resource.target)
        for arg, arg_type in resource.tl_required_params:
            if resource.parameters[arg] is None:
                try:
                    resource.parameters[arg] = filter_args(existing_args[arg])
                except KeyError:
                    if arg_type == 'str':
                        resource.parameters[arg] = ''
                    elif arg_type == 'list':
                        resource.parameters[arg] = []
                    elif arg_type == 'dict':
                        resource.parameters[arg] = {}
        self.add_resource(resource)
        return True

    def add_resource(self, resource):
        """
        Add resource to Terraform environment.

        Args:
            resource (Resource): Resource object
        """
        # Generate TF resource block
        tf_block = (
            '{} {} "{}" '.format(
                resource.tf_type,
                resource.resource_type,
                resource.tf_name) + '{\n' +
            fmt_tf_block(
                resource.parameters,
                indent_count=1,
                indent_spaces=2,
                validate_tl_params=resource.tl_all_params) + '}\n')

        # Write terraform resource block to file
        resource_file = '{}_{}.tf'.format(
            resource.resource_type, resource.tf_name)
        with open(
                os.path.join(self.directory, resource_file), 'w') as file_obj:
            file_obj.write(tf_block)

    def get_tfstate_attributes(self, target):
        """
        Retrieve resource primary.attributes dictionary from Terraform
        tfstate data.

        Args:
            target (str): Resource Address to target

        Returns:
            dict: Resource/DataSource return data structure, empty dict
                  if no 'terraform.tfstate' file exists
        """
        def str_keys(dictionary):
            output = {}
            for key, value in iteritems(attributes):
                output[ensure_str(key)] = value
            return output

        # Load 'tfstate' json file to extract result data
        if not os.path.isfile(
                os.path.join(self.directory, 'terraform.tfstate')):
            return dict()
        with open(
                os.path.join(self.directory, 'terraform.tfstate')) as file_obj:
            tfstate = json.load(file_obj)

        _type, _name = target.split('.', 1)
        for resource in tfstate['resources']:
            if resource['name'] == _name and resource['type'] == _type:
                attributes = resource['instances'][0]['attributes']
                break
        else:
            return {'_type': _type, '_name': _name, 'target': target}

        try:
            expanded_attributes = dict()
            for key, value in iteritems(attributes):
                if key.endswith('.#'):
                    continue
                sub_keys = key.split('.')
                nested_pointer = expanded_attributes
                for index, sub_key in enumerate(sub_keys):
                    if sub_key.isdigit():
                        sub_key = int(sub_key)
                        if sub_key > 10000:
                            sub_key = len(nested_pointer)
                            nested_pointer += ['']
                        elif sub_key >= len(nested_pointer):
                            nested_pointer += (
                                [''] * (
                                    int(sub_key) + 1 - len(nested_pointer)))
                        elif type(nested_pointer[sub_key]) is not str:
                            nested_pointer = nested_pointer[sub_key]
                            continue

                    if (type(nested_pointer) is list and
                            sub_key in nested_pointer):
                        nested_pointer = nested_pointer[sub_key]
                        continue

                    if (type(nested_pointer) is dict and
                            sub_key in nested_pointer):
                        nested_pointer = nested_pointer[sub_key]
                        continue

                    if (index + 1) == len(sub_keys):
                        nested_pointer[sub_key] = value
                    if (index + 1) < len(sub_keys):
                        if sub_keys[index + 1].isdigit():
                            nested_pointer[sub_key] = list()
                        else:
                            nested_pointer[sub_key] = dict()
                        nested_pointer = nested_pointer[sub_key]

            return str_keys(expanded_attributes)
        except KeyError:
            return str_keys(attributes)

    @staticmethod
    def parse_stderr(stderr):
        """
        Parse Terraform error messages into an easily readable message.
        The return string is intended to be used as the error message
        passed to the 'AnsibleModule.exit_json' method.

        Args:
            stderr (str): Stderr output from a Terraform failure

        Returns:
            str: Error message formatted for human readability
        """
        import json
        errors = dict()
        for line in stderr.splitlines():
            if line.strip().startswith('*'):
                resource, msg = line.strip().split(':', 1)
                resource = resource.replace('*', '').strip()
                if resource not in errors:
                    errors[resource] = []
                try:
                    err_msg = json.loads(msg.strip())
                    if 'errors' in err_msg:
                        errors[resource].append(err_msg['errors'])
                    else:
                        errors[resource].append([err_msg])
                except ValueError:
                    if not re.search(r'\d+ error\S* occurred:', msg):
                        if ':' in msg:
                            key, value = msg.strip().split(':', 1)
                        else:
                            key, value = '', msg
                        errors[resource].append([{key: value.strip()}])
        formatted_msg = ''
        count = 1
        for resource, err_list in errors.items():
            first = True
            formatted_msg += "Errors for resource: {}\n".format(resource)
            for errors in err_list:
                for error in errors:
                    for key, value in error.items():
                        if first:
                            formatted_msg += "   {}) ".format(str(count))
                            first = False
                        else:
                            formatted_msg += "      "
                        formatted_msg += "{}: {}\n".format(key, value)

        return formatted_msg


def fmt_tf_block(
        arg_dict,
        indent_count=0,
        indent_spaces=2,
        filter_None=True,
        validate_tl_params=[]):
    """
    Format a dictionary of configuration arguments into Terraform
    block syntax.

    Args:
        arg_dict (dict): Dictionary of configuration arguments
        indent_count (int, optional): Starting number of indentations
        indent_space (int, optional): Number of spaces per indentation
        filter_None (bool, optional): Do not print any 'None' values
        validate_tl_params (list, optional): Only allow top level
            parameters found on this list. If list is empty any top
            level parameter is allowed.

    Returns:
        str: Terraform block format
    """
    output = ''

    def indent(extra_count=0):
        return ' ' * ((indent_count + extra_count) * indent_spaces)

    for key, value in arg_dict.items():
        if len(validate_tl_params) > 0 and key not in validate_tl_params:
            continue
        if key.endswith("_"):
            key = key[:-1]
        if isinstance(value, dict):
            output += indent() + key + ' = {\n'
            output += fmt_tf_block(value, indent_count + 1, indent_spaces)
            output += indent() + '}\n'
        elif isinstance(value, list):
            if len(value) >= 1 and isinstance(value[0], dict):
                for item in value:
                    output += indent() + key + ' {\n'
                    output += fmt_tf_block(
                        item, indent_count + 1, indent_spaces)
                    output += indent(1) + '}\n'
            else:
                output += indent() + key + ' = ' + json.dumps(value) + '\n'
        elif (isinstance(value, bool) or (
                isinstance(value, string_types) and
                value.lower() in ['true', 'false'])):
            output += indent() + key + ' = ' + str(value).lower() + '\n'
        elif value is None and filter_None:
            pass
        else:
            output += indent() + key + ' = ' + json.dumps(value) + '\n'

    return output
