import re

import json

from datetime import datetime

import pygeoip

FINGERPRINT_REGEX = re.compile(r'^[A-Z0-9]{40}$', re.I)

IP_REGEX = (r'^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}'

            r'(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$')

IP_REGEX = re.compile(IP_REGEX)

PRIVATE_IP_REGEX = (r'(^127\.)|(^192\.168\.)|(^10\.)|(^172\.1[6-9]\.)'

                    r'|(^172\.2[0-9]\.)|(^172\.3[0-1]\.)|'

                    r'255\.255\.255\.255')

PRIVATE_IP_REGEX = re.compile(PRIVATE_IP_REGEX)

DATE_FORMAT = '%d-%m-%Y %H:%M:%S'

gi4 = pygeoip.GeoIP('/usr/share/GeoIP/GeoIP.dat', pygeoip.MEMORY_CACHE)

def check_bridge(key, server):

    if key not in server:

        raise ValueError('%s key not present!\n' % key)

    else:

        if not isinstance(server[key], bool):

            error_message = ('%s has not the right type!'

                             ' Needs to be a boolean!\n') % key

            raise ValueError(error_message)

def check_json_format(server):

    for key in ('server_type', 'server_name', 'tor_status', 'fingerprint'):

        if key not in server:

            raise ValueError('%s key not present!\n' % key)

    if server['server_type'] not in ('Exit', 'Relay', 'Bridge'):

        error_message = ('server_type has not the right content!'

                         ' is: %s must be one of: Exit, Relay or Bridge\n') \

            % server['server_type']

        raise ValueError(error_message)

    if not server['tor_status'] in ('Online', 'Offline'):

        error_message = ('tor_status has not the right content!'

                         ' is: %s must be one of: Online or Offline\n') \

            % server['tor_status']

    if FINGERPRINT_REGEX.match(server['fingerprint']) is None:

        raise ValueError('fingerprint has not the right format!\n')

    if server['server_type'] == 'Bridge':

        for key in ('obfs', 'fteproxy', 'flashproxy', 'meek'):

            check_bridge(key, server)

    if 'ip' in server:

        if IP_REGEX.match(server['ip']) is None:

            raise ValueError('ip is not the right format!\n')

        elif PRIVATE_IP_REGEX.match(server['ip']) is not None:

            raise ValueError('ip is not accepted!\n')

    return True

def update_server(server, ip):

    server['last_updated'] = datetime.utcnow().strftime(DATE_FORMAT)

    server['server_status'] = 'Online'

    server['country'] = gi4.country_name_by_addr(ip)

    if server['server_type'] == 'Bridge':

        if 'ip' in server:

            del server['ip']

    else:

        for key in ('obfs', 'fteproxy', 'flashproxy', 'meek'):

            if key in server:

                del server[key]

        if 'ip' not in server:

            server['ip'] = ip

    try:

        with open(filename, 'w', encoding='utf-8') as fb:

            json.dump(server, fb)

    except Exception as e:

        return e

import os

import os.path

import json

from collections import defaultdict

from datetime import datetime

from flask import current_app

from flask_mail import Mail, Message

mail = Mail()

    current_app.logger.info('Try sending mail')

    try:

                      sender='ennstatus@enn.lu')

        msg.add_recipient(current_app.config['SERVER_ADMINS'][server_name])

        msg.body = ('%s went offline. I received the last update at %s'

                    % (server_name, last_updated))

        mail.send(msg)

    except KeyError:

        current_app.logger.error('Admin for %s not found!' % server_name)

    except AssertionError:

        pass

    except Exception as e:

        current_app.logger.error('Unexpected error: %s' % e,

                                 exc_info=True)

    current_app.logger.info('Finished trying!')

def _check_server(data):

    server_name = data['server_name']

    last_updated = data['last_updated']

    current_status = data['server_status']

    filename = os.path.join('data', '.'.join([server_name.lower(), 'json']))

    date = datetime.strptime(last_updated, '%d-%m-%Y %H:%M:%S')

    now = datetime.utcnow()

    delta = now - date

    if delta.days >= 7:

        os.remove(filename)

        current_app.logger.error('%s was removed!' % server_name)

        return False

    elif current_status == 'Offline':

        return data

    if delta.seconds >= 3600:

        status = 'Offline'

    elif delta.seconds >= 1200:

        status = 'Unknown'

    else:

        status = None

    if status is not None:

        current_app.logger.error('%s is set to %s' % (server_name,

                                 status))

        if (current_status == 'Online' or current_status == 'Unknown') and \

           status == 'Offline':

            _send_mail(server_name, last_updated)

        for key in ('server_status', 'tor_status'):

            data[key] = status

        with open(filename, mode='w', encoding='utf-8') as file_object:

            json.dump(data, file_object)

    return data

def _load_single_server(filename):

    current_app.logger.info('Loading {}'.format(filename))

    try:

        with open(filename, encoding='utf-8') as f:

            server = json.load(f)

    except (IOError, ValueError):

        return False

    server = _check_server(server)

    return server

def single_server(name):

    filename = ''.join(['data/', name, '.json'])

    return _load_single_server(filename)

def _get_json_files(root, files):

    for f in files:

        if f.endswith('.json'):

            yield os.path.join(root, f)

def all_servers():

    for root, _, files in os.walk('data'):

        for f in _get_json_files(root, files):

            yield _load_single_server(f)

def all_servers_by_type(type):

    for server in all_servers():

        try:

            if server['server_type'] == type:

                yield server

        except TypeError:

            continue

def split_all_servers_to_types():

    servers = defaultdict(list)

    for server in all_servers():

        try:

            servers[server['server_type']].append(server)

        except TypeError:

            continue

    return servers