def parse(url):
    """Parse a URL for OpenSearch specification."""
    log.info('[opensearch] fetching "%s" ...', url)
    defurl = iconurl = None

    # Fetch and parse URL
    r = web.get(url)
    r.raise_for_status()
    s = r.text

    if not _is_xml(s):  # find URL of OpenSearch definition
        defurl, iconurl = _parse_html(s, url)
        if not defurl:
            log.error('[opensearch] no OpenSearch link found')
            raise NotFound(url)

        r = web.get(defurl)
        r.raise_for_status()
        s = r.text

    # Parse OpenSearch definition
    search = _parse_definition(s)
    search.validate()

    search.uid = _url2uid(url)
    search.icon_url = iconurl

    return search

def main(wf):
    url = 'https://translate.yandex.net/api/v1.5/tr.json/translate'
    # RU
    params = dict(key=API_KEY, lang='ru', text=wf.args[0])
    r = web.get(url, params)

    r.raise_for_status()

    result = r.json()

    value = result['text'][0]
    wf.add_item(title=value, arg=value, subtitle='-> RU', valid=True)

    # EN
    params = dict(key=API_KEY, lang='en', text=wf.args[0])
    r = web.get(url, params)

    r.raise_for_status()

    result = r.json()

    value = result['text'][0]
    wf.add_item(title=value, arg=value, subtitle='-> EN', valid=True)

    wf.send_feedback()

def join_channel(keys, query):
    for key in keys:
        api_key = str(key)
        channels_list = web.get('https://slack.com/api/channels.list?token=' + api_key + '&pretty=1').json()
        for channels in channels_list['channels']:
            if query == channels['name']:
                web.get('https://slack.com/api/channels.join?token=' + api_key + '&name=' + query + '&pretty=1')

def test_gzipped_content(httpserver):
    """Gzip encoding"""
    httpserver.serve_content(gifbytes,
                             headers={'Content-Type': 'image/gif'})
    r = web.get(httpserver.url)
    assert r.status_code == 200
    assert r.content == gifbytes

    httpserver.serve_content(
        gifbytes_gzip,
        headers={
            'Content-Type': 'image/gif',
            'Content-Encoding': 'gzip',
        })
    # Full response
    r = web.get(httpserver.url)
    assert r.status_code == 200
    assert r.content == gifbytes
    # Streamed response
    r = web.get(httpserver.url, stream=True)
    assert r.status_code == 200
    content = b''
    for chunk in r.iter_content():
        content += chunk
    assert content == gifbytes

def slack_files(keys):

    files_list = []

    for key in keys:
        api_key = str(key)
        slack_auth = web.get('https://slack.com/api/auth.test?token=' + api_key + '&pretty=1').json()
        if slack_auth['ok'] is False:
            wf.add_item('Authentication failed.'
                        'Try saving your API key again',
                        valid=False)
            wf.send_feedback()
            break
        else:
            files = web.get('https://slack.com/api/files.list?token=' + api_key + '&count=20&pretty=1').json()
            for file in files['files']:
                if 'initial_comment' in file:
                    files_list.append({'name': file['name'], 'id': file['id'], 'url': file['url'], 'title':
                        file['title'], 'filetype': file['filetype'], 'initial_comment': file['initial_comment'],
                                       'comment': file['initial_comment']['comment']})
                else:
                    files_list.append({'name': file['name'], 'id': file['id'], 'url': file['url'], 'title':
                        file['title'], 'filetype': file['filetype']})

    return files_list

def do_search(query, page=None):
    """
    Search for the query with the specified page or the first one if None is specified

    :rtype : dict
    """
    log.debug('Starting searching for [%s]', query)

    # Gets the first page
    if not page:
        r = web.get(search_url + query, timeout=10)
    else:
        # Gets the specified page
        r = web.get("{}{}/page/{}".format(search_url, query, page), timeout=10)

    r.raise_for_status()

    json = r.json()

    if json['Error'] != u'0':
        wf.add_item('Erro on searching', str(json['Error']), icon=ICON_ERROR)
        wf.send_feedback()
        raise SearchException('Error or searching')

    log.debug('No errors on search')

    return json

