"""
Track Split Model.

Model for getting information about track split.

"""

from sqlalchemy import (
    Column,
    Float,
    Integer,
    String,
    UniqueConstraint,
    exc as sqlexeption,
)

from contracts import response
from contracts.connectors import mysql
from contracts.constants import contracts_constants, error
from contracts.models import contract_history


class TrackSplit(mysql.BaseModel):
    """TrackSplit class."""

    __tablename__ = 'track_split'
    __table_args__ = (UniqueConstraint('vendor_id', 'isrc', name='vendorid_isrc_idx'),)

    track_split_id = Column(Integer, primary_key=True)  # noqa B001, B003
    vendor_id = Column(Integer)
    isrc = Column(String(16))
    track_split = Column(Float)
    track_unique_id = Column(Integer)

    def to_dict(self):
        """Get a dict representation."""
        return {
            'isrc': self.isrc,
            'track_split': self.track_split,
            'track_unique_id': self.track_unique_id,
        }


def get_track_split(vendor_id, page_offset=None, page_limit=None):
    """Get a track split for provided vendor.

    Args:
        vendor_id (int): Vendor Id.
    Returns:
        response.Response: list of isrc and track_splits

    """
    sort = TrackSplit.track_split_id
    with mysql.db_session() as session:
        query = (
            session.query(TrackSplit)
            .filter(TrackSplit.vendor_id == vendor_id)
            .order_by(sort.desc())
        )
        paginated_query = query.offset(page_offset).limit(page_limit)
        result = [splits.to_dict() for splits in paginated_query.all()]

        session.expunge_all()

        result_data = {
            'items': result,
            'pagination': {
                'type': 'standard',
                'offset': page_offset,
                'limit': page_limit,
                'total_records': query.count(),
            },
        }
        return response.Response(result_data)


def set_track_split(vendor_id, data):
    """Set a track split for provided vendor_id and isrc.

    Args:
        vendor_id (int): vendor_id.
        data (list): a list of dictionaries of request parameters.
    Returns:
        response.Response: status

    """
    with mysql.db_session() as session:
        for item in data:
            track_split = TrackSplit(
                vendor_id=vendor_id,
                isrc=item['isrc'],
                track_split=item['track_split'],
                track_unique_id=item['track_unique_id'],
            )
            vendor_history = contract_history.set_track_change_history(
                contracts_constants.SET_TRACK_SPLIT_MESSAGE,
                vendor_id,
                item['isrc'],
                item['vend_contract_id'],
                item['oa_user_id'],
                item['track_split'],
            )
            try:
                session.add(track_split)
                session.add(vendor_history)
                session.flush()
            except sqlexeption.IntegrityError:
                session.rollback()
                return response.create_error_response(
                    'Conflict', 'Duplicate entry for isrc and vendor id', 409
                )
        session.commit()
    return response.create_status_ok_response()


def update_track_split(vendor_id, data):
    """Update a track split for provided vendor_id and isrc.

    Args:
        vendor_id (int): vendor_id.
        data (list): a list of dictionaries of request parameters.
    Returns:
        response.Response: status

    """
    with mysql.db_session() as session:
        for item in data:
            row = (
                session.query(TrackSplit)
                .filter(TrackSplit.vendor_id == vendor_id)
                .filter(TrackSplit.isrc == item['isrc'])
                .first()
            )
            if not row:
                return response.create_not_found_response(
                    item['isrc'].join(['ISRC: ', ' not found'])
                )
            row.track_split = item['track_split']
            vendor_history = contract_history.set_track_change_history(
                contracts_constants.UPDATE_TRACK_SPLIT_MESSAGE,
                vendor_id,
                item['isrc'],
                item['vend_contract_id'],
                item['oa_user_id'],
                item['track_split'],
                item['old_track_split'],
            )
            try:
                session.add(vendor_history)
                session.flush()
            except sqlexeption.IntegrityError:
                session.rollback()
        session.commit()
    return response.create_status_ok_response()


def delete_track_split(vendor_id, data):
    """Delete a track split for provided ISRC and vendor id.

    Args:
        vendor_id (int): unique identifier of the vendor.
        data (dict): dictionary of request parameters.
    Returns:
        response.Response: status

    """
    with mysql.db_session() as session:
        row = (
            session.query(TrackSplit)
            .filter(TrackSplit.isrc == data['isrc'], TrackSplit.vendor_id == vendor_id)
            .first()
        )
        if not row:
            return response.create_not_found_response(
                error.ERROR_MESSAGE_TRACK_SPLIT_RECORD_NOT_FOUND.format(
                    isrc=data['isrc'], vendor_id=vendor_id
                )
            )
        session.delete(row)
        vendor_history = contract_history.set_track_change_history(
            contracts_constants.DELETE_TRACK_SPLIT_MESSAGE,
            vendor_id,
            data['isrc'],
            data['vend_contract_id'],
            data['oa_user_id'],
        )
        session.add(vendor_history)
        session.commit()
    return response.create_status_ok_response()