from cStringIO import StringIO

import sys

import cgi

import urllib

import urlparse

import re

import textwrap

from Cookie import BaseCookie

from rfc822 import parsedate_tz, mktime_tz, formatdate

from datetime import datetime, date, timedelta, tzinfo

import time

import calendar

import tempfile

import warnings

from webob.datastruct import EnvironHeaders

from webob.multidict import MultiDict, UnicodeMultiDict, NestedMultiDict, NoVars

from webob.etag import AnyETag, NoETag, ETagMatcher, IfRange, NoIfRange

from webob.headerdict import HeaderDict

from webob.statusreasons import status_reasons

from webob.cachecontrol import CacheControl, serialize_cache_control

from webob.acceptparse import Accept, MIMEAccept, NilAccept, MIMENilAccept, NoAccept

from webob.byterange import Range, ContentRange

_CHARSET_RE = re.compile(r';\s*charset=([^;]*)', re.I)

_SCHEME_RE = re.compile(r'^[a-z]+:', re.I)

_PARAM_RE = re.compile(r'([a-z0-9]+)=(?:"([^"]*)"|([a-z0-9_.-]*))', re.I)

_OK_PARAM_RE = re.compile(r'^[a-z0-9_.-]+$', re.I)

__all__ = ['Request', 'Response', 'UTC', 'day', 'week', 'hour', 'minute', 'second', 'month', 'year', 'html_escape']

class _UTC(tzinfo):

    def dst(self, dt):

        return timedelta(0)

    def utcoffset(self, dt):

        return timedelta(0)

    def tzname(self, dt):

        return 'UTC'

    def __repr__(self):

        return 'UTC'

UTC = _UTC()

def html_escape(s):

    """HTML-escape a string or object

    This converts any non-string objects passed into it to strings

    (actually, using ``unicode()``).  All values returned are

    non-unicode strings (using ``&#num;`` entities for all non-ASCII

    characters).

    None is treated specially, and returns the empty string.

    """

    if s is None:

        return ''

    if not isinstance(s, basestring):

        if hasattr(s, '__unicode__'):

            s = unicode(s)

        else:

            s = str(s)

    s = cgi.escape(s, True)

    if isinstance(s, unicode):

        s = s.encode('ascii', 'xmlcharrefreplace')

    return s

def timedelta_to_seconds(td):

    """

    Converts a timedelta instance to seconds.

    """

    return td.seconds + (td.days*24*60*60)

day = timedelta(days=1)

week = timedelta(weeks=1)

hour = timedelta(hours=1)

minute = timedelta(minutes=1)

second = timedelta(seconds=1)

# Estimate, I know; good enough for expirations

month = timedelta(days=30)

year = timedelta(days=365)

class _NoDefault:

    def __repr__(self):

        return '(No Default)'

NoDefault = _NoDefault()

class environ_getter(object):

    """For delegating an attribute to a key in self.environ."""

    def __init__(self, key, default='', default_factory=None,

                 settable=True, deletable=True, doc=None,

                 rfc_section=None):

        self.key = key

        self.default = default

        self.default_factory = default_factory

        self.settable = settable

        self.deletable = deletable

        docstring = "Gets"

        if self.settable:

            docstring += " and sets"

        if self.deletable:

            docstring += " and deletes"

        docstring += " the %r key from the environment." % self.key

        docstring += _rfc_reference(self.key, rfc_section)

        if doc:

            docstring += '\n\n' + textwrap.dedent(doc)

        self.__doc__ = docstring

    def __get__(self, obj, type=None):

        if obj is None:

            return self

        if self.key not in obj.environ:

            if self.default_factory:

                val = obj.environ[self.key] = self.default_factory()

                return val

            else:

                return self.default

        return obj.environ[self.key]

    def __set__(self, obj, value):

        if not self.settable:

            raise AttributeError("Read-only attribute (key %r)" % self.key)

        if value is None:

            if self.key in obj.environ:

                del obj.environ[self.key]

        else:

            obj.environ[self.key] = value

    def __delete__(self, obj):

        if not self.deletable:

            raise AttributeError("You cannot delete the key %r" % self.key)

        del obj.environ[self.key]

    def __repr__(self):

        return '<Proxy for WSGI environ %r key>' % self.key

class header_getter(object):

    """For delegating an attribute to a header in self.headers"""

    def __init__(self, header, default=None,

                 settable=True, deletable=True, doc=None, rfc_section=None):

        self.header = header

        self.default = default

        self.settable = settable

        self.deletable = deletable

        docstring = "Gets"

        if self.settable:

            docstring += " and sets"

        if self.deletable:

            docstring += " and deletes"

        docstring += " they header %s from the headers" % self.header

        docstring += _rfc_reference(self.header, rfc_section)

        if doc:

            docstring += '\n\n' + textwrap.dedent(doc)

        self.__doc__ = docstring

    def __get__(self, obj, type=None):

        if obj is None:

            return self

        if self.header not in obj.headers:

            return self.default

        else:

            return obj.headers[self.header]

    def __set__(self, obj, value):

        if not self.settable:

            raise AttributeError("Read-only attribute (header %s)" % self.header)

        if value is None:

            if self.header in obj.headers:

                del obj.headers[self.header]

        else:

            obj.headers[self.header] = value

    def __delete__(self, obj):

        if not self.deletable:

            raise AttributeError("You cannot delete the header %s" % self.header)

        del obj.headers[self.header]

    def __repr__(self):

        return '<Proxy for header %s>' % self.header