def main(wf):

    parser = argparse.ArgumentParser()
    parser.add_argument('--setkey', dest='apikey', nargs='?', default = None)
    parser.add_argument('query', nargs='?', default = None)
    args = parser.parse_args(wf.args)

    if args.apikey:
        wf.save_password('slack_api_key', args.apikey)
        return 0

    try:
        api_key = wf.get_password('slack_api_key')
    except PasswordNotFound:
        wf.add_item('No API key set.',
            'Please run slt',
            valid = False)
        wf.send_feedback()
        return 0

    if len(wf.args):
        query = wf.args[0]
    else:
        query = None

    web.get('https://slack.com/api/presence.set?token=' + api_key + '&presence=' + query + '&pretty=1')

    wf.send_feedback()

def slack_list(keys):
    wf = Workflow()
    slack_search = []

    for key in keys:
        api_key = str(key)
        slack_auth = web.get('https://slack.com/api/auth.test?token=' + api_key + '&pretty=1').json()
        if slack_auth['ok'] is False:
            wf.add_item(title='Authentication failed. Check your API key',
                        valid=False)
            wf.send_feedback()
            break
        else:
            slack_channels = web.get('https://slack.com/api/channels.list?token=' + api_key +
                                     '&exclude_archived=1&pretty=1').json()
            slack_users = web.get('https://slack.com/api/users.list?token=' + api_key + '&pretty=1').json()
            slack_groups = web.get('https://slack.com/api/groups.list?token=' + api_key + '&pretty=1').json()
            for channels in slack_channels['channels']:
                slack_search.append({'name': channels['name'], 'team': slack_auth['team'],'team_id': slack_auth['team_id'], 'id': channels['id'], 'type': 'channel', 'api_key': api_key})
            for users in slack_users['members']:
                slack_search.append({'name': users['name'], 'team': slack_auth['team'],'team_id': slack_auth['team_id'], 'id': users['id'], 'type': 'user', 'api_key': api_key})
                slack_search.append({'name': users['profile']['real_name'], 'team': slack_auth['team'],'team_id': slack_auth['team_id'], 'id': users['id'], 'type': 'user', 'api_key': api_key})
            for groups in slack_groups['groups']:
                if 'name' in groups:
                    slack_search.append({'name': groups['name'], 'team': slack_auth['team'],'team_id': slack_auth['team_id'], 'id': groups['id'], 'type': 'group', 'api_key': api_key})
    return slack_search

def main(wf):

    parser = argparse.ArgumentParser()
    parser.add_argument('query', nargs='?', default = None)
    args = parser.parse_args(wf.args)

    try:
        slack_keys = wf.get_password('slack_api_key')
    except PasswordNotFound:
        wf.add_item(title='No API key set. Please run slt',
                    valid=False)
        wf.send_feedback()
        return 0
    keys = slack_keys.split(",")

    if len(wf.args):
        query = wf.args[0]
    else:
        query = None

    for key in keys:
        api_key = str(key)
        slack_auth = web.get('https://slack.com/api/auth.test?token=' + api_key + '&pretty=1').json()
        if slack_auth['ok'] is False:
            wf.add_item(title='Authentication failed. Check your API key',
                        valid=False)
            wf.send_feedback()
        else:
            web.get('https://slack.com/api/users.setPresence?token=' + api_key + '&presence=' + query + '&pretty=1')

    wf.send_feedback()

