#!/usr/bin/env python
# vim:fileencoding=utf-8
# License: GPLv3 Copyright: 2020, Kovid Goyal <kovid at kovidgoyal.net>

import json

from calibre import prepare_string_for_xml
from calibre.web.feeds.recipes import BasicNewsRecipe


# Article JSON parser {{{
def serialize_image(block):
    yield '<div>'
    block = block['model']
    img = block['image']
    alt = prepare_string_for_xml(img.get('alt') or '', True)
    for q in ('originalSrc', 'src'):
        if q in img:
            src = prepare_string_for_xml(img[q])
            break
    else:
        raise ValueError('No src found in img block: {}'.format(img))
    yield '<img src="{}" alt="{}"/>'.format(src, alt)
    caption = block.get('caption')
    if caption and caption.get('type') == 'text':
        yield '<div>'
        yield from serialize_paragraph(caption)
        yield '</div>'
    yield '</div>'


def block_tag(name, generator):
    yield '<' + name + '>'
    yield from generator
    yield '</' + name + '>'


def serialize_paragraph(block):
    block = block['model']
    for x in block['blocks']:
        xt = x['type']
        if xt == 'fragment':
            styles = []
            model = x['model']
            for attr in model['attributes']:
                if attr == 'bold':
                    styles.append('font-weight: bold')
                elif attr in ('italic', 'italics'):
                    styles.append('font-style: italic')
            if styles:
                prefix = '<span style="{}">'.format('; '.join(styles))
                suffix = '</span>'
            else:
                prefix = suffix = ''
            yield prefix + prepare_string_for_xml(model['text']) + suffix
        elif xt == 'urlLink':
            model = x['model']
            yield '<a href="{}">{}</a>'.format(prepare_string_for_xml(model['locator'], True), prepare_string_for_xml(model['text']))


def serialize_list(block):
    for x in block['model']['blocks']:
        if x['type'] == 'listItem':
            yield from block_tag('li', serialize_paragraph(x))


def serialize_text(block):
    block = block['model']
    for x in block['blocks']:
        xt = x['type']
        if xt == 'paragraph':
            yield from block_tag('p', serialize_paragraph(x))
        elif xt == 'unorderedList':
            yield from block_tag('ul', serialize_list(x))
        elif xt == 'orderedList':
            yield from block_tag('ol', serialize_list(x))
        else:
            raise KeyError('Unknown block type: ' + x['type'])


def serialize_contributor(contributor):
    if 'title' in contributor:
        yield '<h3>' + prepare_string_for_xml(contributor['title']) + '</h3>'
    if 'subtitle' in contributor:
        yield '<div>' + prepare_string_for_xml(contributor['subtitle']) + '</div>'


def extract_text_block_plaintext(text_block):
    # Pull the plain text out of a nested {type: text, model: {blocks: [...]}}
    # block. Used to recover a headline string from the 'headline' / 'topper'
    # block types that BBC Sport articles now use in place of the top-level
    # article['headline'] field.
    chunks = []
    for x in text_block.get('model', {}).get('blocks', []):
        if x.get('type') == 'paragraph':
            for f in x.get('model', {}).get('blocks', []):
                if f.get('type') == 'fragment':
                    chunks.append(f.get('model', {}).get('text', ''))
    return ''.join(chunks)


def parse_article_json(root, abort_article):
    data = root['data']
    has_media_experience = False
    for key in data:
        if key.startswith('article?'):
            article = data[key]['data']
            break
        elif key.startswith('media-experience?'):
            has_media_experience = True
    else:
        if has_media_experience:
            abort_article('Skipping video article')
            return
        raise KeyError('No article found in data keys: {}'.format(data.keys()))
    lines = []
    if article.get('headline'):
        lines.append('<h1>{}</h1>'.format(prepare_string_for_xml(article['headline'])))
    elif article.get('metadata', {}).get('seoHeadline'):
        # BBC Sport articles no longer populate the top-level 'headline' field;
        # the visible headline is on metadata.seoHeadline (and is plain text).
        lines.append('<h1>{}</h1>'.format(prepare_string_for_xml(article['metadata']['seoHeadline'])))
    if article.get('contributor'):
        lines.extend(serialize_contributor(article['contributor']))
    headline_emitted = bool(lines and lines[0].startswith('<h1>'))
    for block in article['content']['model']['blocks']:
        bt = block.get('type')
        if bt == 'image':
            lines.extend(serialize_image(block))
        elif bt == 'text':
            lines.extend(serialize_text(block))
        elif bt == 'headline' and not headline_emitted:
            # New BBC Sport block-type containing the headline as a nested text block.
            inner = block.get('model', {}).get('blocks') or [{}]
            text = extract_text_block_plaintext(inner[0])
            if text:
                lines.insert(0, '<h1>{}</h1>'.format(prepare_string_for_xml(text)))
                headline_emitted = True
        elif bt == 'topper' and not headline_emitted:
            # 'high-impact' BBC Sport article variant: headline lives under
            # block.model.heading.blocks[0] rather than block.model.blocks[0].
            heading = block.get('model', {}).get('heading') or {}
            inner = heading.get('blocks') or [{}]
            text = extract_text_block_plaintext(inner[0])
            if text:
                lines.insert(0, '<h1>{}</h1>'.format(prepare_string_for_xml(text)))
                headline_emitted = True
    return '<html><body id="main-content"><article>' + '\n'.join(lines) + '</article></body></html>'