class converter(object):

    """

    Wraps a decorator, and applies conversion for that decorator

    """

    def __init__(self, decorator, getter_converter, setter_converter, convert_name=None, doc=None, converter_args=()):

        self.decorator = decorator

        self.getter_converter = getter_converter

        self.setter_converter = setter_converter

        self.convert_name = convert_name

        self.converter_args = converter_args

        docstring = decorator.__doc__ or ''

        docstring += "  Converts it as a "

        if convert_name:

            docstring += convert_name + '.'

        else:

            docstring += "%r and %r." % (getter_converter, setter_converter)

        if doc:

            docstring += '\n\n' + textwrap.dedent(doc)

        self.__doc__ = docstring

    def __get__(self, obj, type=None):

        if obj is None:

            return self

        value = self.decorator.__get__(obj, type)

        return self.getter_converter(value, *self.converter_args)

    def __set__(self, obj, value):

        value = self.setter_converter(value, *self.converter_args)

        self.decorator.__set__(obj, value)

    def __delete__(self, obj):

        self.decorator.__delete__(obj)

    def __repr__(self):

        if self.convert_name:

            name = ' %s' % self.convert_name

        else:

            name = ''

        return '<Converted %r%s>' % (self.decorator, name)

def _rfc_reference(header, section):

    if not section:

        return ''

    major_section = section.split('.')[0]

    link = 'http://www.w3.org/Protocols/rfc2616/rfc2616-sec%s.html#sec%s' % (

        major_section, section)

    if header.startswith('HTTP_'):

        header = header[5:].title().replace('_', '-')

    return "  For more information on %s see `section %s <%s>`_." % (

        header, section, link)

class deprecated_property(object):

    """

    Wraps a decorator, with a deprecation warning or error

    """

    def __init__(self, decorator, attr, message, warning=True):

        self.decorator = decorator

        self.attr = attr

        self.message = message

        self.warning = warning

    def __get__(self, obj, type=None):

        if obj is None:

            return self

        self.warn()

        return self.decorator.__get__(obj, type)

    def __set__(self, obj, value):

        self.warn()

        self.decorator.__set__(obj, value)

    def __delete__(self, obj):

        self.warn()

        self.decorator.__delete__(obj)

    def __repr__(self):

        return '<Deprecated attribute %s: %r>' % (

            self.attr,

            self.decorator)

    def warn(self):

        if not self.warning:

            raise DeprecationWarning(

                'The attribute %s is deprecated: %s' % (self.attr, self.message))

        else:

            warnings.warn(

                'The attribute %s is deprecated: %s' % (self.attr, self.message),

                DeprecationWarning,

                stacklevel=3)

def _parse_date(value):

    if not value:

        return None

    t = parsedate_tz(value)

    if t is None:

        # Could not parse

        return None

    t = mktime_tz(t)

    return datetime.fromtimestamp(t, UTC)

def _serialize_date(dt):

    if dt is None:

        return None

    if isinstance(dt, unicode):

        dt = dt.encode('ascii')

    if isinstance(dt, str):

        return dt

    if isinstance(dt, timedelta):

        dt = datetime.now() + dt

    if isinstance(dt, (datetime, date)):

        dt = dt.timetuple()

    if isinstance(dt, (tuple, time.struct_time)):

        dt = calendar.timegm(dt)

    if not isinstance(dt, (float, int)):

        raise ValueError(

            "You must pass in a datetime, date, time tuple, or integer object, not %r" % dt)

    return formatdate(dt)

def _parse_date_delta(value):

    """

    like _parse_date, but also handle delta seconds

    """

    if not value:

        return None

    try:

        value = int(value)

    except ValueError:

        pass

    else:

        delta = timedelta(seconds=value)

        return datetime.now() + delta

    return _parse_date(value)

def _serialize_date_delta(value):

    if not value and value != 0:

        return None

    if isinstance(value, (float, int)):

        return str(int(value))

    return _serialize_date(value)

def _parse_etag(value, default=True):

    if value is None:

        value = ''

    value = value.strip()

    if not value:

        if default:

            return AnyETag

        else:

            return NoETag

    if value == '*':

        return AnyETag

    else:

        return ETagMatcher.parse(value)

def _serialize_etag(value, default=True):

    if value is None:

        return None

    if value is AnyETag:

        if default:

            return None

        else:

            return '*'

    return str(value)

