"""Common lambda asset helper functions."""
import mimetypes

from boto3 import client

from common.constants.asset import MIMETYPES
from common.graphql.asset_queries import create_asset_upload_token
from common.graphql.asset_queries import get_asset_status_v2_query
from common.graphql.asset_queries import get_product_track_assets_query
from common.graphql.asset_queries import save_asset_info
from common.graphql.asset_queries import valid_artwork_query

from marshmallow.utils import get_value


def _setup_mimetypes():
    """Pre-initialize global mimetype map."""
    if not mimetypes.inited:
        mimetypes.init()
    for key, value in MIMETYPES.items():
        mimetypes.types_map[key] = value


_setup_mimetypes()


def create_asset_token(graphql_connector: object, asset_type: str) -> dict:
    """Create asset token from ows-assets.

    Args:
        graphql_connector (object): Graphql Connector object instance
        asset_type (str): Type of asset
    Returns:
        dict
    """
    response = graphql_connector.execute(
        create_asset_upload_token, {'assetType': asset_type}
    )

    return get_value(
        response,
        'data.createAssetUploadToken',
        None
    )


def save_asset_metadata(graphql_connector: object, metadata: dict):
    """Save ows-asset metadata.

    Args:
        graphql_connector (object): Graphql Connector object instance
        metadata (dict): ows-assets required s3 metadata

    Returns:
        dict
    """
    response = graphql_connector.execute(
        save_asset_info,
        metadata
    )

    return get_value(
        response,
        'data.saveAssetInfo',
        None
    )


def get_asset_status_v2(graphql_connector: object, filename: str):
    """Get V2 asset status by filename.

    Args:
        graphql_connector (object): Graphql Connector object instance
        file (str): ows-assets filename

    Returns:
        dict
    """
    response = graphql_connector.execute(
        get_asset_status_v2_query,
        {'filename': filename}
    )

    return get_value(
        response,
        'data.assetStatus.status',
        None
    )


def get_product_track_assets(graphql_connector: object, product_id: str,
                             use_v2: bool):
    """Get track assets by product id.

    Args:
        graphql_connector (object): Graphql Connector object instance
        product_id (str): Product ID
        use_v2 (Bool): Whether to use v2 assets

    Returns:
        list
    """
    response = graphql_connector.execute(
        get_product_track_assets_query,
        {'productId': product_id, 'useV2': use_v2}
    )

    return get_value(
        response,
        'data.productTrackAssets.assets',
        []
    )


def valid_artwork(graphql_connector: object, product_id: str,
                  require_v1: bool):
    """Check if artwork on Product is valid.

    Args:
        graphql_connector (object): Graphql Connector object instance
        product_id (str): Product ID
        require_v1 (bool): Checks if the V1 pipeline Artwork is valid as well

    Returns:
        boolean
    """
    response = graphql_connector.execute(
        valid_artwork_query,
        {'productId': product_id,
         'requireV1': require_v1}
    )

    return get_value(
        response,
        'data.product.isArtworkValid',
        False
    )


def copy_asset(metadata: dict, asset: object, bucket: str, filename: str):
    """Copy asset to a target bucket and filename.

    Args:
        metadata (dict): ows-assets required s3 metadata
        asset (object): Asset model object
        bucket (str): Bucket name ows-assets provided
        filename (str): Filename that ows-assets provided
    """
    s3 = client('s3')

    s3.copy_object(
        Key=filename,
        Bucket=bucket,
        CopySource={'Bucket': asset.bucket, 'Key': asset.key},
        Metadata=metadata,
        MetadataDirective='REPLACE',
        ContentType=mimetypes.guess_type(filename)[0]
    )