"""Entry point for WebDriver."""

import alert
import command
import searchcontext
import webelement

import base64


class WebDriver(searchcontext.SearchContext):
    """Controls a web browser."""

    def __init__(self, host, required, desired, mode='strict'):
        args = { 'desiredCapabilities': desired }
        if required:
            args['requiredCapabilities'] = required

        self._executor = command.CommandExecutor(host, mode)

        resp = self._executor.execute(
            'POST', '/session', None, 'newSession', args)
        self.capabilities = resp['value']
        self._session_id = resp['sessionId']
        self.mode = mode

    def execute(self, method, path, name, parameters= None):
        """Execute a command against the current WebDriver session."""
        data = self._executor.execute(
            method,
            '/session/' + self._session_id + path,
            self._session_id,
            name,
            parameters,
            self._object_hook)
        if data:
            return data['value']

    def get(self, url):
        """Navigate to url."""
        self.execute('POST', '/url', 'get', { 'url': url })

    def get_current_url(self):
        """Get the current value of the location bar."""
        return self.execute('GET', '/url', 'getCurrentUrl')

    def go_back(self):
        """Hit the browser back button."""
        self.execute('POST', '/back', 'goBack')

    def go_forward(self):
        """Hit the browser forward button."""
        self.execute('POST', '/forward', 'goForward')

    def refresh(self):
        """Refresh the current page in the browser."""
        self.execute('POST', '/refresh', 'refresh')

    def quit(self):
        """Shutdown the current WebDriver session."""
        self.execute('DELETE', '', 'quit')

    def get_window_handle(self):
        """Get the handle for the browser window/tab currently accepting
        commands.
        """
        return self.execute('GET', '/window_handle', 'getWindowHandle')

    def get_window_handles(self):
        """Get handles for all open windows/tabs."""
        return self.execute('GET', '/window_handles', 'getWindowHandles')

    def close(self):
        """Close the current tab or window.

        If this is the last tab or window, then this is the same as
        calling quit.
        """
        self.execute('DELETE', '/window', 'close')

    def maximize_window(self):
        """Maximize the current window."""
        return self._window_command('POST', '/maximize', 'maximize')

    def get_window_size(self):
        """Get the dimensions of the current window."""
        result = self._window_command('GET', '/size', 'getWindowSize')
        return {'height': result['height'], 'width': result['width']}

    def set_window_size(self, height, width):
        """Set the size of the current window."""
        self._window_command(
            'POST',
            '/size',
            'setWindowSize',
            { 'height': height, 'width': width})

    def fullscreen_window(self):
        """Make the current window fullscreen."""
        pass # implement when end point is defined

    def switch_to_window(self, name):
        """Switch to the window with the given handle or name."""
        self.execute('POST', '/window', 'switchToWindow', { 'name': name })

    def switch_to_frame(self, id):
        """Switch to a frame.

        id can be either a WebElement or an integer.
        """
        self.execute('POST', '/frame', 'switchToFrame', { 'id': id})

    def switch_to_parent_frame(self):
        """Move to the browsing context containing the currently selected frame.

        If in the top-level browsing context, this is a no-op.
        """
        self.execute('POST', '/frame/parent', 'switchToParentFrame')

    def switch_to_alert(self):
        """Return an Alert object to interact with a modal dialog."""
        alert_ = alert.Alert(self)
        alert_.get_text()
        return alert_

    def execute_script(self, script, args=[]):
        """Execute a Javascript script in the current browsing context."""
        return self.execute(
            'POST',
            '/execute',
            'executeScript',
            { 'script': script, 'args': args })

    def execute_script_async(self, script, args=[]):
        """Execute a Javascript script in the current browsing context."""
        return self.execute(
            'POST',
            '/execute_async',
            'executeScriptAsync',
            { 'script': script, 'args': args })

    def take_screenshot(self, element=None):
        """Take a screenshot.

        If element is not provided, the screenshot should be of the
        current page, otherwise the screenshot should be of the given element.
        """
        if self.mode == 'strict':
            pass # implement when endpoint is defined
        elif self.mode == 'compatibility':
            if element:
                pass # element screenshots are unsupported in compatibility
            else:
                return base64.standard_b64decode(
                    self.execute('GET', '/screenshot', 'takeScreenshot'))

    def add_cookie(self, cookie):
        """Add a cookie to the browser."""
        self.execute('POST', '/cookie', 'addCookie', { 'cookie': cookie })

    def get_cookie(self, name = None):
        """Get the cookies accessible from the current page."""
        if self.mode == 'compatibility':
            cookies = self.execute('GET', '/cookie', 'getCookie')
            if name:
                cookies_ = []
                for cookie in cookies:
                    if cookie['name'] == name:
                        cookies_.append(cookie)
                return cookies_
            return cookies
        elif self.mode == 'strict':
             pass # implement when wire protocol for this has been defined

    def set_implicit_timeout(self, ms):
        self._set_timeout('implicit', ms)

    def set_page_load_timeout(self, ms):
        self._set_timeout('page load', ms)

    def set_script_timeout(self, ms):
        self._set_timeout('script', ms)

    def _set_timeout(self, type, ms):
        params = { 'type': type, 'ms': ms }
        self.execute('POST', '/timeouts', 'timeouts', params)

    def _window_command(self, method, path, name, parameters = None):
        if self.mode == 'compatibility':
            return self.execute(
                method, '/window/current' + path, name, parameters)
        elif self.mode == 'strict':
            pass # implement this when end-points are defined in doc

    def _object_hook(self, obj):
        if 'ELEMENT' in obj:
            return webelement.WebElement(self, obj['ELEMENT'])
        return obj