"""Highlight Model.

Model representing marketing highlight metadata.
"""

from oto import response
import sqlalchemy

from lyrics.connectors import mysql


TRACK_ENTITY = "track"
ENTITY_TYPES = ("vendor", "artist", "release", TRACK_ENTITY, "ex_a_release", "project")
ATTACHMENT = ("Y", "N")
SCOPES = "public", "internal_only"
ALW_CLIENT = "alw"
CLIENTS = "oa", ALW_CLIENT
LYRICS_PROGRAM_ID = 21


class Lyrics(mysql.BaseModel):
    """Highlight Model."""

    __tablename__ = "mkt_program_info"

    highlight_id = sqlalchemy.Column(
        "mkt_program_info_id", sqlalchemy.Integer, primary_key=True, autoincrement=True
    )
    mkt_program_id = sqlalchemy.Column(sqlalchemy.Integer)
    entity = sqlalchemy.Column("info_for", sqlalchemy.Enum(*ENTITY_TYPES))
    entity_id = sqlalchemy.Column("info_for_id", sqlalchemy.BigInteger)
    subject = sqlalchemy.Column(sqlalchemy.VARCHAR(255))
    description = sqlalchemy.Column(sqlalchemy.Text)
    attachment = sqlalchemy.Column(sqlalchemy.Enum(*ATTACHMENT), default="N")
    scope = sqlalchemy.Column(sqlalchemy.Enum(*SCOPES), default="internal_only")
    client = sqlalchemy.Column(sqlalchemy.Enum(*CLIENTS), default="oa")
    date_added = sqlalchemy.Column(sqlalchemy.DateTime, default=sqlalchemy.func.now())
    last_updated = sqlalchemy.Column(
        sqlalchemy.DateTime, onupdate=sqlalchemy.func.now()
    )

    def to_dict(self):
        """Create a dictionary representation of the object.

        Note: this dictionary does not return the dates (date_added and
        last_updated). If you need to return the dates, make sure you cast
        them into a ISO-8601, and if possible, UTC.

        Returns:
            dict: the representation of the object.
        """
        return {"track_id": self.entity_id, "lyrics": self.description}


@mysql.wrap_db_errors
def get_lyrics_by_track_id(track_id):
    """Fetch lyrics by track id.

    Args:
        track_id (int): Track id.

    Returns:
        response.Response: object containing lyrics
            if available else not found response.
    """
    conditions = [
        Lyrics.entity == TRACK_ENTITY,
        Lyrics.entity_id == track_id,
        Lyrics.mkt_program_id == LYRICS_PROGRAM_ID,
    ]
    with mysql.db_session() as session:
        lyrics_obj = (
            session.query(Lyrics)
            .filter(*conditions)
            .order_by(Lyrics.last_updated.desc())
            .first()
        )

        if not lyrics_obj:
            return response.create_not_found_response()

        return response.Response(message=lyrics_obj.to_dict())


@mysql.wrap_db_errors
def put_lyrics_by_track_id(track_id, lyrics):
    """Put lyrics by track id.

    Args:
        track_id (int): Track id.
        lyrics (str): Track lyrics.

    Returns:
        response.Response: object containing lyrics
            if available else not found response.
    """
    conditions = [
        Lyrics.entity == TRACK_ENTITY,
        Lyrics.entity_id == track_id,
        Lyrics.mkt_program_id == LYRICS_PROGRAM_ID,
    ]
    with mysql.db_session() as session:
        lyrics_obj = (
            session.query(Lyrics)
            .filter(*conditions)
            .with_for_update()
            .order_by(Lyrics.last_updated.desc())
            .first()
        )
        if lyrics_obj:
            lyrics_obj.description = lyrics
        else:
            lyrics_obj = Lyrics(
                entity=TRACK_ENTITY,
                entity_id=track_id,
                mkt_program_id=LYRICS_PROGRAM_ID,
                subject=None,
                description=lyrics,
            )
            session.add(lyrics_obj)
        return response.Response(message=lyrics_obj.to_dict())


@mysql.wrap_db_errors
def delete_lyrics_by_track_id(track_id):
    """Delete lyrics by track id.

    Args:
        track_id (int): Track id.

    Returns:
        response.Response: success response if object exists else 404.
    """
    conditions = [
        Lyrics.entity == TRACK_ENTITY,
        Lyrics.entity_id == track_id,
        Lyrics.mkt_program_id == LYRICS_PROGRAM_ID,
    ]
    with mysql.db_session() as session:
        count = session.query(Lyrics).filter(*conditions).delete()

        if not count:
            return response.create_not_found_response()

        return response.Response()


@mysql.wrap_db_errors
def delete_lyrics_by_track_ids(track_ids):
    """Delete lyrics by track ids.

    Args:
        track_ids (list): Track ids.

    Returns:
        response.Response: Response with count of deleted objects
            if success.

    """
    conditions = [
        Lyrics.entity == TRACK_ENTITY,
        Lyrics.entity_id.in_(track_ids),
        Lyrics.mkt_program_id == LYRICS_PROGRAM_ID,
    ]
    with mysql.db_session() as session:
        count = (
            session.query(Lyrics).filter(*conditions).delete(synchronize_session=False)
        )
        return response.Response(message={"count": count})


@mysql.wrap_db_errors
def copy_lyrics_by_track_ids(items):
    """Copy lyrics by track ids.

    Args:
        items (list): Source and destination track ids.

    Returns:
        response.Response: empty response if success.
    """
    filters = [
        Lyrics.entity == TRACK_ENTITY,
        Lyrics.entity_id.in_([item["source_tuid"] for item in items]),
        Lyrics.mkt_program_id == LYRICS_PROGRAM_ID,
    ]
    with mysql.db_session() as session:
        lyrics_objs = session.query(Lyrics).filter(*filters).all()
        new_items = []
        for source in lyrics_objs:
            for item in items:
                if source.entity_id == item["source_tuid"]:
                    new_items.append(
                        Lyrics(
                            entity=TRACK_ENTITY,
                            entity_id=item["destination_tuid"],
                            mkt_program_id=LYRICS_PROGRAM_ID,
                            subject=None,
                            description=source.description,
                        )
                    )
        session.bulk_save_objects(new_items)
    return response.Response()


@mysql.wrap_db_errors
def bulk_track_lyrics_by_track_ids(track_list):
    """Fetch lyrics of multiple tracks.

    Args:
        track_list (list): Track id(s).

    Returns:
        response.Response: object containing lyrics and track id
            if available else not found response.
    """
    conditions = [
        Lyrics.entity == TRACK_ENTITY,
        Lyrics.entity_id.in_(track_list),
        Lyrics.mkt_program_id == LYRICS_PROGRAM_ID,
    ]
    with mysql.db_session() as session:
        lyrics_objs = session.query(Lyrics).filter(*conditions).all()

        if not lyrics_objs:
            return response.create_not_found_response()

        response_items = [
            {"track_id": item.entity_id, "lyrics": item.description}
            for item in lyrics_objs
        ]
    return response.Response(message={"items": response_items})