"""TrackPublisher model."""
from sqlalchemy import BigInteger
from sqlalchemy import Column
from sqlalchemy import ForeignKey
from sqlalchemy import Integer
from sqlalchemy import String

from ows_product_physical.connector import mysql


class TrackPublisher(mysql.BaseModel):
    """Encapsulates Track Publisher data.

    Represents track_publisher table in the art_relation database.
    This table has a one to many relationship to the Track table.
    """

    __tablename__ = 'track_publisher'

    track_publisher_id = Column(
        Integer, primary_key=True, autoincrement=True, nullable=False)

    track_id = Column(
        'unique_track_id', ForeignKey('track.id'), nullable=False)

    publisher_name = Column(String(255), nullable=False)

    # It is unknown if a legacy process is using the UPC column here
    upc = Column('upc', BigInteger)

    @property
    def name(self):
        """Property to get publisher_name."""
        return self.publisher_name

    @name.setter
    def name(self, value):
        """Set the name.

        Args:
            value (str): Name to set
        """
        self.publisher_name = value

    @property
    def role_type(self):
        """Property to make uniform API for related track data."""
        return 'publisher'

    def to_dict(self):
        """Convert the track artist data to dict."""
        return {
            'track_publisher_id': self.track_publisher_id,
            'type': 'publisher',
            'name': self.publisher_name
        }


def create(publishers, track_id, session):
    """Insert publishers in track_publisher table for a particular track.

    Args:
        session (object): database connection object
        publishers (list): list of publisher names
        track_id (int): id of track associated with the publisher

    Response:
        None
    """
    track_publishers = [
        TrackPublisher(track_id=track_id, name=publisher_name)
        for publisher_name in publishers]
    session.add_all(track_publishers)
    session.flush()


def delete_by_track_id(track_id, session):
    """Delete track publishers in track_publisher table for a particular track.

    Args:
        session (object): database connection object.
        track_id (int): id of track associated with the publisher.

    Response:
        None
    """
    (session.query(TrackPublisher)
        .filter(TrackPublisher.track_id == track_id)
        .delete())


def bulk_delete_by_track_id(track_numbers, session):
    """Delete all publishers for all tracks.

    Args:
        track_numbers (list): list of track numbers to delete artists for.
        session (object): database connection object
    """
    (session.query(TrackPublisher)
        .filter(TrackPublisher.track_id.in_(track_numbers))
        .delete(synchronize_session=False))