def _parse_if_range(value):

    if not value:

        return NoIfRange

    else:

        return IfRange.parse(value)

def _serialize_if_range(value):

    if value is None:

        return value

    if isinstance(value, (datetime, date)):

        return _serialize_date(value)

    if not isinstance(value, str):

        value = str(value)

    return value or None

def _parse_range(value):

    if not value:

        return None

    # Might return None too:

    return Range.parse(value)

def _serialize_range(value):

    if isinstance(value, (list, tuple)):

        if len(value) != 2:

            raise ValueError(

                "If setting .range to a list or tuple, it must be of length 2 (not %r)"

                % value)

        value = Range([value])

    if value is None:

        return None

    value = str(value)

    return value or None

def _parse_int(value):

    if value is None or value == '':

        return None

    return int(value)

def _parse_int_safe(value):

    if value is None or value == '':

        return None

    try:

        return int(value)

    except ValueError:

        return None

def _serialize_int(value):

    if value is None:

        return None

    return str(value)

def _parse_content_range(value):

    if not value or not value.strip():

        return None

    # May still return None

    return ContentRange.parse(value)

def _serialize_content_range(value):

    if value is None:

        return None

    if isinstance(value, (tuple, list)):

        if len(value) not in (2, 3):

            raise ValueError(

                "When setting content_range to a list/tuple, it must "

                "be length 2 or 3 (not %r)" % value)

        if len(value) == 2:

            begin, end = value

            length = None

        else:

            begin, end, length = value

        value = ContentRange(begin, end, length)

    value = str(value).strip()

    if not value:

        return None

    return value

def _parse_list(value):

    if value is None:

        return None

    value = value.strip()

    if not value:

        return None

    return [v.strip() for v in value.split(',')

            if v.strip()]

def _serialize_list(value):

    if not value:

        return None

    if isinstance(value, unicode):

        value = str(value)

    if isinstance(value, str):

        return value

    return ', '.join(map(str, value))

def _parse_accept(value, header_name, AcceptClass, NilClass):

    if not value:

        return NilClass(header_name)

    return AcceptClass(header_name, value)

def _serialize_accept(value, header_name, AcceptClass, NilClass):

    if not value or isinstance(value, NilClass):

        return None

    if isinstance(value, (list, tuple, dict)):

        value = NilClass(header_name) + value

    value = str(value).strip()

    if not value:

        return None

    return value

class Request(object):

    ## Options:

    charset = None

    unicode_errors = 'strict'

    decode_param_names = False

    ## The limit after which request bodies should be stored on disk

    ## if they are read in (under this, and the request body is stored

    ## in memory):

    request_body_tempfile_limit = 10*1024

    def __init__(self, environ=None, environ_getter=None, charset=NoDefault, unicode_errors=NoDefault,

                 decode_param_names=NoDefault):

        if environ is None and environ_getter is None:

            raise TypeError(

                "You must provide one of environ or environ_getter")

        if environ is not None and environ_getter is not None:

            raise TypeError(

                "You can only provide one of the environ and environ_getter arguments")

        if environ is None:

            self._environ_getter = environ_getter

        else:

            if not isinstance(environ, dict):

                raise TypeError(

                    "Bad type for environ: %s" % type(environ))

            self._environ = environ

        if charset is not NoDefault:

            self.__dict__['charset'] = charset

        if unicode_errors is not NoDefault:

            self.__dict__['unicode_errors'] = unicode_errors

        if decode_param_names is not NoDefault:

            self.__dict__['decode_param_names'] = decode_param_names

    def __setattr__(self, attr, value, DEFAULT=[]):

        ## FIXME: I don't know why I need this guard (though experimentation says I do)

        if getattr(self.__class__, attr, DEFAULT) is not DEFAULT or attr.startswith('_'):

            object.__setattr__(self, attr, value)

        else:

            self.environ.setdefault('webob.adhoc_attrs', {})[attr] = value

    def __getattr__(self, attr):

        ## FIXME: I don't know why I need this guard (though experimentation says I do)

        if attr in self.__class__.__dict__:

            return object.__getattribute__(self, attr)

        try:

            return self.environ['webob.adhoc_attrs'][attr]

        except KeyError:

            raise AttributeError(attr)

    def __delattr__(self, attr):

        ## FIXME: I don't know why I need this guard (though experimentation says I do)

        if attr in self.__class__.__dict__:

            return object.__delattr__(self, attr)

        try:

            del self.environ['webob.adhoc_attrs'][attr]

        except KeyError:

            raise AttributeError(attr)

    def environ(self):

        """

        The WSGI environment dictionary for this request

        """

        return self._environ_getter()

    environ = property(environ, doc=environ.__doc__)

    def _environ_getter(self):

        return self._environ

    def _body_file__get(self):

        """

        Access the body of the request (wsgi.input) as a file-like

        object.

        If you set this value, CONTENT_LENGTH will also be updated

        (either set to -1, 0 if you delete the attribute, or if you

        set the attribute to a string then the length of the string).

        """