def main(wf):
  
    if len(wf.args):
        query = wf.args[0]
    else:
        query = None
        
    if len(query) < 2:
        wf.add_item(title = 'Enter a movie title',
                    subtitle = 'Please enter more than 2 characters.')
        wf.send_feedback()
        return

    imdbURL = 'http://www.imdb.com/title/'

    moviesData = web.get('http://www.omdbapi.com/?s=' + urllib.quote(query) + '&r=json').json()
    
    if 'Response' in moviesData:
      wf.add_item(title = 'Nothing was found.')
      
    elif 'Search' in moviesData:

        for movie in moviesData['Search']:
            extendedMovieData = web.get('http://www.omdbapi.com/?tomatoes=true&i=' + movie['imdbID'] + '&r=json').json()

            wf.add_item(title = '%s (%s)' % (movie['Title'], movie['Year']),
                        subtitle = 'IMDb: %s RT: %s%s Metacritic: %s' % (extendedMovieData['imdbRating'], extendedMovieData['tomatoMeter'], '' if extendedMovieData['tomatoMeter'] == 'N/A' else '%', extendedMovieData['Metascore']),
                        arg = imdbURL + movie['imdbID'],
                        valid = True,
                        )

    wf.send_feedback()

def get_data(arg):
    url = arg_switch(arg)
    data_filename = datetime.date.today().strftime('%Y_%m_%d') + '_%s.json' % arg
    if not os.path.exists(data_filename):
        web.get(url).save_to_path(data_filename)
    data_fd = open(data_filename, 'r')
    data = json.load(data_fd)
    data_fd.close()
    return data

def _get_story_icon_file_path(wf, dir, img_url):
    regex = r'\w+\.\w+$'
    match = re.search(regex, img_url)
    img_name = match.group(0)
    img_cache_full_path = wf.cachedir + '/thumbnail_cache/' + dir + '/' + img_name
    if not os.path.exists(img_cache_full_path):
        web.get(img_url).save_to_path(img_cache_full_path)
    if not os.path.exists(img_cache_full_path):
        return default_thumsnail
    else:
        return img_cache_full_path

def downloadAudio(wf, word):
    BriURL = "http://dict.youdao.com/dictvoice?audio=" + word + "&type=1"
    AmeURL = "http://dict.youdao.com/dictvoice?audio=" + word + "&type=2"
    dirname = wf.cachedir + "/"

    res = web.get(BriURL)
    if res.status_code == 200:
        res.save_to_path(dirname + word + ".bri")
    res = web.get(AmeURL)
    if res.status_code == 200:
        res.save_to_path(dirname + word + ".ame")

def test_download(travis = None):
    url1 = 'http://unicode.org/emoji/charts-beta/full-emoji-list.html'
    url2 = 'http://unicode.org/emoji/charts/full-emoji-list.html'

    if travis:
        with travis.folding_output():
            r = web.get(url1, timeout=6000)
    else:
        r = web.get(url1, timeout=6000)

        print r.status_code

def slackList(api_key):
    slackChannels = web.get('https://slack.com/api/channels.list?token=' + api_key + '&pretty=1').json()
    slackUsers = web.get('https://slack.com/api/users.list?token=' + api_key + '&pretty=1').json()

    slackSearch = []
    for channels in slackChannels['channels']:
        slackSearch.append('#' + channels['name'])

    for users in slackUsers['members']:
        slackSearch.append('@' + users['name'])

    return slackSearch

def main(wf):

    parser = argparse.ArgumentParser()
    parser.add_argument('--message', nargs='?')
    parser.add_argument('query', nargs='?', default=None)
    args = parser.parse_args(wf.args)

    if args.message:
        query = args.message
        carrot = query.find('>')
        colon = query.find(':')
        team = query[:(colon - 1)]
        channel_name = query[(colon+2):(carrot-1)]
        message = query[(carrot+2):].split()
        if len(message) >= 2:
            message = '%20'.join(message)
        else:
            message = message[0]
        for key in slack_keys():
                api_key = str(key)
                slack_auth = web.get('https://slack.com/api/auth.test?token=' + api_key + '&pretty=1').json()
                if slack_auth['ok'] is True and slack_auth['team'] == team:
                    message_url = 'https://slack.com/api/chat.postMessage?token=' + api_key + '&channel=%23' + channel_name + '&text=' + message + '&as_user=true&pretty=1'
                    web.get(message_url)


    def wrapper():
        return slack_channels(keys=slack_keys())

    channels_list = wf.cached_data('channels', wrapper, max_age=120)

    query = args.query

    if query:
        channels_list = wf.filter(query, channels_list, key=search_slack_channels)

    if len(channels_list) == 0:
        wf.add_item(title="Enter your message",
                    arg=query,
                    valid=True)
    else:
        for channels in channels_list:
            if channels['member'] == True:
                wf.add_item(title=channels['name']+' - '+channels['team'],
                    subtitle='Member',
                    autocomplete='{0} : {1} > '.format(channels['team'], channels['name']),
                    arg=query,
                    valid=True)

    wf.send_feedback()

