"""Backfill apple id for episodes under public rss feeds.

Run this in dev with command
PYTHONPATH=. env/bin/python3.8 dev/backfill_apple_id_for_episodes_under_public_rss_feeds.py -- -env dev
"""

import argparse
import logging
import sys

from podcast.connectors import mysql
from podcast.constants.common import PUBLIC_RSS
from podcast.models.episode import Episode
from podcast.models.episode import update_episode
from podcast.models.episode_links import EpisodeLink
from podcast.models.podcast import Podcast
from podcast.utils import api_utils


log = logging.getLogger('main')
log.setLevel(logging.DEBUG)
fmt = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
sh = logging.StreamHandler(sys.stdout)
sh.setFormatter(fmt)
log.addHandler(sh)


users = {
    'dev': '366',
    'qa': '1298',
    'prod': '88'
}

request_headers = None
apple_store_id = 1


def get_episodes_with_apple_link_by_podcast_id(podcast_id):
    """Return the episodes having apple episode link by podcast id.

    Args:
        podcast_id (int): the podcast identifier
    Returns:
        list of dict: containing the episode dict having episode id and apple episode link.
    """
    with mysql.pod_db_session(read_only=True) as session:
        rows = session.query(Episode.id, EpisodeLink.link).join(
            EpisodeLink, Episode.id == EpisodeLink.episode_id).filter(
                Episode.podcast_id == podcast_id,
                Episode.apple_id.is_(None),
                Episode.is_deleted.isnot(True),
                EpisodeLink.store_id == apple_store_id,
                EpisodeLink.link.isnot(None)
        ).all()
        return [{'episode_id': row.id, 'apple_episode_link': row.link} for row in rows]


def get_public_rss_podcasts():
    """Return public-rss podcasts details.

    Returns:
        list of dict: containing the podcasts dict having podcast id and feed type.
    """
    with mysql.pod_db_session(read_only=True) as session:
        podcasts = session.query(Podcast.id, Podcast.feed_type).filter(
            Podcast.feed_type == PUBLIC_RSS,
            Podcast.is_deleted.isnot(True)
        )

        return [{'id': podcast.id, 'feed_type': podcast.feed_type} for podcast in podcasts]


def backfill_apple_id_for_episodes_under_public_rss_feeds():
    """Backfill apple id for episodes under public rss feeds."""
    podcast_id = None
    error_podcast_count = 0
    error_episode_count = 0
    success_episode_count = 0
    errored_podcast_ids = []
    errored_episode_ids = []
    success_episode_ids = []

    print('Fetching public rss podcasts......')
    podcasts = get_public_rss_podcasts()

    for podcast in podcasts:
        try:
            podcast_id = podcast['id']
            print(f'\nRunning for podcast_id: {podcast_id}')
            episodes = get_episodes_with_apple_link_by_podcast_id(podcast_id)
            for episode in episodes:
                try:
                    episode_id = episode['episode_id']
                    print(f'\nRunning for episode_id: {episode_id}')
                    apple_episode_id = episode['apple_episode_link'].split('?i=')[1]
                    update_episode(episode_id, {'apple_id': apple_episode_id})
                    print(f'Updated episode with apple_episode_id: {apple_episode_id}')
                    success_episode_ids.append(episode_id)
                except Exception as e:
                    errored_episode_ids.append(episode_id)
                    error_episode_count += 1
                    log.info(
                        f'\nGot an exception for episode_id: {episode_id}\n'
                        f'Exception trace: {e}\n'
                    )
            print(f'\nDone for podcast: {podcast_id}\n')
        except Exception as e:
            errored_podcast_ids.append(podcast_id)
            error_podcast_count += 1
            log.info(
                f'\nGot an exception for podcast: {podcast_id}\n'
                f'Exception trace: {e}\n'
            )

    print(f'\nSuccess episode count: {success_episode_count} and success_episode_ids: {success_episode_ids} \n')
    print(f'\nErrored podcast count: {error_podcast_count} and errored_podcast_ids: {errored_podcast_ids} \n')
    print(f'\nErrored episdoe count: {error_episode_count} and errored_podcast_ids: {errored_episode_ids} \n')


def main():
    """Extract shell arguments, backfill apple id for episodes under public rss feeds."""
    global request_headers
    argparser = argparse.ArgumentParser(prog='Backfill apple id for episodes under public rss feeds')
    argparser.add_argument('-env', required=True, help='env', default='qa')

    args = argparser.parse_args()
    env = args.env
    user_id = users[env]

    def get_user_id():
        """Mock get user id return value."""
        return user_id

    api_utils.get_user_id = get_user_id

    request_headers = {
        'Grass-Account-Type': 'vendor',
        'Grass-Account-Id': '1',
        'Correlation-Id': '12',
        'Orchard-Identity-UUID': 'podcast-admin',
        'Content-Type': 'application/json'
    }

    log.info(f'Running backfill_apple_id_for_episodes_under_public_rss_feeds for {env} environment.\n')

    backfill_apple_id_for_episodes_under_public_rss_feeds()


if __name__ == '__main__':
    main()