#!/usr/bin/python

# Copyright: (c) 2018, Terry Jones <terry.jones@example.org>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
from __future__ import (absolute_import, division, print_function)

__metaclass__ = type

import requests

DOCUMENTATION = r'''
---
module: my_test

short_description: This is my test module

# If this is part of a collection, you need to use semantic versioning,
# i.e. the version is of the form "2.5.0" and not "2.4".
version_added: "1.0.0"

description: This is my longer description explaining my test module.

options:
    name:
        description: This is the message to send to the test module.
        required: true
        type: str
    new:
        description:
            - Control to demo if the result of this module is changed or not.
            - Parameter description can be a list as well.
        required: false
        type: bool
# Specify this value according to your collection
# in format of namespace.collection.doc_fragment_name
extends_documentation_fragment:
    - my_namespace.my_collection.my_doc_fragment_name

author:
    - Your Name (@yourGitHubHandle)
'''

EXAMPLES = r'''
# Pass in a message
- name: Test with a message
  my_namespace.my_collection.my_test:
    name: hello world

# pass in a message and have changed true
- name: Test with a message and changed output
  my_namespace.my_collection.my_test:
    name: hello world
    new: true

# fail the module
- name: Test failure of the module
  my_namespace.my_collection.my_test:
    name: fail me
'''

RETURN = r'''
# These are examples of possible return values, and in general should use other names for return values.
original_message:
    description: The original name param that was passed in.
    type: str
    returned: always
    sample: 'hello world'
message:
    description: The output message that the test module generates.
    type: str
    returned: always
    sample: 'goodbye'
'''

from ansible.module_utils.basic import AnsibleModule


def _extract_creds(module):
    return {
        "username": module.params["username"],
        "password": module.params["password"],
        "base_url": module.params["base_url"],
    }


def _get_jwt_token(creds):
    payload = {
        "Username": creds["username"],
        "Password": creds["password"],
    }

    base_url = creds["base_url"]
    auth_url = f"{base_url}/api/auth"
    resp = requests.post(auth_url, json=payload)
    resp.raise_for_status()
    return resp.json()["jwt"]


COMPOSE_STACK = 2
STRING_METHOD = "string"


class PortainerClient:
    def __init__(self, creds):
        self.base_url = creds["base_url"]
        self.token = _get_jwt_token(creds)
        self.headers = {
            "Authorization": f"Bearer {self.token}"
        }

    def get(self, endpoint):
        url = f"{self.base_url}/api/{endpoint}"
        res = requests.get(url, headers=self.headers)
        res.raise_for_status()
        return res.json()

    def post(self, endpoint, body, query_params=None):
        url = f"{self.base_url}/api/{endpoint}"
        if query_params:
            url += "?"
            for k, v in query_params.items():
                url += f"&{k}={v}"

        res = requests.post(url, json=body, headers=self.headers)
        res.raise_for_status()
        return res.json()


def run_module():
    # define available arguments/parameters a user can pass to the module
    module_args = dict(
        stack_name=dict(type='str', required=True),
        docker_compose_file_path=dict(type='str', required=True),
        env_file_path=dict(type='str', required=False),
        username=dict(type='str', default='admin'),
        password=dict(type='str', required=True),
        base_url=dict(type='str', default="http://localhost:9000")
    )

    # seed the result dict in the object
    # we primarily care about changed and state
    # changed is if this module effectively modified the target
    # state will include any data that you want your module to pass back
    # for consumption, for example, in a subsequent task
    result = dict(
        changed=False,
    )

    # the AnsibleModule object will be our abstraction working with Ansible
    # this includes instantiation, a couple of common attr would be the
    # args/params passed to the execution, as well as if the module
    # supports check mode
    module = AnsibleModule(
        argument_spec=module_args,
        supports_check_mode=True
    )

    client = PortainerClient(creds=_extract_creds(module))

    stacks = client.get("stacks")

    result["token"] = client.token
    # result["stacks"] = stacks

    file_contents = ""
    with open(module.params["docker_compose_file_path"]) as f:
        file_contents = f.read()

    result["stacks"] = stacks
    result["stack_name"] = module.params["stack_name"]

    body = {
        "body_compose_string":  {
            "name": module.params["stack_name"],
            "stackFileContent": file_contents,
        },
    }

    query_params = {
        "type": COMPOSE_STACK,
        "method": STRING_METHOD,
        "endpointId": 2,
    }

    res = client.post("stacks", body=body, query_params=query_params)
    result["res"] = res

    # if the user is working with this module in only check mode we do not
    # want to make any changes to the environment, just return the current
    # state with no modifications
    if module.check_mode:
        module.exit_json(**result)

    # manipulate or modify the state as needed (this is going to be the
    # part where your module will do what it needs to do)
    # result['original_message'] = module.params['name']
    # result['message'] = 'goodbye'

    # use whatever logic you need to determine whether or not this module
    # made any modifications to your target
    # if module.params['new']:
    #     result['changed'] = True

    # during the execution of the module, if there is an exception or a
    # conditional state that effectively causes a failure, run
    # AnsibleModule.fail_json() to pass in the message and the result
    # if module.params['name'] == 'fail me':
    #     module.fail_json(msg='You requested this to fail', **result)

    # in the event of a successful module execution, you will want to
    # simple AnsibleModule.exit_json(), passing the key/value results
    module.exit_json(**result)


def main():
    run_module()


if __name__ == '__main__':
    main()