"""Releases Model."""

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

from ows_product_physical.connector import mysql
from ows_product_physical.constant import field
from ows_product_physical.models.sql import product_physical


class Releases(mysql.BaseModel):
    """Releases model."""

    __tablename__ = 'releases'

    release_id = Column(
        Integer, primary_key=True, nullable=False, autoincrement=True)
    subaccount_id = Column(Integer)
    release_status = Column(
        String, default=field.DEFAULT_RELEASE_STATUS_STATUS)
    not_for_distribution = Column(
        Enum(field.REASON_NO), default=field.REASON_NO)
    vendor_catalog_number = Column(String)
    product_name = Column('release_name', String)
    upc = Column(BigInteger)
    display_upc = Column(String)
    project_id = Column(Integer)
    label = Column(String)
    artist_id = Column(Integer)
    version = Column(String)
    genre_id = Column(Integer)
    release_date = Column(String)
    sale_start_date = Column(String)
    format = Column(String)  # noqa
    new_release = Column(Enum('New', 'Catalog'))
    distribution_format_id = Column(Integer)
    product_code = Column(String)
    special_instructions = Column(Text)
    cline = Column('c_line', String)
    description = Column(Text)
    country_of_origin = Column(Integer)

    def to_dict(self):
        """Dict-ified representation of a release row."""
        return {
            'release_id': self.release_id,
            'subaccount_id': self.subaccount_id,
            'release_status': self.release_status,
            'not_for_distribution': self.not_for_distribution,
            'vendor_catalog_number': self.vendor_catalog_number,
            'product_name': self.product_name,
            'upc': self.upc,
            'display_upc': self.display_upc,
            'project_id': self.project_id,
            'label': self.label,
            'artist_id': self.artist_id,
            'version': self.version,
            'genre_id': self.genre_id,
            'release_date': self.release_date,
            'sale_start_date': self.sale_start_date,
            'format': self.format,
            'new_release': self.new_release,
            'distribution_format_id': self.distribution_format_id,
            'product_code': self.product_code,
            'special_instructions': self.special_instructions,
            'c_line': self.cline,
            'description': self.description,
            'country_of_origin': self.country_of_origin
        }


def create(values, session):
    """Create an entry in the `releases` table.

    Args:
        values (dict): dictionary of values to insert
        session: database connection object
    """
    release = Releases(**values)

    session.add(release)
    session.flush()

    return release.to_dict()


def update(values, release_id, session):
    """Update an entry in the `releases` table.

    Args:
        values (dict): dictionary of values to update
        release_id (int): id of release to update
        session: database connection object
    """
    session.query(Releases) \
        .filter(Releases.release_id == release_id) \
        .update(values)


def delete(release_id, session):
    """Delete an entry from the `releases` table.

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


def set_upc_to_used(upc):
    """Updates upc status in upcs table to 'used'.

    Args:
        upc (int): UPC value

    Returns:
        int: number of rows updated
    """
    with mysql.db_session() as session:
        result = session.execute(
            product_physical.SET_UPC_TO_USED, {'upc': upc})
        return result.rowcount