"""
    Handling user preferences
"""

import functools
import Cookie

from qmsk.web import urltree

class Preference (urltree.URLType) :
    """
        A specific preference
    """

    # the name to use
    name = None

    # the default value
    default = None
    
    def process (self, preferences, value) :
        """
            Post-process this preference value. This can access the values of other preferences or the request via
            the given RequestPreferences. Note that the other items will not be post-processed here.

            Defaults to just return value.
        """

        return value

class RequestPreferences (object) :
    """
        Represents the specific preferences for some request
    """

    def __init__ (self, preferences, request, value_map=None) :
        """
            Initialize with the given Preferences object, http Request, and list of mapping of raw preference values
        """
        
        # store
        self.preferences = preferences
        self.request = request

        # initialize
        self.values = {}
        self.set_cookies = {}

        # load preferences
        for pref in preferences.pref_list :
            # got a value for it?
            if value_map and pref.name in value_map :
                # get value
                value = value_map[pref.name]

                # parse it
                value = pref.parse(value)

            else :
                # use default value
                value = pref.default
            
            # add
            self.values[pref.name] = value
        
        # then post-process using the Preferences
        self.values = dict(
            (name, self.preferences.pref_map[name].process(self, value)) for name, value in self.values.iteritems()
        )
    
    def get (self, pref) :
        """
            Return the value for the given Preference, or preference name
        """
        
        # Preference -> name
        if isinstance(pref, Preference) :
            pref = pref.name
        
        # look up
        return self.values[pref]

    # support dict-access
    __getitem__ = get

    def set (self, name, value_obj) :
        """
            Set a new value for the given preference
        """

        # sanity-check to make sure we're not setting it twice...
        assert name not in self.set_cookies

        # encode using the Preference object
        value_str = self.preferences.pref_map[name].build(value_obj)

        # update in our dict
        self.values[name] = value_obj

        # add to set_cookies
        self.set_cookies[name] = value_str

class Preferences (object) :
    """
        Handle user preferences using cookies
    """

    def __init__ (self, pref_list) :
        """
            Use the given list of Preference objects
        """

        # store
        self.pref_list = pref_list

        # translate to mapping as well
        self.pref_map = dict((pref.name, pref) for pref in pref_list)

    def load (self, request, ) :
        """
            Load the set of preferences for the given request, and return as a { name -> value } dict
        """

        # the dict of values
        values = {}

        # load the cookies
        cookie_data = request.env.get('HTTP_COOKIE')

        # got any?
        if cookie_data :
            # parse into a SimpleCookie
            cookies = Cookie.SimpleCookie(cookie_data)

            # update the the values
            values.update((morsel.key, morsel.value) for morsel in cookies.itervalues())
        
        else :
            cookies = None

        # apply any query parameters
        for pref in self.pref_list :
            # look for a query param
            value = request.get_arg(pref.name)

            if value :
                # override
                values[pref.name] = value

        # build the RequestPreferences object
        return cookies, RequestPreferences(self, request, values)

    def handler (self, *pref_list) :
        """
            Intended to be used as a decorator for a request handler, this will load the give Preferences and pass
            them to the wrapped handler as keyword arguments, in addition to any others given.
        """

        def _decorator (func) :
            @functools.wraps(func)
            def _handler (request, **args) :
                # load preferences
                cookies, prefs = self.load(request)

                # bind to request.prefs
                # XXX: better way to do this? :/
                request.prefs = prefs

                # update args with new ones
                args.update(((pref.name, prefs.get(pref)) for pref in pref_list))

                # handle to get response
                response = func(request, **args)

                # set cookies?
                if prefs.set_cookies :
                    if not cookies :
                        cookies = Cookie.SimpleCookie('')

                    # update cookies
                    for key, value in prefs.set_cookies.iteritems() :
                        cookies[key] = value

                    # add headers
                    for morsel in cookies.itervalues() :
                        response.add_header('Set-cookie', morsel.OutputString())

                return response
            
            # return wrapped handler
            return _handler
        
        # return decorator...
        return _decorator

# now for our defined preferences....
import pytz
import config

class TimeFormat (urltree.URLStringType, Preference) :
    """
        Time format
    """

    # set name
    name = 'time_format'

    # default value
    default = config.PREF_TIME_FMT_DEFAULT

class DateFormat (urltree.URLStringType, Preference) :
    """
        Date format
    """

    # set name
    name = 'date_format'

    # default value
    default = config.PREF_DATE_FMT_DEFAULT

class Timezone (Preference) :
    """
        Timezone
    """
    
    # set name
    name = 'timezone'

    # default value is UTC...
    default = config.PREF_TIMEZONE_DEFAULT

    def parse (self, name) :
        """
            tz_name -> pytz.timezone
        """

        return pytz.timezone(name)

    def build (self, tz) :
        """
            pytz.timezone -> tz_name
        """

        return tz.zone

class ImageFont (Preference) :
    """
        Font for ImageFormatter
    """

    # set name
    name = 'image_font'
    
    def __init__ (self, font_dict, default_name) :
        """
            Use the given { name: (path, title) } dict and default the given name
        """

        self.font_dict = font_dict
        self.default = self.parse(default_name)
    
    def parse (self, name) :
        """
            name -> (name, path, title)
        """

        path, title = self.font_dict[name]

        return name, path, title
    
    def build (self, font_info) :
        """
            (name, path, title) -> name
        """

        name, path, title = font_info

        return name

class ImageFontSize (urltree.URLIntegerType, Preference) :
    # set name, default
    name = 'image_font_size'
    default = config.PREF_IMAGE_FONT_SIZE_DEFAULT
    
    # XXX: params

class Formatter (Preference) :
    """
        LogFormatter to use
    """

    # set name
    name = 'formatter'

    def __init__ (self, formatters, default) :
        """
            Use the given { name -> class LogFormatter } dict and default (a LogFormatter class)
        """

        self.formatters = formatters
        self.default = default
    
    def parse (self, fmt_name) :
        """
            fmt_name -> class LogFormatter
        """

        return self.formatters[fmt_name]
    
    def build (self, fmt_cls) :
        """
            class LogFormatter -> fmt_name
        """

        return fmt_cls.name
    
    def process (self, prefs, fmt_cls) :
        """
            class LogFormatter -> LogFormatter(tz, time_fmt, image_font.path)
        """

        font_name, font_path, font_title = prefs[image_font]
        font_size = prefs[image_font_size]

        return fmt_cls(prefs[timezone], prefs[time_format], font_path, font_size)

class Count (urltree.URLIntegerType, Preference) :
    """
        Number of lines of log data to display per page
    """

    # set name
    name = "count"
    
    # default
    default = config.PREF_COUNT_DEFAULT
    
    def __init__ (self) :
        super(Count, self).__init__(allow_negative=False, allow_zero=False, max=config.PREF_COUNT_MAX)

# and then build the Preferences object
time_format     = TimeFormat()
date_format     = DateFormat()
timezone        = Timezone()
image_font      = ImageFont(config.FORMATTER_IMAGE_FONTS, config.PREF_IMAGE_FONT_DEFAULT)
image_font_size = ImageFontSize()
formatter       = Formatter(config.LOG_FORMATTERS, config.PREF_FORMATTER_DEFAULT)
count           = Count()

preferences = Preferences([
    time_format,
    date_format,
    timezone,
    image_font,
    image_font_size,
    formatter,
    count,
])