"""Track Pricing Override Territory.

This model represents a Track Pricing Override Territory
"""

import datetime

from oto import response

from pricing.connectors import mysql

import sqlalchemy


class TrackPricingOverrideTerritory(mysql.BaseModel):
    """Track Pricing Override Territory model."""

    __tablename__ = 'track_pricing_override_territory'

    track_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(
            track_pricing_override_id=self.track_pricing_override_id,
            territory_code=self.territory_code)


@mysql.autosession()
def get_by_track_pricing_override_id(track_pricing_override_id, session):
    """Return the track pricing override territories for an override ID.

    Args:
        track_pricing_override_id (int): the ID of the product override.
        session (Session): the mysql session.
    Returns:
        response.Response: containing a list of track override territory dicts.
    """
    track_pricing_override_territories = _get_by_track_pricing_override_id(
        track_pricing_override_id, session
    )

    return response.Response(
        {
            'items': track_pricing_override_territories
        })


def _get_by_track_pricing_override_id(track_pricing_override_id, session):
    """Get the track pricing override territories for an override ID.

    Args:
        track_pricing_override_id (int): the ID of the parent override.
        session (Session): the mysql session.
    Returns:
        [dict]: a list of track pricing override territory dicts.
    """
    rows = session.query(TrackPricingOverrideTerritory).filter_by(
        track_pricing_override_id=track_pricing_override_id)

    return [row.to_dict() for row in rows]


@mysql.autosession()
def create(track_pricing_override_id, territory_code, session):
    """Create a new track pricing override territory and commit.

    Args:
        track_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 track pricing override
        territory dict.
    """
    result = _create(track_pricing_override_id, territory_code, session)

    session.commit()

    return result


def _create(track_pricing_override_id, territory_code, session):
    """Create a new track pricing override territory without commit.

    Args:
        track_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 track pricing override
        territory dict.
    """
    data = {
        'track_pricing_override_id': track_pricing_override_id,
        'territory_code': territory_code,
        'created_date': datetime.datetime.now()
    }

    created = TrackPricingOverrideTerritory(**data)

    session.add(created)

    return response.Response(created.to_dict())


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

    Args:
        track_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
        track pricing override territories.
    """
    existing_territories = _get_by_track_pricing_override_id(
        track_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(
            track_pricing_override_id, territory_code, session)

        created.append(create_result.message)

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

        deleted.append(delete_result.message)

    session.commit()

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


@mysql.autosession()
def delete(track_pricing_override_id, territory_code, session):
    """Delete a track pricing override territory and commit.

    Args:
        track_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 track pricing override code
        territory dict.
    """
    result = _delete(track_pricing_override_id, territory_code, session)

    session.commit()

    return result


def _delete(track_pricing_override_id, territory_code, session):
    """Delete a track pricing override territory without commit.

    Args:
        track_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 track pricing override code
        territory dict.
    """
    instance = session.query(TrackPricingOverrideTerritory).filter_by(
        track_pricing_override_id=track_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_track_pricing_override_id(track_pricing_override_id, session):
    """Delete the track pricing override territories for an override ID.

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

    Returns:
        response.Response: containing the number of deleted instances
    """
    instances = session.query(TrackPricingOverrideTerritory)\
        .filter_by(track_pricing_override_id=track_pricing_override_id)

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

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