"""Store Pricing Scheme.

This model represents a Store Pricing Scheme, e.g. 'iTunes Film'
"""

import datetime

from oto import response

from pricing.connectors import mysql
from pricing.constants import error
from pricing.models.store_pricing_tier import StorePricingTier
from pricing.models.store_pricing_tier_code import StorePricingTierCode
from pricing.models.store_pricing_tier_code_territory \
    import StorePricingTierCodeTerritory

import sqlalchemy


class StorePricingScheme(mysql.BaseModel):
    """Store Pricing Scheme model."""

    __tablename__ = 'store_pricing_scheme'

    store_pricing_scheme_id = sqlalchemy.Column(
        sqlalchemy.BIGINT,
        primary_key=True)
    name = sqlalchemy.Column(sqlalchemy.VARCHAR(45))
    store_id = sqlalchemy.Column(sqlalchemy.Integer)
    pricing_family_id = sqlalchemy.Column(sqlalchemy.BIGINT)
    use_interval_pricing = sqlalchemy.Column(sqlalchemy.Boolean, default=False)
    created_date = sqlalchemy.Column(sqlalchemy.DateTime)
    created_by = sqlalchemy.Column(sqlalchemy.VARCHAR(45))
    updated_date = sqlalchemy.Column(sqlalchemy.DateTime)
    updated_by = sqlalchemy.Column(sqlalchemy.VARCHAR(45))

    def to_dict(self):
        """Convert Store Pricing Scheme to dict."""
        return dict(
            store_pricing_scheme_id=self.store_pricing_scheme_id,
            name=self.name,
            store_id=self.store_id,
            pricing_family_id=self.pricing_family_id,
            use_interval_pricing=self.use_interval_pricing)


@mysql.autosession()
def create_store_pricing_scheme(data, session):
    """Create a new store pricing scheme.

    Args:
        data (dict): the data from which to create the store pricing scheme.
        session (Session): the mysql session.

    Returns:
        response.Response: containing the created store pricing scheme dict.
    """
    if not data:
        return response.create_error_response(
            400, error.ERROR_MESSAGE_EMPTY_BODY)

    data['created_date'] = datetime.datetime.now()

    store_pricing_scheme = StorePricingScheme(**data)
    session.add(store_pricing_scheme)
    session.commit()

    return response.Response(store_pricing_scheme.to_dict())


@mysql.autosession()
def update_store_pricing_scheme_by_id(store_pricing_scheme_id, data, session):
    """Update a new store pricing scheme by its ID.

    Args:
        store_pricing_scheme_id (int): the ID of the store pricing scheme.
        data (dict): the data from which to update the store pricing scheme.
        session (Session): the mysql session.

    Returns:
        response.Response: containing the updated store pricing scheme dict.
    """
    if not data:
        return response.create_error_response(
            400, error.ERROR_MESSAGE_EMPTY_BODY)

    data['updated_date'] = datetime.datetime.now()

    found_store_pricing_scheme = session.query(
        StorePricingScheme).get(store_pricing_scheme_id)

    if not found_store_pricing_scheme:
        return response.create_not_found_response()

    for key, value in data.items():
        setattr(found_store_pricing_scheme, key, value)

    session.commit()

    return response.Response(found_store_pricing_scheme.to_dict())


def _get_store_pricing_scheme_by_id(store_pricing_scheme_id, session):
    """Get a store pricing scheme by its ID.

    Args:
        store_pricing_scheme_id (int): the ID of the store pricing scheme.
        session (Session): the mysql session.

    Returns:
        StorePricingScheme: the found store pricing scheme.
    """
    found_store_pricing_scheme = session.query(StorePricingScheme).filter(
        StorePricingScheme.store_pricing_scheme_id == store_pricing_scheme_id
    ).one_or_none()
    return found_store_pricing_scheme


@mysql.autosession()
def get_by_pricing_family_and_store_id(
        pricing_family_id, store_id, session):
    """Get a store pricing scheme and all its tiers by family and store ID.

    Args:
        pricing_family_id (int): the ID of the pricing family.
        store_id (int): the ID of the store.
        session (Session): the mysql session.

    Returns:
        response.Response: containing the store pricing scheme dict.
    """
    instance = session.query(StorePricingScheme).filter_by(
        pricing_family_id=pricing_family_id,
        store_id=store_id).one_or_none()

    if not instance:
        return response.create_not_found_response()

    return get_store_pricing_scheme_by_id(instance.store_pricing_scheme_id)


def _get_store_pricing_tier_code_territories(store_pricing_scheme_id, session):
    """Get store pricing tier code territories by scheme ID.

    Args:
        store_pricing_scheme_id (int): the ID of the store pricing scheme.
        session (Session): the mysql session.

    Returns:
        array: containing store pricing tier code territories dict entries.
    """
    rows = (
        session.query(StorePricingTierCodeTerritory)
        .join(
            StorePricingTierCode,
            StorePricingTierCode.store_pricing_tier_code_id
            == StorePricingTierCodeTerritory.store_pricing_tier_code_id
        )
        .join(
            StorePricingTier,
            StorePricingTier.store_pricing_tier_id
            == StorePricingTierCode.store_pricing_tier_id
        )
        .join(
            StorePricingScheme,
            StorePricingScheme.store_pricing_scheme_id
            == StorePricingTier.store_pricing_scheme_id
        )
        .where(StorePricingScheme.store_pricing_scheme_id == store_pricing_scheme_id)
    ).all()
    return [row.to_dict() for row in rows]


