"""Soft delete draft episodes from db and megaphone.

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

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

from podcast import config
from podcast.connectors import mysql
from podcast.constants import error
from podcast.logic import episode as episode_logic
from podcast.models import episode as episode_model
from podcast.utils import api_utils
from podcast.utils.exc import OwsError


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 delete_episode_from_db_and_megaphone(podcast_id, episode_id):
    """Delete draft episode by it's podcast_id and episode_id.

    Args:
        podcast_id (int): The unique identifier of podcast
        episode_id (int): The unique identifier of episode
    """
    with mysql.pod_db_session() as session:
        episode = session.query(
            episode_model.Episode).filter(
            episode_model.Episode.id == episode_id,
            episode_model.Episode.podcast_id == podcast_id
        ).first()

        if not episode:
            raise OwsError.not_found(error.ERROR_EPISODE_NOT_FOUND)
        if episode.is_deleted:
            raise OwsError.not_found(error.ERROR_MESSAGE_EPISODE_IS_DELETED)
        if not episode.draft:
            raise OwsError.not_found(error.ERROR_MESSAGE_EPISODE_IS_NOT_DRAFT)

        episode.updated_by = api_utils.get_user_id()
        episode.is_deleted = True

        episode_megaphone_id = episode.megaphone_id
        if episode_megaphone_id:
            episode_logic.delete_episode_from_megaphone(podcast_id, episode.megaphone_id)
        return episode.to_dict()


def delete_draft_episodes(filename):
    """Soft delete draft episodes in podcast db and megaphone."""
    if not filename:
        raise Exception('File with name: deleteDraftEpisodes.csv not found.')
    log.info(f'Reading file: {filename}.\n')

    with open(filename) as csv_file:
        ep_count = 0
        error_count = 0
        deleted_count = 0
        deleted_episode_ids = []
        errored_episode_ids = []

        reader = csv.DictReader(csv_file)
        for row in reader:
            try:
                podcast_id = int(row['Podcast ID'])
                episode_id = int(row['Episode Episode ID'])
                print(f'\nRunning for episode with id: {episode_id}')
                if row['Delete'] == 'X':
                    delete_episode_from_db_and_megaphone(
                        podcast_id, episode_id)
                    deleted_count += 1
                    deleted_episode_ids.append(episode_id)
                    print(f'Soft deleted episode with id: {episode_id}')
                else:
                    print(f'Skipping deletion for episode with id: {episode_id}')

            except Exception as e:
                errored_episode_ids.append(episode_id)
                error_count += 1
                log.info(
                    f'Got an exception for megaphone_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'\nDeleted count: {deleted_count} and episodes_ids: {deleted_episode_ids}')
    print(f'\nErrored errored count: {error_count} and episodes_ids: {errored_episode_ids} \n')


def main():
    """Extract shell arguments and start soft deleting draft episodes."""
    global request_headers
    argparser = argparse.ArgumentParser(prog='Soft Delete Episodes')
    argparser.add_argument('-env', required=True, help='env', default='qa')
    argparser.add_argument('-api_key', required=True, help='Megaphone API Key')

    args = argparser.parse_args()
    config.MEGAPHONE_API_TOKEN = args.api_key
    env = args.env
    filename = os.environ.get('FILENAME')

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

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

    api_utils.get_user_id = get_user_id

    log.info(f'Running delete draft episodes script for {env} Environment.\n')

    delete_draft_episodes(filename)


if __name__ == '__main__':
    main()