"""Product Pricing Override Territory.

This model represents a Product Pricing Override Territory
"""

import datetime

from oto import response

from pricing.connectors import mysql

import sqlalchemy


class ProductPricingOverrideTerritory(mysql.BaseModel):
    """Product Pricing Override Territory model."""

    __tablename__ = 'product_pricing_override_territory'

    product_pricing_override_id = sqlalchemy.Column(
        sqlalchemy.BIGINT,
        primary_key=True)
    territory_code = sqlalchemy.Column(
        sqlalchemy.VARCHAR(45),
        primary_key=True)
    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 a Product Pricing Override Territory to dict."""
        return dict(
            product_pricing_override_id=self.product_pricing_override_id,
            territory_code=self.territory_code)


@mysql.autosession()
def get_by_product_pricing_override_id(product_pricing_override_id, session):
    """Return the product pricing override territories for an override ID.

    Args:
        product_pricing_override_id (int): the ID of the product override.
        session (Session): the mysql session.

    Returns:
        response.Response: containing a list of override territory dicts.
    """
    product_pricing_override_territories = _get_by_product_pricing_override_id(
        product_pricing_override_id, session
    )
    return response.Response(
        {
            'items': product_pricing_override_territories
        })


def _get_by_product_pricing_override_id(product_pricing_override_id, session):
    """Get the product pricing override territories for an override ID.

    Args:
        product_pricing_override_id (int): the ID of the parent override.
        session (Session): the mysql session.

    Returns:
        [dict]: a list of product pricing override territory dicts.
    """
    rows = session.query(ProductPricingOverrideTerritory).where(
        ProductPricingOverrideTerritory
        .product_pricing_override_id == product_pricing_override_id
    ).all()
    return [row.to_dict() for row in rows]


@mysql.autosession()
def create(product_pricing_override_id, territory_code, session):
    """Create a new product pricing override territory.

    Args:
        product_pricing_override_id (int): the ID of the parent code.
        territory_code (string): the territory code.
        session (Session): the mysql session.

    Returns:
        response.Response: containing the created product pricing override
        territory dict.
    """
    result = _create(product_pricing_override_id, territory_code, session)

    session.commit()

    return result


def _create(product_pricing_override_id, territory_code, session):
    """Create a new product pricing override territory.

    Args:
        product_pricing_override_id (int): the ID of the parent override.
        territory_code (string): the territory code.
        session (Session): the mysql session.

    Returns:
        response.Response: containing the created product pricing override
        territory dict.
    """
    data = {
        'product_pricing_override_id': product_pricing_override_id,
        'territory_code': territory_code,
        'created_date': datetime.datetime.now()
    }

    created = ProductPricingOverrideTerritory(**data)

    session.add(created)

    return response.Response(created.to_dict())


@mysql.autosession()
def update_territories(product_pricing_override_id, territory_codes, session):
    """Create or delete product pricing override territories.

    Args:
        product_pricing_override_id (int): the ID of the parent code.
        territory_codes ([string]): a list of territory codes.
        session (Session): the mysql session.

    Returns:
        response.Response: containing the list of created and deleted
        product pricing override territories.
    """
    existing_territories = _get_by_product_pricing_override_id(
        product_pricing_override_id, session)

    existing_territory_codes = [item['territory_code'] for item in
                                existing_territories]

    create_new_territory_codes = list(set(
        territory_codes) - set(existing_territory_codes))
    delete_old_territory_codes = list(set(
        existing_territory_codes) - set(territory_codes))

    created = []
    deleted = []

    for territory_code in create_new_territory_codes:
        create_result = _create(
            product_pricing_override_id, territory_code, session)

        created.append(create_result.message)

    for territory_code in delete_old_territory_codes:
        delete_result = _delete(
            product_pricing_override_id, territory_code, session)

        deleted.append(delete_result.message)

    session.commit()

    return response.Response({
        'created': created,
        'deleted': deleted})


@mysql.autosession()
def delete(product_pricing_override_id, territory_code, session):
    """Delete a store pricing tier code territory.

    Args:
        product_pricing_override_id (int): the ID of the parent code.
        territory_code (string): the territory code.
        session (Session): the mysql session.

    Returns:
        response.Response: containing the deleted store pricing tier code
        territory dict.
    """
    result = _delete(product_pricing_override_id, territory_code, session)

    session.commit()

    return result


def _delete(product_pricing_override_id, territory_code, session):
    """Delete a product pricing override territory.

    Args:
        product_pricing_override_id (int): the ID of the parent override.
        territory_code (string): the territory code.
        session (Session): the mysql session.

    Returns:
        response.Response: containing the deleted store pricing tier code
        territory dict.
    """
    instance = session.query(ProductPricingOverrideTerritory).filter_by(
        product_pricing_override_id=product_pricing_override_id,
        territory_code=territory_code).one_or_none()

    if not instance:
        return response.create_not_found_response()

    session.delete(instance)

    return response.Response(instance.to_dict())


@mysql.autosession()
def delete_by_product_pricing_override_id(
        product_pricing_override_id, session):
    """Delete the product pricing override territories for an override ID.

    Args:
        product_pricing_override_id (int): the ID of the parent override.
        session (Session): the mysql session.

    Returns:
        [dict]: a list of deleted instances.
    """
    instances = session.query(ProductPricingOverrideTerritory)\
        .filter_by(product_pricing_override_id=product_pricing_override_id)

    result = []
    for instance in instances:
        result.append(instance)
        session.delete(instance)

    return response.Response(
        {
            'deleted': len(result)
        })