#!/usr/bin/env python2
# -*- coding: utf-8 -*-

from sys import path
from os.path import join
import json
from creole.client import CreoleClient
from amon.era import regles

creole_client = CreoleClient()

ERA_MODEL = creole_client.get_creole('type_amon')
ERA_PARENT_DIR = '/usr/share'
ERA_ROOT_DIR = join(ERA_PARENT_DIR, 'era')
ERA_MODEL_PATH = join(ERA_ROOT_DIR, 'modeles', '{}.xml'.format(ERA_MODEL))
ACTIVE_TAGS = '/var/lib/eole/config/regles.csv'
MATRIX_EXPORT_PATH = '/var/lib/eole/config/era_matrix.json'

class OptionalRule(object):
    OPTIONAL_MASK = 1
    ACTIVE_MASK = 2
    LOG_MASK = 4
    IPSET_MASK = 8
    HIDDEN_MASK = 16

    def __init__(self, label, default_state, count, interface):
        self.label = label
        self.default_state = int(default_state)
        self.state = int(default_state)
        self.count = count
        self.interface = interface

    def set_state(self, value):
        self.state = int(value)

    def is_optional(self):
        return self.OPTIONAL_MASK & self.state == self.OPTIONAL_MASK

    def is_hidden(self):
        return self.HIDDEN_MASK & self.state == self.HIDDEN_MASK

    def is_active(self):
        return self.ACTIVE_MASK & self.state == self.ACTIVE_MASK

    def activate(self):
        self.state = self.state | self.ACTIVE_MASK

    def deactivate(self):
        self.state = self.state ^ self.ACTIVE_MASK

    def output(self):
        return ','.join([self.label, str(self.state), str(self.count), self.interface])


def update_directive_states(directives):
    with open(ACTIVE_TAGS, 'r') as active_tags_stream:
        for tag in active_tags_stream.readlines():
            label, state, _, _ = tag.split(',')
            for directive in directives:
                if label == directive.label:
                    directive.set_state(state)


def get_interfaces(client):
    interfaces = {'%%nom_zone_eth{}'.format(i): {'name': client.get_creole('nom_zone_eth{}'.format(i)),
                                                 'zone': client.get_creole('dansguardian_eth{}'.format(i), None)}
                  for i in range(int(client.get_creole('nombre_interfaces')))}
    return interfaces

def get_directives(matrix):
    directives = [OptionalRule(d[0], d[1], d[2], interfaces[d[3]]['name']) for d in matrix.get_active_list()]
    update_directive_states(directives)
    return directives


def export_data(data, file_path=MATRIX_EXPORT_PATH):
    with open(file_path, 'w') as matrix_export_stream:
        json.dump(zones, matrix_export_stream)

if __name__ == '__main__':
    path.append(ERA_PARENT_DIR)
    from era.noyau.initialize import initialize_app

    matrix = initialize_app(ERA_MODEL_PATH)

    interfaces = get_interfaces(creole_client)
    directives = get_directives(matrix)

    zones = {}
    zones['générales'] = {interfaces[i]['name']: [{'label': d.label, 'state': d.state, 'count': d.count, 'interface': d.interface} for d in directives if d.interface == interfaces[i]['name']]
                          for i in interfaces
                          if not interfaces[i]['zone']}

    if creole_client.get_creole('activer_filtrage_proxy', 'non') == 'oui':
        for i in ['1', '2', '3']:
            if creole_client.get_creole('dans_instance_{}_active'.format(i)) == 'oui':
                zone = creole_client.get_creole('dansguardian_ead_filtre{}'.format(i))
                zones[zone] = {interfaces[iface]['name']: [{'label': d.label,
                                                            'state': d.state,
                                                            'count': d.count,
                                                            'interface': d.interface}
                                                            for d in directives
                                                            if d.interface == interfaces[iface]['name']]
                               for iface in interfaces
                               if interfaces[iface]['zone'] == i}

    export_data(zones, MATRIX_EXPORT_PATH)
