"""Logic module that works with import_asset models."""

from oto import response

from assets import config
from assets.constants import error
from assets.constants import asset_legacy
from assets.models import ows_product
from assets.models.legacy import import_asset
from assets.models.legacy import import_asset_batch
from assets.models.legacy import import_asset_detail


def get_status_by_filename(filename, account_type=None, account_id=None):
    """Get status by filename.

    Args:
        filename (str): Filename of asset, with extension.
        account_type (str): Grass account type.
        account_id (int): Grass account id.
    Returns:
        response.Response: Import Asset status or error in Response object.
    """
    if not filename:
        return response.create_error_response(
            code=error.ERROR_CODE_QUERY_VALIDATION,
            message='Invalid filename value.')
    import_asset_response = import_asset.get_import_asset_by_filename(filename)
    if not import_asset_response:
        return import_asset_response
    if account_id is not None and account_type is not None:
        import_asset_id = import_asset_response.message['id']
        ownership_response = _check_import_asset_ownership(
            import_asset_id, account_type, account_id)
        if not ownership_response:
            return ownership_response

    return response.Response({
        'status': import_asset_response.message['status'],
        'message': import_asset_response.message['result']})


def create_import_asset_items(
        full_user_id, filename, asset_type, upc, track_unique_id,
        import_type=asset_legacy.IMPORT_TYPE_UPLOAD,
        import_asset_batch_body=None):
    """Create all items for art_relations database.

    Args:
        full_user_id (str): Full user id
        filename (str): Asset filename
        asset_type (str): Asset type
        upc (int): UPC
        track_unique_id (int): Track unique id
        import_type (str): Batch import type (e.g. "upload", "copy", "replace")
        import_asset_batch_body (dict): Asset batch data.
    Returns:
        response.Response: Response object with success or error message
    """
    if import_asset_batch_body is None:
        asset_batch_response = create_import_asset_batch(
            full_user_id=full_user_id, import_type=import_type
        )
        if not asset_batch_response:
            return asset_batch_response

        import_asset_batch_body = asset_batch_response.message

    import_asset_batch_id = import_asset_batch_body['id']

    folder_name = config.RAW_ASSETS_BUCKET_NAME
    if import_type == asset_legacy.IMPORT_TYPE_COPY:
        folder_name = None

    asset_response = import_asset.create_import_asset(
        import_asset_batch_id, folder_name,
        filename, asset_type)

    if not asset_response:
        return asset_response

    import_asset_body = asset_response.message
    import_asset_id = import_asset_body['id']
    asset_detail_response = import_asset_detail.create_import_asset_detail(
        import_asset_id, upc, track_unique_id
    )

    if not asset_detail_response:
        return asset_detail_response

    return response.Response(message={'import_asset_id': import_asset_id})


def create_import_asset_batch(
        full_user_id, ip_address=0, import_type='upload'):
    """Create new import asset batch record.

    Args:
        full_user_id (str): Full user Id
        ip_address (int): Client IP Address
        import_type (str): asset batch import type

    Returns:
        response.Response: Inserted record info or error
    """
    if not full_user_id:
        return response.create_error_response(
            'no_user_id', 'No user id provided', 400)
    if full_user_id.startswith('alw:'):
        vendor_contact_id = int(full_user_id.replace('alw:', ''))
        impersonated = 0
    else:
        impersonated = int(full_user_id.replace('oa:', ''))
        vendor_contact_id = None

    create_batch_response = import_asset_batch.create_import_asset_batch(
        vendor_contact_id, impersonated, ip_address, import_type)
    return create_batch_response


def _check_import_asset_ownership(import_asset_id, account_type, account_id):
    """Check ownership by import asset id.

    Args:
        import_asset_id (int): Full user Id
        account_type (str): Client IP Address
        account_id (int): asset batch import type

    Returns:
        response.Response: Response with success or error message.
    """
    import_asset_detail_response = (
        import_asset_detail.get_by_import_asset_id(import_asset_id))
    if not import_asset_detail_response:
        return import_asset_detail_response

    upc = import_asset_detail_response.message['upc']

    get_product_response = ows_product.get_product_by_upc(upc)
    if not get_product_response:
        return get_product_response

    product_id = get_product_response.message['product_id']

    ownership_response = ows_product.check_ownership(
        account_type, account_id, product_id)
    if not ownership_response:
        return ownership_response

    return response.Response({'status': error.SUCCESS_CODE})