"""
You shouldn't need to import this module directly.
Instead, import aruba_commands and use the context manager to issue poe commands.
"""
import base64
import json
import logging
import os
import sys

import requests
import yaml

log = logging.getLogger(__name__)
logging.basicConfig(
    level=logging.DEBUG,
    filename='aruba.log',
    filemode='w',
    format='%(asctime)s [%(levelname)8s] %(message)s (%(filename)s:%(lineno)s',
    datefmt='%Y-%m-%d %H:%M:%S'
)

YAML_CONFIG = 'aruba.yaml'

# Stacked switches should use version 3 or higher
api_version = '3'


try:
    cfg = yaml.load(
        open(
            os.path.join(
                os.path.dirname(os.path.dirname(__file__)),
                YAML_CONFIG),
            'r'
        )
    )

except FileNotFoundError as error:
    log.error('YAML configuration file is required: {}'.format(error))
    sys.exit(1)


def get_bb_credentials(switch_name, credential):
    return cfg['switches'][switch_name][credential]


def login_os(switch_name):
    """
    Login to ArubaOS REST API
    :param string switch_name: name of the switch
    :return: cookie header for REST API access for current session
    :rtype: string
    :Example:

    >>>login_os('bbsa')
    """
    params = {
        'userName': get_bb_credentials(switch_name, 'username'),
        'password': get_bb_credentials(switch_name, 'password')
    }
    proxies = {'http': None, 'https': None}
    ip = cfg['switches'][switch_name]['ip']
    url_login = 'http://{}/rest/v{}/login-sessions'.format(ip, api_version)

    # We'll let any Requests exceptions bubble up
    response = requests.post(url_login, verify=False, data=json.dumps(params), proxies=proxies, timeout=3)
    if response.status_code == 201:
        log.info('Login to switch {} is successful.'.format(switch_name))
        session = response.json()
        r_cookie = session['cookie']
        return r_cookie
    else:
        log.info('Login to switch {} returned HTTP {}.'.format(switch_name, response.status_code))


def logout_os(url, cookie):
    """
    Logout of ArubaOS REST API
    :param str url: base url of switch
    :param str cookie: cookie header for REST API access for current session
    :Example:

    >>>logout_os('http://10.2.8.3/rest/v3/', 'e3k...Tse')
    """
    url_login = url + "login-sessions"
    headers = {'cookie': cookie}
    proxies = {'http': None, 'https': None}
    response = requests.delete(url_login, headers=headers, verify=False, proxies=proxies)
    if response.status_code == 204:
        log.info('Logout of switch is successful.')
    else:
        log.info('Logout of switch is not successful ({}).'.format(response.status_code))


def execute_cli(url, cmd, cookie):
    """
    Send CLI commands supported on ArubaOS switch via REST API.
    :param str url: base url of switch
    :param str cookie: cookie header for REST API access for current session
    :param str cmd: cli command to be executed
    :return JSON response
    :Example:

    >>>execute_cli('http://10.2.8.3/rest/v3/', 'show vlan', 'e3k...Tse')
    """
    url = url + 'cli'
    headers = {'cookie': cookie}
    command = {"cmd": cmd}
    response = requests.post(url, verify=False, data=json.dumps(command), headers=headers)
    log.info(response.json()['status'])
    return response.json()


def decode_cli_response(json_response):
    """
    Decode the base64-encoded CLI response
    :param dict json_response: JSON response from CLI request
    :return: UTF-8 decoded response
    :Example:

    >>> decode_cli_response(execute_cli('http://10.2.8.3/rest/v3/', 'show vlan', 'e3k...Tse'))
    """
    result = json_response.get('result_base64_encoded', None)
    return base64.b64decode(result).decode('utf-8')


def execute_api(url, cmd, cookie, payload=None):
    """
    Execute an API using the GET verb
    :param url: base url of switch
    :param cmd: API endpoint
    :param cookie: cookie header for REST API access for current session
    :return: JSON response
    """
    url = url + cmd
    headers = {'cookie': cookie}
    if 'payload' is not None:
        response = requests.put(url, verify=False, headers=headers, data=payload)
    else:
        response = requests.get(url, verify=False, headers=headers)
    return response.json()