"""Trascription Model.

This model represents an transcription
"""

import sqlalchemy
from sqlalchemy import ForeignKey
from sqlalchemy.dialects.mysql import INTEGER
from sqlalchemy.sql import func

from podcast.connectors import mysql
from podcast.utils import api_utils
from podcast.utils.exc import OwsError


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

    __tablename__ = 'transcription'

    id = sqlalchemy.Column(INTEGER(unsigned=True), primary_key=True, autoincrement=True)  # noqa
    episode_id = sqlalchemy.Column(
        INTEGER,
        ForeignKey('episode.id'),
        nullable=False
    )
    created_by = sqlalchemy.Column(sqlalchemy.Integer)
    updated_by = sqlalchemy.Column(sqlalchemy.Integer)
    created_date = sqlalchemy.Column(sqlalchemy.DateTime, default=func.now())
    updated_date = sqlalchemy.Column(
        sqlalchemy.DateTime, default=func.now(), onupdate=func.now())
    transcript = sqlalchemy.Column(sqlalchemy.JSON)
    is_transcript_processing = sqlalchemy.Column(sqlalchemy.Boolean, nullable=False, default=False)
    is_deleted = sqlalchemy.Column(sqlalchemy.Boolean, nullable=False, default=False)

    def to_dict(self):
        """Return the object as dictionary."""
        return dict(
            id=self.id,
            episode_id=self.episode_id,
            created_by=self.created_by,
            updated_by=self.updated_by,
            created_date=self.created_date,
            updated_date=self.updated_date,
            is_transcript_processing=self.is_transcript_processing,
            transcript=self.transcript)


def update(episode_id, data):
    """Update the transcript."""
    with mysql.pod_db_session() as session:
        query = session.query(Transcription).filter((Transcription.episode_id == episode_id))
        try:
            user_id = api_utils.get_user_id()
            data['updated_by'] = user_id
        except OwsError:
            pass

        query.update(data)
        result = query.first()
        if result:
            return result.to_dict()
        else:
            raise OwsError.not_found()

        return query.first().to_dict()


def create(episode_id):
    """Create the transcript."""
    with mysql.pod_db_session() as session:
        user_id = api_utils.get_user_id()
        data = {
            'episode_id': episode_id,
            'created_by': user_id,
            'updated_by': user_id,
            'is_transcript_processing': True,
            'transcript': None
        }
        transcription = Transcription(**data)
        session.add(transcription)
    return transcription.to_dict()


def get(episode_id):
    """Get the transcription."""
    with mysql.pod_db_session(read_only=True) as session:
        query = session.query(Transcription).filter(
            Transcription.episode_id == episode_id,
            Transcription.is_deleted.isnot(True)
        )
        return query.first()


def get_all_by_episode_ids(episode_ids):
    """Get the transcriptions for the given episode ids."""
    with mysql.pod_db_session(read_only=True) as session:
        query = session.query(Transcription).filter(
            Transcription.episode_id.in_(episode_ids),
            Transcription.is_deleted.isnot(True)
        ).all()
    return query


def start(episode_id):
    """Start a new transcription for an episode."""
    transcription = get(episode_id)
    if transcription:
        update(episode_id, {'is_transcript_processing': True, 'transcript': None})
    else:
        create(episode_id)


def delete(episode_id):
    """Soft delete the transcription."""
    with mysql.pod_db_session() as session:
        transcription = session.query(Transcription).filter((Transcription.episode_id == episode_id))
        transcription.update({'is_deleted': True})