"""Browser to test web applications.

(from web.py)

"""

from utils import re_compile

from net import htmlunquote

import httplib, urllib, urllib2

import copy

from StringIO import StringIO

DEBUG = False

__all__ = [

    "BrowserError",

    "Browser", "AppBrowser",

    "AppHandler"

]

class BrowserError(Exception):

    pass

class Browser:

    def __init__(self):

        import cookielib

        self.cookiejar = cookielib.CookieJar()

        self._cookie_processor = urllib2.HTTPCookieProcessor(self.cookiejar)

        self.form = None

        self.url = "http://0.0.0.0:8080/"

        self.path = "/"

        self.status = None

        self.data = None

        self._response = None

        self._forms = None

    def reset(self):

        """Clears all cookies and history."""

        self.cookiejar.clear()

    def build_opener(self):

        """Builds the opener using urllib2.build_opener. 

        Subclasses can override this function to prodive custom openers.

        """

        return urllib2.build_opener()

    def do_request(self, req):

        if DEBUG:

            print 'requesting', req.get_method(), req.get_full_url()

        opener = self.build_opener()

        opener.add_handler(self._cookie_processor)

        try:

            self._response = opener.open(req)

        except urllib2.HTTPError, e:

            self._response = e

        self.url = self._response.geturl()

        self.path = urllib2.Request(self.url).get_selector()

        self.data = self._response.read()

        self.status = self._response.code

        self._forms = None

        self.form = None

        return self.get_response()

    def open(self, url, data=None, headers={}):

        """Opens the specified url."""

        url = urllib.basejoin(self.url, url)

        req = urllib2.Request(url, data, headers)

        return self.do_request(req)

    def show(self):

        """Opens the current page in real web browser."""

        f = open('page.html', 'w')

        f.write(self.data)

        f.close()

        import webbrowser, os

        url = 'file://' + os.path.abspath('page.html')

        webbrowser.open(url)

    def get_response(self):

        """Returns a copy of the current response."""

        return urllib.addinfourl(StringIO(self.data), self._response.info(), self._response.geturl())

    def get_soup(self):

        """Returns beautiful soup of the current document."""

        import BeautifulSoup

        return BeautifulSoup.BeautifulSoup(self.data)

    def get_text(self, e=None):

        """Returns content of e or the current document as plain text."""

        e = e or self.get_soup()

        return ''.join([htmlunquote(c) for c in e.recursiveChildGenerator() if isinstance(c, unicode)])

    def _get_links(self):

        soup = self.get_soup()

        return [a for a in soup.findAll(name='a')]

    def get_links(self, text=None, text_regex=None, url=None, url_regex=None, predicate=None):

        """Returns all links in the document."""

        return self._filter_links(self._get_links(),

            text=text, text_regex=text_regex, url=url, url_regex=url_regex, predicate=predicate)

    def follow_link(self, link=None, text=None, text_regex=None, url=None, url_regex=None, predicate=None):

        if link is None:

            links = self._filter_links(self.get_links(),

                text=text, text_regex=text_regex, url=url, url_regex=url_regex, predicate=predicate)

            link = links and links[0]

        if link:

            return self.open(link['href'])

        else:

            raise BrowserError("No link found")

    def find_link(self, text=None, text_regex=None, url=None, url_regex=None, predicate=None):

        links = self._filter_links(self.get_links(), 

            text=text, text_regex=text_regex, url=url, url_regex=url_regex, predicate=predicate)

        return links and links[0] or None

    def _filter_links(self, links, 

            text=None, text_regex=None,

            url=None, url_regex=None,

            predicate=None):

        predicates = []

        if text is not None:

            predicates.append(lambda link: link.string == text)

        if text_regex is not None:

            predicates.append(lambda link: re_compile(text_regex).search(link.string or ''))

        if url is not None:

            predicates.append(lambda link: link.get('href') == url)

        if url_regex is not None:

            predicates.append(lambda link: re_compile(url_regex).search(link.get('href', '')))

        if predicate:

            predicate.append(predicate)

        def f(link):

            for p in predicates:

                if not p(link):

                    return False

            return True

        return [link for link in links if f(link)]

    def get_forms(self):

        """Returns all forms in the current document.

        The returned form objects implement the ClientForm.HTMLForm interface.

        """

        if self._forms is None:

            import ClientForm

            self._forms = ClientForm.ParseResponse(self.get_response(), backwards_compat=False)

        return self._forms

    def select_form(self, name=None, predicate=None, index=0):

        """Selects the specified form."""

        forms = self.get_forms()

        if name is not None:

            forms = [f for f in forms if f.name == name]

        if predicate:

            forms = [f for f in forms if predicate(f)]

        if forms:

            self.form = forms[index]

            return self.form

        else:

            raise BrowserError("No form selected.")

    def submit(self, **kw):

        """submits the currently selected form."""

        if self.form is None:

            raise BrowserError("No form selected.")

        req = self.form.click(**kw)

        return self.do_request(req)

    def __getitem__(self, key):

        return self.form[key]

    def __setitem__(self, key, value):

        self.form[key] = value

class AppBrowser(Browser):

    """Browser interface to test web.py apps.

        b = AppBrowser(app)

        b.open('/')

        b.follow_link(text='Login')

        b.select_form(name='login')

        b['username'] = 'joe'

        b['password'] = 'secret'

        b.submit()

        assert b.path == '/'

        assert 'Welcome joe' in b.get_text()

    """

    def __init__(self, app):

        Browser.__init__(self)

        self.app = app

    def build_opener(self):

        return urllib2.build_opener(AppHandler(self.app))

class AppHandler(urllib2.HTTPHandler):

    """urllib2 handler to handle requests using web.py application."""

    handler_order = 100

    def __init__(self, app):

        self.app = app

    def http_open(self, req):

        result = self.app.request(

            localpart=req.get_selector(),

            method=req.get_method(),

            host=req.get_host(),

            data=req.get_data(),

            headers=dict(req.header_items()),

            https=req.get_type() == "https"

        )

        return self._make_response(result, req.get_full_url())

    def https_open(self, req):

        return self.http_open(req)

    try:

        https_request = urllib2.HTTPHandler.do_request_

    except AttributeError:

        # for python 2.3

        pass

    def _make_response(self, result, url):

        data = "\r\n".join(["%s: %s" % (k, v) for k, v in result.header_items])

        headers = httplib.HTTPMessage(StringIO(data))

        response = urllib.addinfourl(StringIO(result.data), headers, url)

        code, msg = result.status.split(None, 1)

        response.code, response.msg = int(code), msg

        return response