"""Product Physical Model."""

from sqlalchemy import Column
from sqlalchemy import Enum
from sqlalchemy import Integer
from sqlalchemy import Numeric
from sqlalchemy import String
from sqlalchemy import Text

from ows_product_physical.connector import mysql


class ProductPhysical(mysql.BaseModel):
    """Product Physical Model."""

    __tablename__ = 'product_physical'

    pp_id = Column(
        'id', Integer, primary_key=True, autoincrement=True, nullable=False)
    release_id = Column(Integer)
    packaging_id = Column(Integer)
    display_configuration = Column(String)

    exclusive_for = Column(String)
    initial_stock = Column(Integer)
    units_per_set = Column(Integer)
    box_lot = Column(Integer)
    pline = Column(String)
    discount = Column(Text)
    production_notes = Column(Text)
    pricing = Column(Numeric(6, 2))
    wholesale_price = Column(Numeric(6, 2))

    end_date = Column(String)

    individual = Column(Enum('Y', 'N'))
    explicit = Column(Enum('Y', 'N'))
    manufacturing_obligation = Column(Enum('Y', 'N'))

    japan_distribution = Column(Enum('no', 'yes_only', 'yes_other'))
    edition = Column(Enum(
        'normal_edition',
        'first_run_limited_edition',
        'initial_limited_edition',
        'limited_edition',
        'period_limited_edition'))

    def to_dict(self):
        """Dict-ified row of the product_physical table."""
        return {
            'id': self.pp_id,
            'release_id': self.release_id,
            'packaging_id': self.packaging_id,
            'exclusive_for': self.exclusive_for,
            'initial_stock': self.initial_stock,
            'units_per_set': self.units_per_set,
            'box_lot': self.box_lot,
            'pricing': self.pricing,
            'end_date': self.end_date,
            'discount': self.discount,
            'wholesale_price': self.wholesale_price,
            'individual': self.individual,
            'explicit': self.explicit,
            'manufacturing_obligation': self.manufacturing_obligation,
            'production_notes': self.production_notes,
            'pline': self.pline,
            'display_configuration': self.display_configuration,
            'japan_distribution': self.japan_distribution,
            'edition': self.edition
        }


def create(values, session):
    """Insert a product_physical row.

    Args:
        values (dict): dictionary of values to store
        session: database connection object
    """
    physical_product = ProductPhysical(**values)

    session.add(physical_product)
    session.flush()


def update(values, release_id, session):
    """Update a product_physical row.

    Args:
        values (dict): dictionary of values to store
        release_id (int): id of release associated with the updating product
        session: database connection object
    """
    session.query(ProductPhysical) \
        .filter(ProductPhysical.release_id == release_id) \
        .update(values)


def delete(release_id, session):
    """Delete a product_physical row.

    Args:
        release_id (int): id of release being deleted
        session: database connection object
    """
    session.query(ProductPhysical) \
        .filter(ProductPhysical.release_id == release_id) \
        .delete()