"""Track Pricing Override Store.

This model represents a Track Pricing Override Store
"""

import datetime

from oto import response

from pricing.connectors import mysql

import sqlalchemy


class TrackPricingOverrideStore(mysql.BaseModel):
    """Track Pricing Override Store model."""

    __tablename__ = 'track_pricing_override_store'

    track_pricing_override_id = sqlalchemy.Column(
        sqlalchemy.BIGINT,
        primary_key=True)
    store_id = sqlalchemy.Column(
        sqlalchemy.BIGINT,
        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 Track Pricing Override Store to dict."""
        return dict(
            track_pricing_override_id=self.track_pricing_override_id,
            store_id=self.store_id)


@mysql.autosession()
def get_by_track_pricing_override_id(track_pricing_override_id, session):
    """Return the track pricing override stores 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 store dicts.
    """
    track_pricing_override_stores = _get_by_track_pricing_override_id(
        track_pricing_override_id, session
    )

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


def _get_by_track_pricing_override_id(track_pricing_override_id, session):
    """Get the track pricing override stores 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 store dicts.
    """
    rows = session.query(TrackPricingOverrideStore).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, store_id, session):
    """Create a new track pricing override store and commit.

    Args:
        track_pricing_override_id (int): the ID of the parent override.
        store_id (string): the store ID.
        session (Session): the mysql session.
    Returns:
        response.Response: containing the created track pricing override
        store dict.
    """
    result = _create(track_pricing_override_id, store_id, session)

    session.commit()

    return result


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

    Args:
        track_pricing_override_id (int): the ID of the parent override.
        store_id (string): the store ID.
        session (Session): the mysql session.
    Returns:
        response.Response: containing the created track pricing override
        store dict.
    """
    data = {
        'track_pricing_override_id': track_pricing_override_id,
        'store_id': store_id,
        'created_date': datetime.datetime.now()
    }

    created = TrackPricingOverrideStore(**data)

    session.add(created)

    return response.Response(created.to_dict())


@mysql.autosession()
def update_stores(track_pricing_override_id, store_ids, session):
    """Create or delete track pricing override stores.

    Args:
        track_pricing_override_id (int): the ID of the parent code.
        store_ids ([string]): a list of store IDs.
        session (Session): the mysql session.
    Returns:
        response.Response: containing the list of created and deleted
        track pricing override stores.
    """
    existing_stores = _get_by_track_pricing_override_id(
        track_pricing_override_id, session)

    existing_store_ids = [item['store_id'] for item in existing_stores]

    create_new_store_ids = list(set(
        store_ids) - set(existing_store_ids))
    delete_old_store_ids = list(set(
        existing_store_ids) - set(store_ids))

    created = []
    deleted = []

    for store_id in create_new_store_ids:
        create_result = _create(
            track_pricing_override_id, store_id, session)

        created.append(create_result.message)

    for store_id in delete_old_store_ids:
        delete_result = _delete(
            track_pricing_override_id, store_id, session)

        deleted.append(delete_result.message)

    session.commit()

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


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

    Args:
        track_pricing_override_id (int): the ID of the parent override.
        store_id (string): the store ID.
        session (Session): the mysql session.
    Returns:
        response.Response: containing the deleted track pricing override store
        dict.
    """
    result = _delete(track_pricing_override_id, store_id, session)

    session.commit()

    return result


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

    Args:
        track_pricing_override_id (int): the ID of the parent override.
        store_id (string): the store ID.
        session (Session): the mysql session.
    Returns:
        response.Response: containing the deleted track pricing override store
        dict.
    """
    instance = session.query(TrackPricingOverrideStore).filter_by(
        track_pricing_override_id=track_pricing_override_id,
        store_id=store_id).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 stores 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(TrackPricingOverrideStore)\
        .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)
        })