from datetime import datetime, timezone, timedelta
from itertools import product
from app.extensions import db
from sqlalchemy.exc import IntegrityError
from sqlalchemy.orm import relationship
from dateutil.relativedelta import relativedelta
from datetime import timedelta
import logging
from sqlalchemy import and_, or_, not_
from sqlalchemy.sql import func
import uuid

logger = logging.getLogger(__name__)


class GenerativeResults(db.Model):
    __tablename__ = 'generative_results'

    id = db.Column(
        db.Integer,
        primary_key=True,
        autoincrement=True,
    )

    uid = db.Column(db.String(150), nullable=False)
    member_id = db.Column(db.Integer, nullable=False)
    product_id = db.Column(db.String(25), nullable=False)
    var_name = db.Column(db.String(100), nullable=False)
    subscription_uid = db.Column(db.String(100), nullable=False)
    text_result = db.Column(db.String(14000), nullable=False)
    status = db.Column(db.Integer, nullable=True, default=0)
    added = db.Column(db.DateTime(timezone=True), server_default=func.now())

    @classmethod
    def get_subscription_generative_by_subscription_uid(cls, subscription_uid):
        subscription_generative = cls.query.filter_by(subscription_uid=str(subscription_uid)).all()
        if not subscription_generative:
            return None
        return subscription_generative

    @classmethod
    def get_subscription_generative_list_by_status(cls, status):
        subscription_generative = cls.query.filter_by(status=status).all()
        if not subscription_generative:
            return None
        return subscription_generative

    @classmethod
    def update_subscription_generative_status(cls, subscription_uid, status):
        subscription_generative = cls.query.filter_by(subscription_uid=str(subscription_uid)).first()
        if not subscription_generative:
            logger.error(f"SubscriptionGenerative with Sub UID {subscription_uid} does not exist.")
            return None
        subscription_generative.status =status
        return status

    @classmethod
    def create_generative_result(cls, member_id,product_id,var_name,subscription_uid,text_result):
           # create_generative_result(member_id,product_id,var_name,subscription_uid,text_result)
        logger.info(f"GenerativeResults Create::Data {member_id} ,{product_id} ,{var_name} , {subscription_uid},{text_result} ")
        subscription_generative_data = cls(
            uid=str(uuid.uuid4()),
            member_id=member_id,
            var_name=var_name,
            text_result=text_result,
            product_id=product_id,
            subscription_uid=subscription_uid,
            added=datetime.now(timezone.utc)
        )
        try:
            logger.info(f" About to Insert GenerativeResults Data {subscription_generative_data.member_id} ")
            db.session.add(subscription_generative_data)
            db.session.commit()
        except IntegrityError as err:
            logger.error(f" Error inserting GenerativeResults data {err}  -- ")
            raise ValueError(f"Database integrity error: {err}")
        return subscription_generative_data

    def to_dict(self):

        return {
            'id': self.id,
            'uid': self.uid,
            'member_id': self.member_id,
            'product_id': self.product_id,
            'var_name': self.var_name,
            'subscription_uid': self.subscription_uid,
            'text_result': self.text_result,
            'status': self.status,
            'added': self.added
        }

    def __repr__(self):
        return f'<GenerativeResults {self.id}>'