from sqlmodel import Session, SQLModel, create_engine, select

from app.config import settings

engine = create_engine(
    settings.database_url,
    echo=True,
    connect_args={"check_same_thread": False},
)


def create_database():
    SQLModel.metadata.create_all(engine)


def add_to_database(input: SQLModel):
    with Session(engine) as session:
        session.add(input)
        session.commit()


def get_from_database(query: type[SQLModel]):
    with Session(engine) as session:
        results = session.exec(select(query)).all()
    return results


def get_from_database_where(
    query: type[SQLModel],
    variable: object,
    value: int | str | None,
    first_only: bool = False,
    offset: int | None = None,
    limit: int | None = None,
):
    with Session(engine) as session:
        statement = select(query).where(variable == value)
        if offset:
            statement = statement.offset(offset)
        if limit:
            statement = statement.limit(limit)
        results = session.exec(statement)
        if first_only:
            results = results.first()
        else:
            results = results.all()
    return results


def get_from_database_where_id(
    query: type[SQLModel],
    value: int,
) -> SQLModel | None:
    with Session(engine) as session:
        result = session.get(query, value)
    return result


def get_from_database_where_join_filter(
    query: type[SQLModel],
    joined: type[SQLModel],
    variable: object,
    value: int | str | None,
):
    with Session(engine) as session:
        results = session.exec(select(query).join(joined).where(variable == value))
    return results


def get_and_join_from_database(
    query: type[SQLModel],
    joined: type[SQLModel],
    isouter: bool = False,
):
    with Session(engine) as session:
        results = session.exec(select(query, joined).join(joined, isouter=isouter))
    return results


def update_database_where(
    query: type[SQLModel],
    variable: object,
    value: int | str | None,
    attribute: str,
    new_value: int | str | None,
):
    with Session(engine) as session:
        results = list(session.exec(select(query).where(variable == value)))

        for instance in results:
            setattr(instance, attribute, new_value)
            session.add(instance)

        session.commit()

        for instance in results:
            session.refresh(instance)
    return results


def delete_from_database_where(
    query: type[SQLModel],
    variable: object,
    value: str | int | None,
):
    with Session(engine) as session:
        results = session.exec(select(query).where(variable == value))

        for instance in results:
            session.delete(instance)
            session.commit()

        remainder = session.exec(select(query).where(variable == value)).all()
    return remainder