"""Backfill episode's season number and episode number and update description.

Run this in dev with command
docker compose run --build backfill-season-and-episode-number --env=dev --api_key=megaphone_token
    --is_update_description=True --description='description'
"""

import argparse
import csv
import logging
import os
import sys
import time

from flask import g

from podcast import config
from podcast.api import app
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 update_episode_details_in_megaphone(mp_podcast_id, episode_data, network_id):
    """Update season number, episode number and update episode description in megaphone.

    Args:
        mp_podcast_id (str): The podcast unique identifier in megaphone.
        episode_data (dict): The episode data from episode table/model.
        network_id (str): The network unique identifier.

    Returns:
        dict: the megaphone api response.

    """
    megaphone_data = {
        'summary': episode_data['description'],
        'episodeNumber': episode_data['episode_number'],
        'seasonNumber': episode_data['season_number'],
        'retainAdLocations': True
    }

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


def backfill_season_and_episode_number(filename, is_update_description, description):
    """Backfill episode's season number and episode number in ows-podcats db and megaphone.

    if is_update_description is True, append description string to the end of episode's description.

    Args:
        filename (str): The filename to access the csv file.
        is_update_description (boolean): if we need to update description or not.
        description (str): description string to append to the existing description.
    """
    if not filename:
        raise Exception('File with name: backfillSeasonAndEpisodeNumber.csv not found.')
    log.info(f'Reading file: {filename}.\n')

    with open(filename) as csv_file:
        ep_count = 0
        error_count = 0
        prev_mp_podcast_id = None
        errored_episodes = []
        podcast = {}

        reader = csv.DictReader(csv_file)
        for row in reader:
            try:
                episode_id = int(row['Episode ID'])
                print(f'Running for episode_id: {episode_id}')

                mp_podcast_id = row['Podcast Megaphone ID']
                if prev_mp_podcast_id != mp_podcast_id:
                    podcast = podcast_model.get_podcast_by_megaphone_id(
                        mp_podcast_id)
                    prev_mp_podcast_id = podcast['megaphone_id']

                season_number = int(row['Season Number'])
                episode_number = int(row['Episode Number'])
                data = {
                    'season_number': season_number,
                    'episode_number': episode_number
                }

                if is_update_description:
                    episode = episode_model.get_episode_by_id(episode_id)
                    episode_description = episode['description']
                    data['description'] = f'{episode_description}{description}'

                updated_episode = episode_model.update_episode(episode_id, data)
                print(f'Database updated episode with season_no {season_number} and episode_no {episode_number}')

                update_episode_details_in_megaphone(mp_podcast_id, updated_episode, podcast['network_id'])
                print(f'Megaphone updated episode with season_no {season_number} and episode_no {episode_number}')
            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 main():
    """Extract shell arguments and backfill episode season no, episode no, and description in DB and megaphone."""
    global request_headers
    argparser = argparse.ArgumentParser(prog='Backfill season number and episode number in DB and megaphone.')
    argparser.add_argument('--api_key', required=True, help='Megaphone API Key')
    argparser.add_argument('--env', required=True, help='env', default='qa')
    argparser.add_argument('--is_update_description', required=False, help='flag to update description', default=False)
    argparser.add_argument('--description', required=False, help='description to append', default='')

    args = argparser.parse_args()

    config.MEGAPHONE_API_TOKEN = args.api_key
    env = args.env
    description = args.description
    is_update_description = args.is_update_description
    filename = os.environ.get('FILENAME')

    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 season no. and episode no. backfill for {env} Environment.\n')

    with app.app_context():
        g.log = log
        backfill_season_and_episode_number(filename, is_update_description, description)


if __name__ == '__main__':
    main()