#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""Github methods module."""
from hvac import exceptions, utils
from hvac.api.vault_api_base import VaultApiBase

DEFAULT_MOUNT_POINT = "github"


class Github(VaultApiBase):
    """GitHub Auth Method (API).

    Reference: https://www.vaultproject.io/api/auth/github/index.html
    """

    def configure(
        self,
        organization,
        base_url=None,
        ttl=None,
        max_ttl=None,
        mount_point=DEFAULT_MOUNT_POINT,
    ):
        """Configure the connection parameters for GitHub.

        This path honors the distinction between the create and update capabilities inside ACL policies.

        Supported methods:
            POST: /auth/{mount_point}/config. Produces: 204 (empty body)


        :param organization: The organization users must be part of.
        :type organization: str | unicode
        :param base_url: The API endpoint to use. Useful if you are running GitHub Enterprise or an API-compatible
            authentication server.
        :type base_url: str | unicode
        :param ttl: Duration after which authentication will be expired.
        :type ttl: str | unicode
        :param max_ttl: Maximum duration after which authentication will
            be expired.
        :type max_ttl: str | unicode
        :param mount_point: The "path" the method/backend was mounted on.
        :type mount_point: str | unicode
        :return: The response of the configure_method request.
        :rtype: requests.Response
        """
        params = {
            "organization": organization,
        }
        params.update(
            utils.remove_nones(
                {
                    "base_url": base_url,
                    "ttl": ttl,
                    "max_ttl": max_ttl,
                }
            )
        )
        api_path = utils.format_url(
            "/v1/auth/{mount_point}/config",
            mount_point=mount_point,
        )
        return self._adapter.post(
            url=api_path,
            json=params,
        )

    def read_configuration(self, mount_point=DEFAULT_MOUNT_POINT):
        """Read the GitHub configuration.

        Supported methods:
            GET: /auth/{mount_point}/config. Produces: 200 application/json


        :param mount_point: The "path" the method/backend was mounted on.
        :type mount_point: str | unicode
        :return: The JSON response of the read_configuration request.
        :rtype: dict
        """
        api_path = utils.format_url(
            "/v1/auth/{mount_point}/config",
            mount_point=mount_point,
        )
        return self._adapter.get(url=api_path)

    def map_team(self, team_name, policies=None, mount_point=DEFAULT_MOUNT_POINT):
        """Map a list of policies to a team that exists in the configured GitHub organization.

        Supported methods:
            POST: /auth/{mount_point}/map/teams/{team_name}. Produces: 204 (empty body)


        :param team_name: GitHub team name in "slugified" format
        :type team_name: str | unicode
        :param policies: Comma separated list of policies to assign
        :type policies: List[str]
        :param mount_point: The "path" the method/backend was mounted on.
        :type mount_point: str | unicode
        :return: The response of the map_github_teams request.
        :rtype: requests.Response
        """
        # First, perform parameter validation.
        if policies is None:
            policies = []
        if not isinstance(policies, list) or not all(
            isinstance(p, str) for p in policies
        ):
            error_msg = 'unsupported policies argument provided "{arg}" ({arg_type}), required type: List[str]"'
            raise exceptions.ParamValidationError(
                error_msg.format(
                    arg=policies,
                    arg_type=type(policies),
                )
            )
        # Then, perform request.
        params = {
            "value": ",".join(policies),
        }
        api_path = utils.format_url(
            "/v1/auth/{mount_point}/map/teams/{team_name}",
            mount_point=mount_point,
            team_name=team_name,
        )
        return self._adapter.post(
            url=api_path,
            json=params,
        )

    def read_team_mapping(self, team_name, mount_point=DEFAULT_MOUNT_POINT):
        """Read the GitHub team policy mapping.

        Supported methods:
            GET: /auth/{mount_point}/map/teams/{team_name}. Produces: 200 application/json


        :param team_name: GitHub team name
        :type team_name: str | unicode
        :param mount_point: The "path" the method/backend was mounted on.
        :type mount_point: str | unicode
        :return: The JSON response of the read_team_mapping request.
        :rtype: dict
        """
        api_path = utils.format_url(
            "/v1/auth/{mount_point}/map/teams/{team_name}",
            mount_point=mount_point,
            team_name=team_name,
        )
        return self._adapter.get(url=api_path)

    def map_user(self, user_name, policies=None, mount_point=DEFAULT_MOUNT_POINT):
        """Map a list of policies to a specific GitHub user exists in the configured organization.

        Supported methods:
            POST: /auth/{mount_point}/map/users/{user_name}. Produces: 204 (empty body)


        :param user_name: GitHub user name
        :type user_name: str | unicode
        :param policies: Comma separated list of policies to assign
        :type policies: List[str]
        :param mount_point: The "path" the method/backend was mounted on.
        :type mount_point: str | unicode
        :return: The response of the map_github_users request.
        :rtype: requests.Response
        """
        # First, perform parameter validation.
        if policies is None:
            policies = []
        if not isinstance(policies, list) or not all(
            isinstance(p, str) for p in policies
        ):
            error_msg = 'unsupported policies argument provided "{arg}" ({arg_type}), required type: List[str]"'
            raise exceptions.ParamValidationError(
                error_msg.format(
                    arg=policies,
                    arg_type=type(policies),
                )
            )

        # Then, perform request.
        params = {
            "value": ",".join(policies),
        }
        api_path = utils.format_url(
            "/v1/auth/{mount_point}/map/users/{user_name}",
            mount_point=mount_point,
            user_name=user_name,
        )
        return self._adapter.post(
            url=api_path,
            json=params,
        )

    def read_user_mapping(self, user_name, mount_point=DEFAULT_MOUNT_POINT):
        """Read the GitHub user policy mapping.

        Supported methods:
            GET: /auth/{mount_point}/map/users/{user_name}. Produces: 200 application/json


        :param user_name: GitHub user name
        :type user_name: str | unicode
        :param mount_point: The "path" the method/backend was mounted on.
        :type mount_point: str | unicode
        :return: The JSON response of the read_user_mapping request.
        :rtype: dict
        """
        api_path = utils.format_url(
            "/v1/auth/{mount_point}/map/users/{user_name}",
            mount_point=mount_point,
            user_name=user_name,
        )
        return self._adapter.get(url=api_path)

    def login(self, token, use_token=True, mount_point=DEFAULT_MOUNT_POINT):
        """Login using GitHub access token.

        Supported methods:
            POST: /auth/{mount_point}/login. Produces: 200 application/json


        :param token: GitHub personal API token.
        :type token: str | unicode
        :param use_token: if True, uses the token in the response received from the auth request to set the "token"
            attribute on the the :py:meth:`hvac.adapters.Adapter` instance under the _adapater Client attribute.
        :type use_token: bool
        :param mount_point: The "path" the method/backend was mounted on.
        :type mount_point: str | unicode
        :return: The JSON response of the login request.
        :rtype: dict
        """
        params = {
            "token": token,
        }
        api_path = utils.format_url(
            "/v1/auth/{mount_point}/login", mount_point=mount_point
        )
        return self._adapter.login(
            url=api_path,
            use_token=use_token,
            json=params,
        )
