import mysql.connector as ipam_connector
import requests
import json
import os.path

from query_strings import QUERY_DEVICES
from RequestModel import RequestModel
from ZabbixAnswerModel import ZabbixAnswerModel
from ErrorModel import ErrorModel


class IpamUtility:
    cursor = None
    ipam_connection = None

    def __init__(self):
        self.connect()

    def connect(self):
        self.ipam_connection = ipam_connector.connect(user='ipam_audit',
                                                      password='Dp5EudkQe5X7Xp5A',
                                                      database='phpipam',
                                                      host='10.20.48.98')
        self.cursor = self.ipam_connection.cursor()

    def query_ipam_db(self, query_string):
        if self.cursor:
            self.cursor.execute(query_string)
            return self.cursor


class ZabbixApiClient:
    base_url = ""

    def __init__(self, base_url):
        self.base_url = base_url

    def login(self, user_login, password):

        login_model = RequestModel()
        login_model.jsonrpc = "2.0"
        login_model.method = "user.login"
        login_model.params = {
            "user": user_login,
            "password": password
        }
        login_model.id = 1
        login_model.auth = None

        dump = json.dumps(login_model.__dict__)

        r = requests.post(self.base_url,
                          data=dump,
                          headers={'Content-Type': 'application/json'}
                          )

        if r.status_code == 200:
            json_result = r.content
            print("ZabbixClient: Logged in successfully.")

            if json_result:
                payload = ZabbixAnswerModel(json_result)
                print("Zabbix Client: Token acquired.")
                return payload.result

        else:
            print("Error: %d" % r.status_code)

    def get_hosts(self, token):
        request_model = RequestModel()
        request_model.jsonrpc = "2.0"
        request_model.method = "host.get"
        request_model.params = {
            "output": [
                "host"
            ],
            "selectInterfaces": [
                "ip"
            ]
        }
        request_model.id = 2
        request_model.auth = token

        dump = json.dumps(request_model.__dict__)

        r = requests.post(self.base_url,
                          headers={
                              'Content-Type': "application/json"
                          },
                          data=dump
                          )

        if r.status_code == 200:
            payload = ZabbixAnswerModel(r.content)
            return payload
        else:
            print("Error: Server responded with: %d" % r.status_code)


def compare_data_sets(ipam_data_set, zabbix_data_set):
    out_entries = []
    if zabbix_data_set and ipam_data_set:
        try:
            for ipam_entry in ipam_data_set:
                if ipam_entry not in zabbix_data_set:
                    out_entries.append(ipam_entry)

        except TypeError as e:
            print(e)

        return out_entries
    else:
        print("Not enough data sets retrieved.")


def prepare(data_set):
    result = []
    for host in data_set:
        result.append((host['host'], host['interfaces'][0]['ip']))

    return result


def write_to_file(file, diff_list):
    for entry in diff_list:
        out_string = ""
        for index in entry:
            out_string += str(index) + ","
        file.write(out_string.strip(',') + "\n")


def write_unique_ipam(diff_list,
                      diff_uniq_ipam_path
                      ):
    file = open(diff_uniq_ipam_path, "w")

    write_to_file(file, diff_list)


def write_unique_zabbix(diff_list,
                        diff_uniq_zabbix_path):
    file = open(diff_uniq_zabbix_path, "w")

    write_to_file(file, diff_list)


def write_diff_hosts(ipam_data_set, zabbix_data_set, path):
    out_result = []
    for ipam_tuple in ipam_data_set:
        for zabbix_tuple in zabbix_data_set:
            if ipam_tuple[1] == zabbix_tuple[1] and ipam_tuple[0] != zabbix_tuple[0]:
                out_result.append((ipam_tuple[1], zabbix_tuple[0], ipam_tuple[0]))

    out_file = open(path, "w")
    write_to_file(out_file, out_result)


def write_diff_ips(ipam_data_set, zabbix_data_set, path):
    out_result = []
    for ipam_tuple in ipam_data_set:
        for zabbix_tuple in zabbix_data_set:
            if ipam_tuple[1] != zabbix_tuple[1] and ipam_tuple[0] == zabbix_tuple[0]:
                out_result.append((ipam_tuple[0], zabbix_tuple[1], ipam_tuple[1]))

    out_file = open(path, "w")
    write_to_file(out_file, out_result)


def load_ommit_list(ommit_path):
    ommit_ipam_list = []

    if os.path.isfile(ommit_path):
        ommit_file = open(ommit_path, "r")
        lines = ommit_file.readlines()
        for line in lines:
            ommit_ipam_list.append(tuple(line.strip().split(",")))

        print("Ommit file(%s) found, records read: %d" % (ommit_path, len(ommit_ipam_list)))
    else:
        print("No such file: %s." % ommit_path)

    return ommit_ipam_list


def apply_ommit(diff_list, ommit_list):
    ommited_counter = 0
    for entry in ommit_list:
        if entry in diff_list:
            diff_list.remove(entry)
            ommited_counter += 1

    print("Ommission applied, ommited files count %d" % ommited_counter)


def main():
    home_dir = "/opt/ipam/"
    config_dir = home_dir+"config/"
    out_dir = home_dir+"out/"
    ommit_ipam_list = load_ommit_list("%suniq_ipam_ommit.conf" % config_dir)
    ommit_zabbix_list = load_ommit_list("%suniq_zabbix_ommit.conf" % config_dir)

    main_obj = IpamUtility()
    cursor = main_obj.query_ipam_db(QUERY_DEVICES)
    ipam_data_set = cursor.fetchall()
    zabbix_api_client = ZabbixApiClient("http://192.168.17.200/zabbix/api_jsonrpc.php")
    token = zabbix_api_client.login("zabbix_audit", "42TDvW6meBt6stKF")
    payload = zabbix_api_client.get_hosts(token)
    zabbix_data_set = payload.result

    if payload:
        if zabbix_data_set and ipam_data_set:
            zabbix_data_set = prepare(zabbix_data_set)
            diff_ipam = compare_data_sets(ipam_data_set, zabbix_data_set)
            print("IPAM knows: %d hosts." % len(ipam_data_set))
            diff_zabbix = compare_data_sets(zabbix_data_set, ipam_data_set)
            print("Zabbix knows: %d hosts." % len(zabbix_data_set))
            apply_ommit(diff_zabbix, ommit_zabbix_list)
            apply_ommit(diff_ipam, ommit_ipam_list)
            write_unique_ipam(diff_ipam, "%sdiff_uniq_ipam.log" % out_dir)
            write_unique_zabbix(diff_zabbix, "%sdiff_uniq_zabbix.log" % out_dir)

            write_diff_hosts(ipam_data_set, zabbix_data_set, "%sdiff_hosts.log" % out_dir)
            write_diff_ips(ipam_data_set, zabbix_data_set, "%sdiff_ips.log" % out_dir)

    else:
        if payload is ErrorModel:
            print(payload.error)


if __name__ == "__main__":
    main()