'''
Created on 29.01.2014

@author: rauchp
'''
from sys import stderr
from socket import gethostname
from Config.parser import config
from datetime import datetime
from flask  import abort

### json test ###
from numpy import timedelta64, float64, int64
from datetime import date
from decimal import Decimal
from math import isnan

### LOAD CONFIG ###
c = config()
conf = c.readConf()

api_host = gethostname() if conf['flask_server'] == '0.0.0.0' else conf['flask_server']
api_url = 'http://%s:%s' % (api_host, conf['flask_port'])

class Buffer(object):

    error = {
                'db_error' : {}
             }

    system = {
              '00_config' : conf,
              '0_request' : [],
              '0_done' : [],
              'device' : {},
              'error' : error
              }

    _instance = None
    _id = 0

    def __new__(cls, *args, **kwargs):
        # http://stackoverflow.com/questions/42558/python-and-the-singleton-pattern
        if not cls._instance:
            cls._instance = super(Buffer, cls).__new__(
                                cls, *args, **kwargs)
        return cls._instance

    def gen_start_url(self, l):
        '''
        generate a URL form a list
        @param l: list of aspacts of the URL
        @return: URL
        '''
        url = api_url
        for i in l:
            url = '%s/%s' % (url, i)
        return url

    def get_level(self, l):
        '''
        iterating over a dictionary on a given path
        @param l: items witch tell the path to the value
        @return: dictionary with the key and value of the last item in the list
        '''
        level = l.pop(0)
        for i in l:
            if isinstance(level, dict) and i in level:
                level = level.get(i)
            else:
                abort(404)
        self.set_href(level, self.gen_start_url(l))        #set all links above
        return {l[-1] : level}

    def generate_links(self, dic, url, postfix):
        '''
        generats a link to dic if dic is a dictionary
        @param dic: variable that is being tested on a dictionary
        @param url: previous url
        @param postfix: appendix to the given url
        '''
        if isinstance(dic, dict):
            if '00_config' in url.split('/'):
                return
            url = '%s/%s' % (url, postfix)
            self.set_href(dic, url)
        else:
            return

    def set_href(self, dic, url):
        '''
        set the ref link if dic is a dictionary
        @param dic: variable that is being tested on a dictionary
        @param url: url to the first dictionary
        '''
        if isinstance(dic, dict):
            for i in dic.keys():
                self.generate_links(dic.get(i), url, i)
            dic.update({'000_href': url})
            dic.update({'000_timestamp' : str(datetime.now())})

    def foo(self, l, args):
        '''
        @param l: list
        @param args: arguments from the reqest
        @return: Dictionary
        '''
        del l[-1]
        dic = self.get_level(l).get(l[-1])
        if isinstance(dic, dict) and 'dyn' in dic:
            message = 'generating view for %s' % (l[-1])
        else:
            abort(404)
        return { l[-1] : message, 'args' : args.to_dict(flat=False)}

    def value_to_json(self, value): #timedelta64, float64, int64
        if isinstance(value, (date, timedelta64)):
            return str(value)
        elif isinstance(value, (Decimal, float64)):
            return float(value)
        elif isinstance(value, int64):
            return int(value)
        elif isinstance(value, float) and isnan(value):
            return None
        else:
            return value

    def update_buffer(self, push):
        '''
        Method to update the Buffer on the given path
        @param push: message to push in the buffer
            construction:  key is the path
                           value is the dict
        '''

        ## Test of valid push message ##
        if not isinstance(push, dict):
            stderr.write('error wrong parameter: Type is %s expect dict' %
                         push.__class__.__name__)
            return
        if len(push.keys()) not in [1]:
            stderr.write('error wrong number of arguments: %s expect 1' %
                         len(push.keys()))
            return
        if not isinstance(push.get(push.keys()[0]) ,dict):
            stderr.write('error value is not dict')
            return

        key = push.keys()[0]
        value = push[key]
        path = key.split('/')
        if path[0] == '':
            path.remove('')

        sys = self.system
        for k in path:
            try:
                sys = sys[k]
            except KeyError:
                stderr.write('error wrong path: %s' % k)
                return
        for k in value:
            value[k] = self.value_to_json(value[k])

        sys.update(value)
        return key

    def init_buffer(self):
        self.system['reqest'].append('init')
        pass