"""Product Distribution Model."""

from datetime import datetime

from oto import response
import sentry_sdk
from sqlalchemy import Column
from sqlalchemy import DateTime
from sqlalchemy import Enum
from sqlalchemy import Integer
from sqlalchemy import String

from ows_product_physical.connector import mysql
from ows_product_physical.constant import error
from ows_product_physical.constant import success


class ProductDistribution(mysql.BaseModel):
    """Product Distribution model."""

    __tablename__ = 'product_distribution'

    product_distribution_id = Column(
        Integer, primary_key=True, autoincrement=True, nullable=False)
    product_id = Column(Integer, nullable=False)
    distribute_to = Column(String, nullable=False)
    updated_by = Column(Integer, nullable=True)
    user_type = Column(Enum('oa', 'alw'), default='oa')
    last_updated = Column(DateTime, nullable=False)

    def to_dict(self):
        """Dict representation of a ProductDistribution row."""
        return {
            'product_distribution_id': self.product_distribution_id,
            'product_id': self.product_id,
            'distribute_to': self.distribute_to
        }


def get_product_distribution(product_id):
    """Fetch product distribution by product id.

    Args:
        product_id (int): product id of existing product

    Returns:
        Response: A response object with existing data.
    """
    with mysql.db_session() as session:
        try:
            result = session.query(
                ProductDistribution).filter_by(
                    product_id=product_id).all()

            metadata = {
                'items': [item.to_dict() for item in result]}
            return response.Response(message=metadata, status=200)
        except Exception as exception:
            sentry_sdk.capture_exception(exception)
            return response.create_error_response(
                code=error.INTERNAL_ERROR,
                message='mysql error product_distribution',
                status=500)


def delete_product_distribution(product_id):
    """Delete the product distribution by product_id.

    Args:
        product_id (int): product id of the product

    Returns:
        Response: Response 200 upon successful deletion.
    """
    with mysql.db_session() as session:
        try:
            session.query(ProductDistribution) \
                .filter_by(product_id=product_id) \
                .delete()
            return response.Response(message={'status': 'ok'}, status=200)
        except Exception as exception:
            sentry_sdk.capture_exception(exception)
            return response.create_error_response(
                code=error.INTERNAL_ERROR,
                message='mysql error product_distribution',
                status=500)


def set_product_distribution(
        product_id, product_distribution_data, user_type, user_id):
    """Save product distribution data for given product id.

    Args:
        product_id: (int): unique id of Product
        product_distribution_data (dict): dict contains value of distribute_to.
        user_type: (string): either alw or oa
        user_id (int): orchard user id.

    Returns:
        Response: A response object with success response.
    """
    with mysql.db_session() as session:
        try:
            filters = [
                (ProductDistribution.product_id == product_id),
                (ProductDistribution.distribute_to
                 == product_distribution_data.get('distribute_to'))
            ]
            existing_product_distribution = session.query(
                ProductDistribution).filter(*filters).one_or_none()

            if not existing_product_distribution:
                product_distribution = ProductDistribution(
                    product_id=product_id,
                    distribute_to=product_distribution_data
                    .get('distribute_to'),
                    updated_by=user_id,
                    user_type=user_type,
                    last_updated=datetime.now(),
                )
                session.add(product_distribution)
                session.flush()
        except Exception as exception:
            sentry_sdk.capture_exception(exception)
            return response.create_error_response(
                code=error.INTERNAL_ERROR,
                message=exception,
                status=500)

        return response.Response(
            message=({'status': 'success'}),
            status=success.SUCCESS_CODE
        )