"""Read ddex file from s3."""
import os
import time

import botocore
from ddex_ingester_common.constants.xmltodict import DDEX_LIST_FIELDS
from ddex_ingester_common.helpers.xml_document_helper import (
    get_conditional_text_value,
    get_root_element,
)
from ddex_ingester_common.lambda_exceptions import ParseDDEXException
from ddex_ingester_common.schemas.ddex_schema import DDEXSchema
from ddex_ingester_common.schemas.purged_ddex_schema import PurgedDDEXSchema
from marshmallow.utils import get_value
import xmltodict

READ_EXTENDED_METADATA_TIME_SLEEP_SECONDS = 10
READ_EXTENDED_METADATA_RETRY_COUNT = 3


def read_ddex(s3_client, bucket, key, logger):
    """Read and parse ddex file form s3."""
    xml_data = s3_client.get_object(Bucket=bucket, Key=key).get('Body').read()

    doc = xmltodict.parse(xml_data, force_list=DDEX_LIST_FIELDS)

    prefix = 'ernm:' if '<ernm:' in xml_data.decode('utf-8') else 'ern:'

    release_header = get_value(doc, prefix + 'NewReleaseMessage') or {}

    deal_list = get_value(release_header, 'DealList') or {}

    is_purged_release = get_is_purged_release(
        xml_data.decode('utf-8'),
        deal_list,
        logger
    )

    if is_purged_release:
        data = PurgedDDEXSchema().load(doc)
    else:
        # Only extract extended metadata if not a purged release message
        extended_metadata_key = extract_extended_metadata_location(
            key,
            doc,
            logger
        )

        if extended_metadata_key:
            extended_doc = extract_extended_doc(
                logger,
                s3_client,
                bucket,
                extended_metadata_key
            )
            doc = combine_ddex_documents(doc, extended_doc)

        data = DDEXSchema().load(doc)

    data.is_purged_release = is_purged_release

    return data


def extract_extended_metadata_location(key, extended_xml, logger):
    """Extract extended metadata file location from ddex."""
    extracted_file = None
    base_location = key.rsplit('/', 1)[0]
    extended_xml = get_root_element(extended_xml)
    extended_metadata_text = get_extended_metadata_text(extended_xml)
    if extended_metadata_text:
        file_path = extended_metadata_text['TextDetailsByTerritory'][
            'TechnicalTextDetails']['File']['FilePath']
        file_name = extended_metadata_text['TextDetailsByTerritory'][
            'TechnicalTextDetails']['File']['FileName']
        extracted_file = base_location + '/' + file_path + file_name

    logger.info(f'Extended metadata file found: {extracted_file}')
    return extracted_file


def get_extended_metadata_text(extended_xml):
    """Get the extended metadata text element from the extended xml."""
    text_elements = extended_xml['ResourceList'].get('Text')
    for element in text_elements or []:
        text_type = get_conditional_text_value(element.get('TextType'))
        if text_type == 'OrchardExtendedMetadataMessage':
            return element

    return None


def combine_ddex_documents(doc, ext):
    """Combine extended metadata with DDEX document."""
    root = get_root_element(doc)

    main_product = DDEXSchema().get_main_product(release_list=get_value(
        root,
        'ReleaseList.Release',
        []
    ))

    artist_name = main_product['ReleaseDetailsByTerritory'][0][
        'DisplayArtistName']
    upc = main_product['ReleaseId']['ICPN']
    title = main_product['ReferenceTitle']['TitleText']

    if 'Project' in ext['OrchardMessage']:
        root['Project'] = ext['OrchardMessage']['Project']

        if 'Artist' not in root['Project'] or not root['Project']['Artist']:
            root['Project']['Artist'] = {'Name': artist_name}

        if 'Name' not in root['Project'] or not root['Project']['Name']:
            root['Project']['Name'] = title

        if 'Id' not in root['Project'] or not root['Project']['Id']:
            root['Project']['upc'] = upc

    else:
        root['Project'] = {'Id': upc, 'Name': title,
                           'Artist': {'Name': artist_name}}

    """
        We want to retain Tracks as a top level object in the DDEX,
        so remove it from the Product dict after using it to avoid duplication.
    """
    root['Tracks'] = ext['OrchardMessage']['Product']['Tracks']
    del ext['OrchardMessage']['Product']['Tracks']

    root['Product'] = ext['OrchardMessage']['Product']

    if ext['OrchardMessage'].get('OrchardLabelId'):
        root['Product']['VendorId'] = ext['OrchardMessage']['OrchardLabelId']

    if ext['OrchardMessage'].get('OrchardSubaccountId'):
        root['Product']['SubaccountId'] = ext['OrchardMessage'][
            'OrchardSubaccountId']

    if ext['OrchardMessage']['Product'].get('IsConfidential'):
        root['Product']['IsConfidential'] = ext['OrchardMessage'][
            'Product'].get('IsConfidential')

    return doc


def get_is_purged_release(xml_data, deal_list, logger):
    """Check if the XML is a normal ingest or a purged release."""
    # For AWAL, we check for existence of TakeDown being true.
    if deal_list:
        # TakeDowns will only have one deal.
        release_deal = (
            deal_list['ReleaseDeal'][0]
            if deal_list.get('ReleaseDeal') else {})
        deal = (
            release_deal['Deal'][0]
            if release_deal.get('Deal') else {})

        if deal.get('DealTerms', {}).get('TakeDown') == 'true':
            logger.info('Product has TakeDown flag set to True.')
            return True

    # SME and anyone that uses strict adherence to DDEX standards.
    return '<ernm:PurgeReleaseMessage' in xml_data


def extract_extended_doc(
        logger,
        s3_client,
        bucket,
        extended_metadata_key
):
    """Find and retrieve extended xml data from source XML file."""
    check_key_extension(extended_metadata_key, logger)

    for i in range(READ_EXTENDED_METADATA_RETRY_COUNT):
        try:
            extended_xml_data = s3_client.get_object(
                Bucket=bucket, Key=extended_metadata_key
            ).get('Body').read()
            break
        except botocore.exceptions.ClientError as error:
            sleep_time = (i + 1) * READ_EXTENDED_METADATA_TIME_SLEEP_SECONDS
            if error.response['Error']['Code'] == 'NoSuchKey':
                logger.warning(f'Extended doc key {extended_metadata_key} '
                               f'is not yet available. '
                               f'Wait {sleep_time}'
                               f' seconds')

                time.sleep(sleep_time)
            else:
                raise error

            if i == READ_EXTENDED_METADATA_RETRY_COUNT - 1:
                raise error

    extended_xml_data = _remove_invalid_tokens(extended_xml_data)
    extended_doc = xmltodict.parse(
        extended_xml_data,
        force_list=DDEX_LIST_FIELDS
    )
    if not extended_doc:
        raise Exception('Extended metadata file is empty')

    return extended_doc


def check_key_extension(key, logger):
    """Check file extension is valid xml."""
    _, extension = os.path.splitext(key)

    if extension != '.xml':
        msg = 'S3 event source is not an XML file'
        logger.warning(msg)
        raise ParseDDEXException(msg)


def _remove_invalid_tokens(xml_data):
    return xml_data.decode('utf-8') \
        .replace('\v', '') \
        .replace('\x02', '') \
        .replace('', '')