import urllib.request as urllib
import json
from telegraf.client import TelegrafClient
import yaml
from logging import log

with open('config.yaml') as f:
    config = yaml.load(f, Loader=yaml.FullLoader)

URL = config['server']['url']
TOKEN = config['server']['token']
VERIFY_SSL = config['server']['verify_ssl']


class Api(object):
    """Handle all RMM api Connections"""

    def __init__(self, url, apikey):
        self.url = url
        self.apikey = apikey

    def get_request(self, url):
        """
        Handles adding auth ticket to API request
        :param url: url to create request to
        :return: request to handle with urlopen
        """
        req = urllib.Request(url)
        req.add_header('X-API-KEY', self.apikey)
        return req

    def get_agent_list(self):
        url = self.url + 'agents'
        response = json.load(urllib.urlopen(self.get_request(url)))
        return response


class Agent(object):

    def __init__(self, agent_json, api_object):
        self.api = api_object
        self.agent_json = agent_json
        self.agent_id = agent_json['agent_id']
        self.hostname = agent_json['hostname']
        self.site_name = agent_json['site_name']
        self.client_name = agent_json['client_name']
        self.monitoring_type = agent_json['monitoring_type']
        self.description = agent_json['description']
        self.status = agent_json['status']
        self.details = self.download_agent_details()
        self.wmi_details = self.extract_wmi_details()

    def download_agent_details(self):
        url = self.api.url + 'agents' + '/' + str(self.agent_id)
        response = urllib.urlopen(self.api.get_request(url))
        return json.load(response)

    def extract_wmi_details(self):
        try:
            wmi_details = self.details['wmi_detail']
        except KeyError:
            log(30, "No WMI details in this agent, continuing")
            wmi_details = {}
            pass
        wmi_dict = {}
        for k, v in wmi_details.items():
            try:
                value = v[0][0]
            except IndexError:
                value = dict()
            wmi_dict[k] = value
        return wmi_dict

    def get_agent_metrics(self):
        new_values = {'agent_id': self.agent_id, 'hostname': self.hostname, 'site_name': self.site_name,
                      'client_name': self.client_name, 'status': self.status}
        agent_details = self.wmi_details
        agent_details['agent_info'] = new_values
        new_dict = {}
        for k, v in agent_details.items():
            new_values = self.prefix_keys(v, k)
            new_values = self.delete_conflict_characters(new_values)
            new_dict[k] = new_values
        return new_dict

    @staticmethod
    def delete_conflict_characters(value_dict):
        new_dict = {}
        for key, value in value_dict.items():
            new_value = str(value).replace('[', '').replace(']', '')
            new_dict[key] = new_value
        return new_dict

    @staticmethod
    def prefix_keys(value_dict, prefix):
        new_dict = {}
        for key, value in value_dict.items():
            new_dict[str(prefix) + '_' + str(key)] = value
        return new_dict

    def send_agent_metrics(self, telegraf_client_object):
        for k, v in self.get_agent_metrics().items():
            telegraf_client_object.metric(str(k), v,
                                          tags={
                                              'hdn': str(str(self.hostname) + '/' + str(self.client_name) + '/' + str(
                                                  self.site_name))})

    def __str__(self):
        params = [self.agent_id, self.hostname, self.site_name, self.client_name, self.status]
        return str(params)


api = Api(URL, TOKEN)
agent_list = api.get_agent_list()
telegraf_client = TelegrafClient(host=config['telegraf']['host'], port=config['telegraf']['port'])

for agent in agent_list:
    a = Agent(agent, api)
    a.send_agent_metrics(telegraf_client)
    for k, v in a.get_agent_metrics().items():
        print(k, v)