from typing import Type, TypeVar

from sqlalchemy.exc import SQLAlchemyError
from sqlalchemy.orm import Session
from ApiLibrary import get_line_number_for_error
from ErrorHandlers.Exceptions.api_exc import HTTPExceptionApi

# Type variable for class methods returning self
T = TypeVar("T", bound="FilterAttributes")


class BaseAlchemyModel:
    """
    Controller of alchemy to database transactions.
    Query: Query object for model
    Session: Session object for model
    Actions: save, flush, rollback, commit
    """

    __abstract__ = True

    @classmethod
    def new_session(cls) -> Session:
        """Get database session."""
        from Services.PostgresDb.database import get_db

        with get_db() as session:
            return session

    @classmethod
    def flush(cls: Type[T], db: Session) -> T:
        """
        Flush the current session to the database.

        Args:
            db: Database session

        Returns:
            Self instance

        Raises:
            HTTPException: If database operation fails
        """
        try:
            db.flush()
            return cls
        except SQLAlchemyError as e:
            raise HTTPExceptionApi(
                error_code="HTTP_304_NOT_MODIFIED",
                lang=cls.lang or "tr",
                loc=get_line_number_for_error(),
                sys_msg=str(e),
            )

    def destroy(self: Type[T], db: Session) -> None:
        """
        Delete the record from the database.

        Args:
            db: Database session
        """
        db.delete(self)

    @classmethod
    def save_via_metadata(cls: Type[T], db: Session) -> None:
        """
        Save or rollback based on metadata.

        Args:
            db: Database session

        Raises:
            HTTPException: If save operation fails
        """
        try:
            if cls.is_created:
                db.commit()
                db.flush()
            db.rollback()
        except SQLAlchemyError as e:
            raise HTTPExceptionApi(
                error_code="HTTP_304_NOT_MODIFIED",
                lang=cls.lang or "tr",
                loc=get_line_number_for_error(),
                sys_msg=str(e),
            )

    @classmethod
    def save(cls: Type[T], db: Session) -> None:
        """
        Commit changes to database.

        Args:
            db: Database session

        Raises:
            HTTPException: If commit fails
        """
        try:
            db.commit()
        except SQLAlchemyError as e:
            raise HTTPExceptionApi(
                error_code="HTTP_304_NOT_MODIFIED",
                lang=cls.lang or "tr",
                loc=get_line_number_for_error(),
                sys_msg=str(e),
            )
        except Exception as e:
            raise HTTPExceptionApi(
                error_code="HTTP_500_INTERNAL_SERVER_ERROR",
                lang=cls.lang or "tr",
                loc=get_line_number_for_error(),
                sys_msg=str(e),
            )

    @classmethod
    def save_and_confirm(cls: Type[T], db: Session) -> None:
        """
        Save changes and mark record as confirmed.

        Args:
            db: Database session

        Raises:
            HTTPException: If operation fails
        """
        try:
            cls.save(db)
            cls.update(db, is_confirmed=True)
            cls.save(db)
        except SQLAlchemyError as e:
            raise HTTPExceptionApi(
                error_code="HTTP_304_NOT_MODIFIED",
                lang=cls.lang or "tr",
                loc=get_line_number_for_error(),
                sys_msg=str(e),
            )

    @classmethod
    def rollback(cls: Type[T], db: Session) -> None:
        """
        Rollback current transaction.

        Args:
            db: Database session
        """
        db.rollback()