def parse_raw_html(html, abort_article):
    q = '>window.__INITIAL_DATA__="{'
    idx = html.find(q)
    if idx < 0:
        print('Failed to find JSON')
        return html
    data = html[idx + len(q) - 2 :]
    idx = data.find('}";</script>')
    data = data[: idx + 2]
    data = json.loads(data)
    root = json.loads(data)
    return parse_article_json(root, abort_article)


if __name__ == '__main__':
    print(parse_raw_html(open('/t/raw.html').read(), print))
# }}}


class BBC(BasicNewsRecipe):
    title = 'BBC News (fast)'
    __author__ = 'Kovid Goyal, unkn0wn'
    description = 'Visit BBC News for up-to-the-minute news, breaking news, video, audio and feature stories. BBC News provides trusted World and UK news as well as local and regional perspectives. Also entertainment, business, science, technology and health news.'  # noqa: E501
    oldest_article = 2
    max_articles_per_feed = 100
    no_stylesheets = True
    use_embedded_content = False
    encoding = 'utf8'
    publisher = 'BBC'
    category = 'news, UK, world'
    language = 'en_GB'
    conversion_options = {
        'comments': description,
        'tags': category,
        'language': language,
        'publisher': publisher,
    }
    # Removes empty feeds - why keep them!?
    remove_empty_feeds = True
    ignore_duplicate_articles = {'title', 'url'}
    resolve_internal_links = True

    keep_only_tags = [dict(name='article')]

    remove_tags = [dict(name=['button', 'svg', 'iframe']), dict(attrs={'data-component': ['ad-slot', 'tags', 'links-block', 'metadata-block', 'topic-list']})]

    remove_attributes = ['style', 'height', 'width']
    extra_css = '''
        figure,
        [data-component="byline-block"],
        [data-component="caption-block"],
        [data-component="image-block"] {
            font-size:small;
        }
    '''
    cover_url = 'https://upload.wikimedia.org/wikipedia/commons/thumb/6/62/BBC_News_2019.svg/768px-BBC_News_2019.svg.png'
    masthead_url = 'https://upload.wikimedia.org/wikipedia/commons/4/41/BBC_Logo_2021.svg'

    def preprocess_html(self, soup):
        for placeholder in soup.findAll('img', attrs={'src': lambda x: x and x.endswith('placeholder.png')}):
            placeholder.decompose()
        for img in soup.findAll('img'):
            img.attrs = {'src': img.get('src', '')}
        for h2 in soup.findAll(['h2', 'h3']):
            h2.name = 'h4'
        return soup

    recipe_specific_options = {
        'days': {
            'short': 'Oldest article to download from this news source. In days ',
            'long': 'For example, 0.5, gives you articles from the past 12 hours',
            'default': str(oldest_article),
        }
    }

    def __init__(self, *args, **kwargs):
        BasicNewsRecipe.__init__(self, *args, **kwargs)
        d = self.recipe_specific_options.get('days')
        if d and isinstance(d, str):
            self.oldest_article = float(d)

    feeds = [
        ('Science/Environment', 'https://feeds.bbci.co.uk/news/science_and_environment/rss.xml'),
        ('Technology', 'https://feeds.bbci.co.uk/news/technology/rss.xml'),
        ('Entertainment/Arts', 'https://feeds.bbci.co.uk/news/entertainment_and_arts/rss.xml'),
        ('Business', 'https://feeds.bbci.co.uk/news/business/rss.xml'),
        ('Politics', 'https://feeds.bbci.co.uk/news/politics/rss.xml'),
        ('Health', 'https://feeds.bbci.co.uk/news/health/rss.xml'),
        ('US&Canada', 'https://feeds.bbci.co.uk/news/world/us_and_canada/rss.xml'),
        ('Latin America', 'https://feeds.bbci.co.uk/news/world/latin_america/rss.xml'),
        ('Europe', 'https://feeds.bbci.co.uk/news/world/europe/rss.xml'),
        ('South Asia', 'https://feeds.bbci.co.uk/news/world/south_asia/rss.xml'),
        ('England', 'https://feeds.bbci.co.uk/news/england/rss.xml'),
        ('Asia-Pacific', 'https://feeds.bbci.co.uk/news/world/asia_pacific/rss.xml'),
        ('Africa', 'https://feeds.bbci.co.uk/news/world/africa/rss.xml'),
        ('Top Stories', 'https://feeds.bbci.co.uk/news/rss.xml'),
    ]

    def preprocess_raw_html(self, raw_html, url):
        return parse_raw_html(raw_html, self.abort_article)
