# -*- coding:utf-8 -*-
""" Shell driver management """

from sfa.util.sfalogging import logger
from iotlabcli import auth
from iotlabcli import rest
from iotlabcli import helpers
from iotlabcli import experiment
from urllib.error import HTTPError


class IotLABShell(object):
    """
    A REST client shell to the Iot-LAB testbed API instance
    """

    def __init__(self):
        user, passwd = auth.get_user_credentials()
        self.api = rest.Api(user, passwd)

    def get_nodes(self):
        """
        Get all OAR nodes
        :returns: nodes with OAR properties
        :rtype: dict

        :Example:
        {"items": [
            {"archi": "a8:at86rf231",
             "mobile": 0,
             "mobility_type": " ",
             "network_address": "a8-53.grenoble.iot-lab.info",
             "site": "paris",
             "state": "Alive",
             "uid": "9856",
             "x": "0.37",
             "y": "5.44",
             "z": "2.33"
            },
            {"archi= ...}
          ]
        {
        """
        logger.warning("iotlashell get_nodes")
        nodes_dict = {}
        try:
            nodes = experiment.info_experiment(self.api)
        except HTTPError as err:
            logger.warning("iotlashell get_nodes error %s" % err.reason)
            return {'error': err.reason}
        for node in nodes['items']:
            nodes_dict[node['network_address']] = node
        return nodes_dict

    def get_users(self, email=None):
        """
        Get all LDAP users
        :returns: users with LDAP attributes
        :rtype: dict

        :Example:
        [{"firstName":"Frederic",
          "lastName":"Saint-marcel",
          "email":"frederic.saint-marcel@inria.fr",
          "structure":"INRIA",
          "city":"Grenoble",
          "country":"France",
          "login":"saintmar",
          sshPublicKeys":["ssh-rsa AAAAB3..."],
          "motivations":"test SFA",
          "validate":true,
          "admin":true,
          "createTimeStamp":"20120911115247Z"},
          {"firstName":"Julien",
           ...
          }
        ]
        """
        logger.warning("iotlashell get_users")
        users_dict = {}
        try:
            if email:
                users = self.api.method('admin/users?email=%s' % email)
            else:
                users = self.api.method('admin/users')
        except HTTPError as err:
            logger.warning("iotlashell get_users error %s" % err.reason)
            return {'error': err.reason}
        for user in users:
            users_dict[user['email']] = user
        return users_dict

    def reserve_nodes(self, login, exp_name,
                      nodes_list, start_time, duration):
        """
        Submit a physical experiment (nodes list) and reservation date.
        """
        # pylint:disable=W0212,R0913,E1123
        logger.warning("iotlashell reserve_nodes")
        logger.info("login=%s, exp_name=%s, nodes_list=%s, start_time=%s, duration=%s" % (login, exp_name, nodes_list, start_time, duration))
        exp_file = helpers.FilesDict()
        _experiment = experiment._Experiment(exp_name, duration, start_time)
        _experiment.type = 'physical'
        _experiment.nodes = nodes_list
        exp_file['new_exp.json'] = helpers.json_dumps(_experiment)
        try:
            return self.api.method('admin/experiments?user=%s' % login,
                                   'post',
                                   files=exp_file)
        except HTTPError as err:
            logger.warning("iotlashell reserve_nodes error %s" % err.reason)
            logger.error(err)
            return {'error': err.reason}

    def get_reserved_nodes(self):
        """
        Get all OAR jobs not terminated.

        :Example:
        {"total":"1907",
         "items":[
             {"id":9960,
              "resources": ["m3-16.devgrenoble.iot-lab.info",...],
              "duration":"36000",
              "name":"test_sniffer",
              "state":"Running",
              "owner":"saintmar",
              "nb_resources":10,
              "date":1427966468},
              {"id": ...}
         ]
        }
        """
        logger.warning("iotlashell get_reserved_nodes")
        reserved_nodes_dict = {}
        request = ('admin/experiments?state='
                   'Running,Waiting,toAckReservation,'
                   'toLaunch,Launching')
        try:
            experiments = self.api.method(request)
        except HTTPError as err:
            logger.warning("iotlashell get_reserved_nodes error %s" %
                           err.reason)
            return {'error': err.reason}
        for exp in experiments['items']:
            # BUG ASAP jobs without date information
            if exp['date'] == "as soon as possible":
                exp['date'] = 0
            reserved_nodes_dict[exp['id']] = exp
        return reserved_nodes_dict

    def add_user(self, slice_user):
        """
        Add LDAP user
        {
            "firstName":"loic",
            "lastName":"test",
            "email":"loic.test@lip6.fr",
            "organization":"SFA",
            "city":"To be defined",
            "country":"To be defined",
            "motivations":"SFA federation",
            "category":"Academic",
            "type": "SA",
            "sshPublicKey": "ssh-rsa AAAAB3Nz..."
        }       
        """
        
        # pylint:disable=E1123
        logger.warning("iotlashell add_user")
        logger.warning("slice_user: %s" % slice_user)
        if 'urn' in slice_user:
            organization = slice_user['urn']
        else:
            organization = "SFA federation"
        # single account creation
        user = {"type": "SA",
                "city": "To be defined",
                "country": "To be defined",
                "motivations": "SFA federation",
                "organization": organization,
                "category":"Academic"
                }
        email = slice_user['email']
        user['email'] = email
        user['sshPublicKey'] = slice_user['keys'][0]
        # ex : onelab.inria
        user['structure'] = slice_user['urn'].split('+')[1].replace(':','.')
        email = (email.split('@'))[0]
        user['firstName'] = email.split('.')[0]
        try:
            user['lastName'] = email.split('.')[1]
        except IndexError:
            user['lastName'] = email.split('.')[0]
        try:
            self.api.method('admin/users', 'post',
                            json=user)
        except HTTPError as err:
            logger.warning("iotlashell add_user error %s" % err.reason)