from __future__ import absolute_import
from flask_sqlalchemy.query import Query as BaseQuery
from dostadmin import db, db_model, app_logger
from dostadmin.mixins import TimestampMixin
from dostadmin.db_model.language import Language


class ContentVersionQuery(BaseQuery):
    def get_content_version_by_id(self, content_version_id):
        return self.filter(ContentVersion.id == content_version_id).first()

    def get_content_version_by_content_id(self, content_id):
        return (
            self.filter(ContentVersion.content_id == content_id)
            .order_by(ContentVersion.version)
            .all()
        )

    def get_by_content_id_and_version(self, content_id, version):
        return self.filter(
            ContentVersion.content_id == content_id, ContentVersion.version == version
        ).first()

    def get_all_content_versions(self, page=1, per_page=30):
        return (
            self.join(db_model.Content)
            .join(Language)
            .order_by(db_model.Content.name)
            .paginate(page=page, per_page=per_page, error_out=False)
        )

    def get_content_version_by_content_and_language_id(
        self, content_id, language_id=None
    ):
        if not language_id:
            language_id = db_model.Language.query.find_language_id_with_name("hindi")

        return self.filter(
            ContentVersion.content_id == content_id,
            ContentVersion.language_id == language_id,
            ContentVersion.status == "active",
        ).first()

    def find_content_id_with_exotel_appid(self, exotel_appid):
        content_version = self.filter(
            ContentVersion.exotel_appid == exotel_appid
        ).first()
        if content_version:
            return content_version.content_id
        return None


class ContentVersion(TimestampMixin, db.Model):
    __tablename__ = "content_version"
    query_class = ContentVersionQuery

    class Status:
        ACTIVE = "active"
        INACTIVE = "inactive"

    id = db.Column(db.Integer, primary_key=True)
    content_id = db.Column(db.Integer, db.ForeignKey("content.id"))
    language_id = db.Column(db.Integer, db.ForeignKey("language.id"))
    version = db.Column(db.Float)
    status = db.Column(db.String(50))
    duration_secs = db.Column(db.Integer)
    exotel_appid = db.Column(db.Integer)

    campaign = db.relationship(
        "Campaign",
        back_populates="content_version",
        primaryjoin="ContentVersion.id == Campaign.content_version_id",
    )

    @classmethod
    def update_contents(cls, content_data):
        app_logger.info("Adding content %s", content_data)
        content_version_id = int(content_data[0])
        duration_secs = int(content_data[1])
        exotel_appid = int(content_data[2])
        language = int(content_data[3])
        content_rec = ContentVersion.query.get_content_version_by_id(content_version_id)
        content_rec.duration_secs = duration_secs
        content_rec.exotel_appid = exotel_appid
        content_rec.language_id = language
        db.session.commit()

    @classmethod
    def add_new_content_version(cls, content):
        app_logger.info("Adding versions %s", content)
        errors = None
        content_id = int(content[0])
        duration_secs = int(content[1])
        exotel_appid = int(content[2])
        language = int(content[3])
        version = content[4]

        existing_version = ContentVersion.query.get_by_content_id_and_version(
            content_id=content_id, version=version
        )
        if existing_version:
            errors = "Version: " + version + " Already Exists for this content"
        else:
            content_version_rec = ContentVersion(
                content_id=content_id,
                language_id=language,
                exotel_appid=exotel_appid,
                duration_secs=duration_secs,
                status="active",
                version=version,
            )
            db.session.add(content_version_rec)
            db.session.commit()
        return errors