def _get_store_pricing_tier_codes_by_scheme_id(store_pricing_scheme_id, session):
    """Get store pricing tier codes by scheme ID.

    Args:
        store_pricing_scheme_id (int): the ID of the store pricing scheme.
        session (Session): the mysql session.

    Returns:
        array: containing store pricing tier codes dict entries.
    """
    store_pricing_tier_codes_query = (
        session.query(StorePricingTierCode)
        .join(
            StorePricingTier,
            StorePricingTier.store_pricing_tier_id == StorePricingTierCode.store_pricing_tier_id
        )
        .join(
            StorePricingScheme,
            StorePricingScheme.store_pricing_scheme_id == StorePricingTier.store_pricing_scheme_id
        )
        .where(StorePricingScheme.store_pricing_scheme_id == store_pricing_scheme_id)
    ).all()
    return [entry.to_dict() for entry in store_pricing_tier_codes_query]


def _get_store_pricing_tier_by_scheme_id(store_pricing_scheme_id, session):
    """Get store pricing tier by scheme ID.

    Args:
        store_pricing_scheme_id (int): the ID of the store pricing scheme.
        session (Session): the mysql session.

    Returns:
        array: containing store pricing tier dict entries.
    """
    tier_query = (
        session.query(StorePricingTier)
        .join(
            StorePricingScheme,
            StorePricingScheme.store_pricing_scheme_id == StorePricingTier.store_pricing_scheme_id
        )
        .where(StorePricingScheme.store_pricing_scheme_id == store_pricing_scheme_id)
    ).all()
    return [entry.to_dict() for entry in tier_query]


@mysql.autosession()
def get_store_pricing_scheme_by_id(store_pricing_scheme_id, session):
    """Get a store pricing scheme and all its tiers by its ID.

    Args:
        store_pricing_scheme_id (int): the ID of the store pricing scheme.
        session (Session): the mysql session.

    Returns:
        response.Response: containing the store pricing scheme dict.
    """
    found_store_pricing_scheme = _get_store_pricing_scheme_by_id(
        store_pricing_scheme_id, session)

    if not found_store_pricing_scheme:
        return response.create_not_found_response()

    result = found_store_pricing_scheme.to_dict()

    tier_rows = _get_store_pricing_tier_by_scheme_id(store_pricing_scheme_id, session)

    result['store_pricing_tiers'] = list(map(
        map_store_pricing_tier_row, tier_rows))

    tier_code_rows = _get_store_pricing_tier_codes_by_scheme_id(
        store_pricing_scheme_id, session)

    for tier_code_row in tier_code_rows:
        store_pricing_tier_code = map_store_pricing_tier_code_row(
            tier_code_row)
        for store_pricing_tier in result['store_pricing_tiers']:
            if store_pricing_tier['store_pricing_tier_id'] == \
                    store_pricing_tier_code[
                        'store_pricing_tier_id']:
                store_pricing_tier['store_pricing_tier_codes'].append(
                    store_pricing_tier_code)

    tier_code_territory_rows = _get_store_pricing_tier_code_territories(
        store_pricing_scheme_id, session)

    for tier_code_territory_row in tier_code_territory_rows:
        for store_pricing_tier in result['store_pricing_tiers']:
            for store_pricing_tier_code in \
                    store_pricing_tier['store_pricing_tier_codes']:
                if store_pricing_tier_code['store_pricing_tier_code_id'] == \
                        tier_code_territory_row[
                            'store_pricing_tier_code_id']:
                    store_pricing_tier_code['territory_set'].add(
                        tier_code_territory_row['territory_code'])
                    store_pricing_tier_code[
                        'store_pricing_tier_code_territories'].append(
                        tier_code_territory_row)

    return response.Response(result)


def map_store_pricing_tier_row(row):
    """Map a store pricing tier row to dict.

    Args:
        row (sqlalchemy.engine.ResultProxy): the row containing the tier.

    Returns:
        dict: containing the store pricing tier.
    """
    result = StorePricingTier(**row).to_dict()
    result['store_pricing_tier_codes'] = []
    return result


def map_store_pricing_tier_code_row(row):
    """Map a store pricing tier code row to dict.

    Args:
        row (sqlalchemy.engine.ResultProxy): the row containing the code.

    Returns:
        dict: containing the store pricing tier code.
    """
    result = StorePricingTierCode(**row).to_dict()
    result['store_pricing_tier_code_territories'] = []
    result['territory_set'] = set()
    return result


@mysql.autosession()
def get_by_store_id(store_id, session):
    """Get the list of store pricing schemes for a specific store.

    Args:
        store_id (int): the ID of the store.
        session (Session): the mysql session.

    Returns:
        response.Response: containing the list of store pricing schemes.
    """
    schemes = session.query(StorePricingScheme).filter_by(
        store_id=store_id).all()

    return response.Response({
        'items': [scheme.to_dict() for scheme in schemes]
    })


@mysql.autosession()
def get_by_pricing_family_id(pricing_family_id, session):
    """Get the list of store pricing schemes for a specific pricing family.

    Args:
        pricing_family_id (int): the ID of the pricing family.
        session (Session): the mysql session.

    Returns:
        response.Response: containing the list of store pricing schemes.
    """
    schemes = session.query(StorePricingScheme).filter_by(
        pricing_family_id=pricing_family_id).all()

    return response.Response({
        'items': [scheme.to_dict() for scheme in schemes]
    })