def login_create_cookie(wf):
    """
    Use account to login and return cookie information.
    """
    url = "http://passport.garmin.com.tw/passport/login.aspx?Page=http://biz.garmin.com.tw/introduction/index.asp&Qs="

    pwd = wf.get_password('employ_password')
    r = web.get(url=url, auth=(USER_NAME, pwd))
    r.raise_for_status()
    soup = BeautifulSoup(r.text, "html5lib")
    cookie = cookielib.MozillaCookieJar(COOKIE_NAME)
    result = web.get(soup.body.a['href'], cookies=cookie)
    result.raise_for_status()
    cookie.save(ignore_discard=True, ignore_expires=True)
    return cookie

def main(wf):

    parser = argparse.ArgumentParser()
    parser.add_argument('--join', nargs = '?')
    parser.add_argument('--leave', dest = 'leave', nargs = '?')
    parser.add_argument('query', nargs = '?', default = None)
    args = parser.parse_args(wf.args)

    try:
        api_key = wf.get_password('slack_api_key')
    except PasswordNotFound:
        wf.add_item('No API key set.'
            'Please run slt',
            valid = False)
        wf.send_feedback()
        return 0

    if args.leave:
        query = args.leave
        web.get('https://slack.com/api/channels.leave?token=' + api_key + '&channel=' + query + '&pretty=1')
    elif args.join:
        query = args.join
        channelName = getChannelName(api_key, query)
        web.get('https://slack.com/api/channels.join?token=' + api_key + '&name=' + channelName + '&pretty=1')

    def wrapper():
        return slackChannels(api_key)

    channelsList = wf.cached_data('channels', wrapper, max_age = 60)

    query = args.query

    if query:
        channelsList = wf.filter(query, channelsList, key = searchSlackChannels)

    for channels in channelsList:
        if channels['is_member'] == True:
            wf.add_item(title = channels['name'],
                subtitle = 'Member',
                arg = channels['id'],
                valid = True)
        elif channels['is_member'] == False:
            wf.add_item(title = channels['name'],
                subtitle = 'Not a member',
                arg = channels['id'],
                valid = True)

    wf.send_feedback()

def getDroplrInfo(input):
    output = []

    r = web.get(input)

    # Check for errors!
    r.raise_for_status()

     # Parse the result!
    result = r.text

    if u'Droplr.dropProps' in result:
        # We have some JS from the page! Let's read it...
        # We'll start with the title!
        tS = result.find('title: ', result.find('Droplr.dropProps')) + 8
        tE = result.find('\'', tS)
        if tS > 0 and tE > 0:
            title = result[tS:tE]
            output.append(title)
            log.debug(title)
        # Now we'll get the file type
        fS = result.find('type: ', result.find('Droplr.dropProps')) + 7
        fE = result.find('\'', fS)
        if fS > 0 and fE > 0:
            fileType = result[fS:fE].lower()
            output.append(fileType)
            log.debug(fileType)

    return output

def test_iter_content_fails_if_content_read(httpserver):
    """iter_content fails if `content` has been read"""
    httpserver.serve_content(utf8html_bytes)
    r = web.get(httpserver.url, stream=True)
    r.content
    with pytest.raises(RuntimeError):
        r.iter_content(decode_unicode=True)