from datetime import datetime
from fastapi import HTTPException, status
from sqlalchemy.orm import Session
from sqlalchemy import select,and_
import typing as t

from app.db.cruddb.crudbase import crudbase
from fastapi_pagination.ext.sqlalchemy import paginate
from app.core.common import  ApiReturnPage

from app.db import models, schemas
from app.core.security import chacha20Decrypt, get_password_hash

class dbflow(crudbase):
    def __init__(self):
        super().__init__(model=models.Flow)

    def get_domain_apps(self):
        return None
    
    def get_domain_app_by_appid(self,db: Session,domainurl:str,appid:str):
        return db.execute(select(models.Flow).filter(and_(models.Flow.domainurl ==  domainurl,models.Flow.appid == appid))).scalars().all()


    def create_flow(self,db: Session, domainurl: str, flow: schemas.FlowIn,userid:int):
        db_flow = models.Flow(
            flowid=flow.flowid,
            appid=flow.appid,
            eventid=flow.eventid,
            domainurl=domainurl,
            name=flow.name,
            content=flow.content,
            createuserid = userid,
            updateuserid = userid
        )
        db.add(db_flow)
        db_app = db.execute(select(models.App).filter(and_(models.App.domainurl ==  domainurl,models.App.appid == flow.appid))).scalars().first()
        if not db_app:
            db_app = models.App(
            domainurl = domainurl,
            appid=flow.appid,
            appname=flow.appname,
            version = 0,
            createuserid= userid,
            updateuserid = userid
            )
            db.add(db_app)
        db.commit()
        db.refresh(db_flow)
        return db_flow

dbflow = dbflow()


class dbappversion(crudbase):
    def __init__(self):
        super().__init__(model=models.AppVersion)

    def get_appversions(self,domainurl:str,appid:str):
        return super().get_by_conditions({"domainurl":domainurl,"appid":appid})

dbappversion = dbappversion()

class dbapp(crudbase):
    def __init__(self):
        super().__init__(model=models.App)

    def get_app(self,db: Session,domainurl:str,appid:str):
        return db.execute(super().get_by_conditions({"domainurl":domainurl,"appid":appid})).scalars().first()
    
    def get_apps(self,db: Session,domainurl:str):
        return db.execute(super().get_by_conditions({"domainurl":domainurl})).scalars().all()
    
    def update_appversion(self,db: Session, appedit: schemas.AppVersion,userid:int):
        db_app = db.execute(select(models.App).filter(and_(models.App.domainurl ==  appedit.domainurl,models.App.appid == appedit.appid))).scalars().first()
        if not db_app:
            return db_app
        
        db_app.version = db_app.version + 1
        appversion = models.AppVersion(
            domainurl = appedit.domainurl,
            appid=appedit.appid,
            appname=db_app.appname,
            version = db_app.version,
            versionname = appedit.versionname,
            comment = appedit.comment,
            updateuserid = userid,
            createuserid = userid
        )
        db.add(appversion)
        db.add(db_app)

        flows = dbflow.get_domain_app_by_appid(db,appedit.domainurl,appedit.appid) #select(models.Flow).filter(and_(models.Flow.domainurl ==  appedit.domainurl,models.App.appid == appedit.appid)) 
        for flow in flows:
            db_flowhistory = models.FlowHistory(
            flowid = flow.flowid,
            appid = flow.appid,
            eventid = flow.eventid,
            domainurl = flow.domainurl,
            name = flow.name,
            content = flow.content,
            version = db_app.version, 
            updateuserid = userid,
            createuserid = userid
            )
            db.add(db_flowhistory)

        db.commit()
        db.refresh(db_app)
        return db_app

    def delete_app(self,db: Session, domainurl: str,appid: str ):
        db_app =self.get_app(db,domainurl,appid)
        if db_app:
            db.delete(db_app)
            db_flows = dbflow.get_domain_app_by_appid(db,domainurl,appid)
            for flow in db_flows:
                db.delete(flow)
            db.commit()
            return db_app
        return None

    def get_appversions(self,db: Session, domainurl:str,appid:str):
        return paginate(db,dbappversion.get_appversions(domainurl,appid))

    def create_flow(self,db: Session, domainurl: str, flow: schemas.FlowIn,userid:int):
        return dbflow.create_flow(db,domainurl,flow,userid)

appService = dbapp()