from datetime import datetime, timezone
from app.extensions import db
from sqlalchemy.sql import func
from sqlalchemy.exc import IntegrityError
import uuid
from app.utils.logger import logger

class Members(db.Model):
    __tablename__ = 'members'

    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    uid = db.Column(db.String(150), nullable=False)
    username = db.Column(db.String(25), nullable=False)
    password = db.Column(db.String(100), nullable=True)
    loc = db.Column(db.String(20), nullable=True)
    status = db.Column(db.Integer, default=1)
    added = db.Column(db.DateTime(timezone=False), server_default=func.now())
    updated = db.Column(db.DateTime(timezone=False), server_default=func.now(), onupdate=func.now())
    email = db.Column(db.String(100), nullable=False)
    account_name = db.Column(db.String(100), nullable=True)
    firstname = db.Column(db.String(25), nullable=False)
    lastname = db.Column(db.String(100), nullable=True)
    country = db.Column(db.String(3), nullable=True)
    profile_completed = db.Column(db.DateTime(timezone=False))
    stripe_customer_id = db.Column(db.String(100), nullable=True)
    option_name = db.Column(db.String(100), nullable=True)

    def to_dict(self):
        return {
            "id": self.id,
            "uid": str(self.uid),
            "profile_completed": self.profile_completed,
            "username": self.account_id,
            "account_id": self.username,
            "password": self.password,
            "country": self.country,
            "loc": self.loc,
            "status": self.status,
            "added": self.added.isoformat() if self.added else None,
            "updated": self.updated.isoformat() if self.updated else None,
            "email": self.email,
            "account_name": self.account_name,
            "firstname": self.firstname,
            "lastname": self.lastname,
            'option_name': self.option_name,
            "stripe_customer_id": self.stripe_customer_id
        }

    def __repr__(self):
        return f'<Members {self.id} - {self.uid}>'

    @classmethod
    def get_member_by_username(cls, username):
        member = cls.query.filter_by(username=str(username)).first()
        if not member:
            return None
        return member

    @classmethod
    def get_member_by_uid(cls, uid):
        member = cls.query.filter_by(uid=str(uid)).first()

        if not member:
            logger.info(f"User UID =  {uid} found")
            return None
        return member

    @classmethod
    def set_member_profile_completed(cls, uid):
        member = cls.query.filter_by(uid=str(uid)).first()

        if not member:
            logger.info(f"User UID =  {uid} found")
            raise ValueError(f"Member with UID {uid} does not exist.")

        member.profile_completed = datetime.now(timezone.utc)
        return member.profile_completed


    @classmethod
    def add_member(cls, firstname, lastname, email, username,password, country):

        # Save the response
        member_data = cls(
            uid=str(uuid.uuid4()),
            firstname=firstname,
            lastname=lastname,
            username =username,
            email=email,
            country=country,
            password=password,
            added=datetime.now(timezone.utc),
            updated=datetime.now(timezone.utc)
        )

        try:
            db.session.add(member_data)
        except IntegrityError as err:
            raise ValueError(f"Database integrity error: {err}")
        return member_data


    @classmethod
    def update_user_password(cls, reset_id, member_uid, member_id, new_passwprd_hash):
        member = cls.query.filter_by(uid=str(member_uid),id=member_id).first()
        if not member:
            raise ValueError(f"Reset with UID {member_uid} does not exist.")

        # Update reset_p status and the updated_at timestamp
        member.password = new_passwprd_hash

    @classmethod
    def set_user_stripe_id(cls, member_uid, member_id, stripe_customer_id):
        member = cls.query.filter_by(uid=str(member_uid),id=member_id).first()
        if not member:
            raise ValueError(f"Reset with UID {member_uid} does not exist.")
        # Update stripe_customer_id
        member.stripe_customer_id = stripe_customer_id

        return stripe_customer_id


    @classmethod
    def get_all_member(cls, email=None, username=None, page=1, limit=20):

        query = cls.query
        logger.info(f"Get all customer back")

        if username:
            query = query.filter(cls.username == username)

        if email:
            query = query.filter(cls.email == email)

        # Order by created_at descending (newest first)
        query = query.order_by(cls.added.desc())

        # Get total count before pagination
        total_count = query.count()

        # Apply pagination
        offset = (page - 1) * limit
        query = query.limit(limit).offset(offset)

        return query.all(), total_count