"""Update episode description.

run this in dev with command
docker compose run --build update-episode-description.py --env=dev --api_key=megaphone_token
--podcast_id=299 --bad_string='abc'
"""

import argparse
import logging
import sys
import time

from flask import g

from podcast import config
from podcast.api import app
from podcast.connectors import mysql
from podcast.logic import megaphone as megaphone_logic
from podcast.models import episode as episode_model
from podcast.models import podcast as podcast_model
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


def get_podcast_episodes(podcast_id, is_draft, bad_string):
    """Return draft episodes by podcast id.

    Filter data on podcast_id and given string in description

    Args:
        podcast_id (int): the podcast identifier
    Returns:
        list: containing the dict of episodes.
    """
    with mysql.pod_db_session(read_only=True) as session:
        episodes = session.query(episode_model.Episode).filter(
            episode_model.Episode.podcast_id == podcast_id,
            episode_model.Episode.draft == is_draft,
            episode_model.Episode.description.contains(bad_string),
            episode_model.Episode.is_deleted.isnot(True)
        ).all()
        return [episode.to_dict() for episode in episodes]


def update_megaphone(podcast, updated_episode):
    """Remove bad string from episode description in megaphone.

    Args:
        podcast (dict): The podcast .
        episode_data (dict): The episode data from episode table/model.

    Returns:
        dict: the megaphone api response.

    """
    megaphone_data = {
        'summary': updated_episode['description'],
        'retainAdLocations': True
    }

    megaphone_response = megaphone_logic.call_episode_api(
        megaphone_data,
        podcast['megaphone_id'],
        updated_episode['megaphone_id'],
        podcast['network_id'],
        updated_episode['id']
    )
    return megaphone_response


def update_db_and_megaphone(episodes, podcast, bad_string, is_update_in_megaphone):
    """Update ows_podcast DB and megaphone API.

    Args:
        episodes (list): list of episodes and podcast
    """
    ep_count = 0
    error_count = 0
    errored_episodes = []
    for episode in episodes:
        try:
            episode_id = episode['id']
            updated_description = {
                'description': episode['description'].replace(bad_string, '')
            }
            updated_episode = episode_model.update_episode(episode_id, updated_description)

            if is_update_in_megaphone:
                update_megaphone(podcast, updated_episode)
        except Exception as e:
            errored_episodes.append(episode_id)
            error_count += 1
            log.info(
                f'Got an exception for episode_id: {episode_id}\n'
                f'Exception trace: {e}\n'
            )

        ep_count += 1
        if ep_count % 10 == 0:
            print(f'\n sleep time 10 secs and episode count: {ep_count}\n')
            time.sleep(10)

    print(f'\nErrored errored  count: {error_count} and episode_ids: {errored_episodes} \n')


def update_description(podcast_id, bad_string, is_update_in_megaphone):
    """Update episodes description for a podcast.

    Given a podcast id
    Fetch episodes
        Iterate over episodes and split description in a list
            Given a string , find index of string in list and pop it.
                Join the list into a string.
                    Update description in ows_podcast DB & Megaphone
    """
    try:
        podcast = podcast_model.get_podcast_by_id(podcast_id)

        log.info('Processing draft episodes for update')
        pod_draft_episodes = get_podcast_episodes(podcast_id, True, bad_string)
        update_db_and_megaphone(pod_draft_episodes, podcast, bad_string, is_update_in_megaphone)

        log.info('Processing published episodes for update')
        pod_published_episodes = get_podcast_episodes(podcast_id, False, bad_string)
        update_db_and_megaphone(pod_published_episodes, podcast, bad_string, is_update_in_megaphone)
    except Exception as error:
        error_message = 'Failed for podcast: {} with error: {}\n'.format(podcast_id, error)
        print(error_message)


def main():
    """Extract shell arguments and start updating episode description for a podcast in DB and megaphone."""
    global request_headers
    argparser = argparse.ArgumentParser(prog='Update episode description')
    argparser.add_argument('--api_key', required=True, help='Megaphone API Key')
    argparser.add_argument('--env', required=True, help='env', default='qa')
    argparser.add_argument('--podcast_id', required=True, help='podcast id')
    argparser.add_argument('--bad_string', required=True, help='bad string to be removed')
    argparser.add_argument('--is_update_in_megaphone', required=False, help='update in megaphone or not', default=False)

    args = argparser.parse_args()
    config.MEGAPHONE_API_TOKEN = args.api_key
    env = args.env
    podcast_id = args.podcast_id
    bad_string = args.bad_string
    is_update_in_megaphone = args.is_update_in_megaphone

    def get_user_id():
        """Mock get user id return value."""
        return users[env]

    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 update description for podcast_id:{podcast_id} in  {env} Environment.\n')

    with app.app_context():
        g.log = log
        update_description(podcast_id, bad_string, is_update_in_megaphone)


if __name__ == '__main__':
    main()