from models.modules.core import logger, request, InvalidUsage, make_response, app, url_for
from models.libs.jwt import decodejwt, get_userinfo
from models.dbmodels.skits_model import *
from datetime import datetime
import ast

class Skits():

    def process_skits(skits):
        try:
            skitResults = []
            for skit in skits:
                skitObject = skit_scheme.dump(skit)
                skitObject['files'] = ast.literal_eval(skit.files)
                skitObject['tags'] = ast.literal_eval(skit.tags)
                review = ReviewModel.query.filter_by(skit_id = skit.id).first()
                reviewObj = {}
                reviews = review_scheme.dump(review)
                reviewObj['comments'] = ast.literal_eval(reviews['comments'])
                reviewObj['likes'] = ast.literal_eval(reviews['likes'])
                reviewObj['likes_count'] = len(reviewObj['likes'])
                reviewObj['comments_count'] = len(reviewObj['comments'])
                skitObject['reviews'] = reviewObj
                skitResults.append(skitObject)
            return skitResults
        except Exception as e:
            raise Exception(str(e))

    def getAllskits():
        try:
            userInfo = dict(decodejwt())
            skits = SkitModel.query.filter_by(uid = userInfo['uid']).all()
            if skits is None:
                return make_response({
                    "message": []
                }, 200)

            return {
                "message": Skits.process_skits(skits)[::-1]
            }
        except exc.SQLAlchemyError as e:
            raise Exception(e._message)
        except Exception as e:
            raise Exception(str(e))
    
    def get_a_skit(value):
        try:
            userInfo = dict(decodejwt())
            skits = SkitModel.query.filter(and_(
                SkitModel.id.like(value))).all()
            if skits is None:
                return make_response({
                    "message": []
                }, 200)

            return {
                "message": Skits.process_skits(skits)[::-1]
            }

        except exc.SQLAlchemyError as e:
            raise Exception(e._message)
        except Exception as e:
            raise Exception(str(e))

    def add_skits():
        try:
            userInfo = dict(decodejwt())
            description = request.json['description']
            post_type = request.json['post_type']
            tags = request.json['tags']
            category = request.json['category']
            files = request.json['files']
            is_commentable = request.json['is_commentable']

            date = datetime.now().utcnow()
            skitinfo = SkitModel(userInfo['uid'], description, post_type, category, str(tags), is_commentable, date, files)
            db.session.add(skitinfo)
            db.session.flush()
            skit_id = str(skitinfo.id)

            reviewinfo = ReviewModel(userInfo['uid'], skit_id, str([]), str([]))
            db.session.add(reviewinfo)
            db.session.commit()

            db.session.close()
            return make_response({
                "message": "skits saved",
            }, 200)

        except exc.SQLAlchemyError as e:
            raise Exception(e._message)
        except Exception as e:
            raise Exception(str(e))
    
    def delete(id):
        try:
            skit = SkitModel.query.filter_by(id = id).first()
            if not skit:
                return make_response({
                    "error": "no skit info found"
                }, 400)
                
            db.session.delete(skit)
            db.session.commit()
            db.session.close()
            return make_response({
                "message": "skit deleted successfully",
            }, 200)
        except exc.SQLAlchemyError as e:
            raise Exception(e._message)
        except Exception as e:
            raise Exception(str(e))

    def get_categories():
        try:
            categories = CategoriesModel.query.all()
            if categories is None:
                return make_response({
                    "error": "no category created"
                }, 400)
            return {
                "message": categories_scheme.dump(categories)[::-1]
            }
            
        except exc.SQLAlchemyError as e:
            raise Exception(e._message)
        except Exception as e:
            raise Exception(str(e))

    def add_categories():
        try:
            name = request.json['name']
            subcategory = request.json['subcategory']
            parent = request.json['parent']
            summary = request.json['summary']

            catinfo = CategoriesModel(name, summary, subcategory, parent)
            db.session.add(catinfo)
            db.session.commit()
            db.session.close()
            return make_response({
                "message": "category info saved",
            }, 201)
        except exc.SQLAlchemyError as e:
            raise Exception(e._message)
        except Exception as e:
            raise Exception(str(e))