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 SubscriptionGenerative(db.Model):
    __tablename__ = 'subscription_generative'

    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)
    practice = db.Column(db.String(100), nullable=False)
    specialization = db.Column(db.String(100), nullable=False)
    product_id = db.Column(db.String(25), nullable=False)
    subscription_uid = db.Column(db.String(100), nullable=True)
    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)).first()
        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):
        logger.info(
            f"UPDATE SubscriptionGenerative::status   subscription_uid = {subscription_uid} status = {status} ")
        subscription_generative_data = cls.query.filter_by(subscription_uid=str(subscription_uid)).first()

        if not subscription_generative_data:
            logger.error(f"SubscriptionGenerative with Sub UID {subscription_uid} does not exist.")
            return None
        logger.info("UPDATE STATUS::Point-->")
        subscription_generative_data.status = status
        db.session.commit()

        return subscription_generative_data.status

    @classmethod
    def create_subscription_generative(cls, member_id ,practice,specialization,product_id, subscription_uid):

        logger.info(f"SubscriptionGenerative Data {member_id} ,{practice} ,{specialization},{product_id}, {subscription_uid} ")
        subscription_generative_data = cls(
            uid=str(uuid.uuid4()),
            member_id=member_id,
            practice=practice,
            specialization=specialization,
            product_id=product_id,
            subscription_uid=subscription_uid,
            added=datetime.now(timezone.utc)
        )
        try:
            logger.info(f" About to Insert Subscription_Generative Data {subscription_generative_data.member_id} ")
            db.session.add(subscription_generative_data)
            db.session.flush()
        except IntegrityError as err:
            logger.error(f" Error inserting Subscription_Generative data {err}  -- ")
            raise ValueError(f"Database integrity error: {err}")
        return subscription_generative_data

    def to_dict(self):
        """
        Convert the Loan object to a dictionary format for JSON serialization.
        """
        return {
            'id': self.id,
            'uid': self.uid,
            'member_id': self.member_id,
            'practice': self.practice,
            'specialization': self.specialization,
            'product_id': self.product_id,
            'subscription_uid': self.subscription_uid,
            'added': self.added,
            'status': self.status
        }

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