from datetime import datetime, timezone
from app.extensions import db
from app.models.charge import Charge
from sqlalchemy.orm import relationship
from sqlalchemy.sql import func
from sqlalchemy.exc import IntegrityError
import uuid
from app.utils.logger import logger

class PasswordReset(db.Model):
    __tablename__ = 'password_reset'

    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    uid = db.Column(db.String(150), nullable=False)
    username = db.Column(db.String(35), nullable=False)
    status = db.Column(db.Integer, nullable=True, default=0)
    added = db.Column(db.DateTime(timezone=True), server_default=func.now())
    updated = db.Column(db.DateTime(timezone=True), server_default=func.now(), onupdate=func.now())

    def to_dict(self):
        return {
            "id": self.id,
            "uid": str(self.uid),
            "username": self.account_id,
            "status": self.status,
            "added": self.added.isoformat() if self.added else None,
            "updated": self.updated.isoformat() if self.updated else None,
        }

    @classmethod
    def get_rest_with_uid(cls, pending_uid):
        """
        Return all offers in dictionary format.
        """
        pass_reset = cls.query.filter_by(uid = pending_uid).first()
        if not pass_reset:
            raise ValueError(f"Password Reset with UID {pending_uid} does not exist.")
        return pass_reset

    @classmethod
    def update_status(cls, reset_id, status):
        # Retrieve Reset
        reset_p = cls.query.get(reset_id)

        if not reset_p:
            raise ValueError(f"Reset with ID {reset_id} does not exist.")

        if reset_p.status == status:
            return

        # Update reset_p status and the updated_at timestamp
        reset_p.status = status

    @classmethod
    def create_reset(cls, username):
        logger.info(f"Enter to reset the password**********  "+username)
        uid_val = str(uuid.uuid4())
        logger.info(f"Enter to reset the password UID *****  "+uid_val)
        data1 ={
                'uid' :uid_val,
                'username' : username,
                'status' : 0,
                'added' : datetime.now(timezone.utc),
                'updated' : datetime.now(timezone.utc)
               }
        logger.info(f"Enter to reset the password DATA *****  {data1}")

        pass_reset = cls(
            uid=uid_val,
            username=username,
            status=0,
            added=datetime.now(timezone.utc),
            updated=datetime.now(timezone.utc)
        )

        logger.info(f"About to reset the password**********")
        try:
            db.session.add(pass_reset)
            db.session.flush()
            logger.info(f"After Insert to reset the password**********")
        except IntegrityError as err:
            raise ValueError(f"****** ERROR Database integrity error: {err}")
        return pass_reset



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


# ''''
# merms_panel=# \d password_reset
#                                        Table "public.password_reset"
#   Column  |            Type             | Collation | Nullable |                  Default
# ----------+-----------------------------+-----------+----------+--------------------------------------------
#  id       | integer                     |           | not null | nextval('password_reset_id_seq'::regclass)
#  uid      | uuid                        |           |          | uuid_generate_v4()
#  username | character varying(35)       |           | not null |
#  status   | integer                     |           |          | 0
#  added    | timestamp without time zone |           |          | now()
#  updated  | timestamp without time zone |           |          | now()
# Indexes:
#     "password_reset_id_key" UNIQUE CONSTRAINT, btree (id)
#
# '''