from sqlalchemy import select
from sqlalchemy.orm import Session

from backend.app.models.system import Menu, Role, User


class SystemRepository:
    def get_user_by_username(self, session: Session, username: str) -> User | None:
        stmt = select(User).where(User.username == username)
        return session.execute(stmt).scalar_one_or_none()

    def get_user(self, session: Session, user_id: int) -> User | None:
        stmt = select(User).where(User.id == user_id)
        return session.execute(stmt).scalar_one_or_none()

    def create_user(self, session: Session, payload: dict) -> User:
        user = User(
            username=payload["username"],
            password_hash=payload["password_hash"],
            real_name=payload["real_name"],
            mobile=payload.get("mobile") or "",
            role_id=payload["role_id"],
            status=payload.get("status", 1),
        )
        session.add(user)
        session.flush()
        return user

    def update_user(self, user: User, payload: dict) -> User:
        user.real_name = payload["real_name"]
        user.mobile = payload.get("mobile") or ""
        user.role_id = payload["role_id"]
        user.status = payload.get("status", 1)
        return user

    def reset_password(self, user: User, password_hash: str) -> User:
        user.password_hash = password_hash
        return user

    def get_role(self, session: Session, role_id: int) -> Role | None:
        stmt = select(Role).where(Role.id == role_id)
        return session.execute(stmt).scalar_one_or_none()

    def get_role_by_code(self, session: Session, role_code: str) -> Role | None:
        stmt = select(Role).where(Role.role_code == role_code)
        return session.execute(stmt).scalar_one_or_none()

    def create_role(self, session: Session, payload: dict) -> Role:
        role = Role(
            role_name=payload["role_name"],
            role_code=payload["role_code"],
            status=payload.get("status", 1),
            remark=payload.get("remark"),
        )
        session.add(role)
        session.flush()
        return role

    def update_role(self, role: Role, payload: dict) -> Role:
        role.role_name = payload["role_name"]
        role.status = payload.get("status", 1)
        role.remark = payload.get("remark")
        return role

    def get_menu(self, session: Session, menu_id: int) -> Menu | None:
        stmt = select(Menu).where(Menu.id == menu_id)
        return session.execute(stmt).scalar_one_or_none()

    def get_menu_by_permission_code(self, session: Session, permission_code: str) -> Menu | None:
        stmt = select(Menu).where(Menu.permission_code == permission_code)
        return session.execute(stmt).scalar_one_or_none()

    def create_menu(self, session: Session, payload: dict) -> Menu:
        menu = Menu(
            parent_id=payload.get("parent_id", 0),
            menu_name=payload["menu_name"],
            menu_path=payload.get("menu_path") or "",
            menu_type=payload.get("menu_type", "page"),
            permission_code=payload["permission_code"],
            icon=payload.get("icon"),
            sort_no=payload.get("sort_no", 0),
            status=payload.get("status", 1),
        )
        session.add(menu)
        session.flush()
        return menu

    def update_menu(self, menu: Menu, payload: dict) -> Menu:
        menu.parent_id = payload.get("parent_id", 0)
        menu.menu_name = payload["menu_name"]
        menu.menu_path = payload.get("menu_path") or ""
        menu.menu_type = payload.get("menu_type", "page")
        menu.permission_code = payload["permission_code"]
        menu.icon = payload.get("icon")
        menu.sort_no = payload.get("sort_no", 0)
        menu.status = payload.get("status", 1)
        return menu

    def list_users(self, session: Session, filters: dict) -> list[tuple[User, Role | None]]:
        stmt = select(User, Role).outerjoin(Role, User.role_id == Role.id)

        if filters.get("username"):
            stmt = stmt.where(User.username.contains(filters["username"]))
        if filters.get("real_name"):
            stmt = stmt.where(User.real_name.contains(filters["real_name"]))
        if filters.get("mobile"):
            stmt = stmt.where(User.mobile.contains(filters["mobile"]))
        if filters.get("role_id") is not None:
            stmt = stmt.where(User.role_id == filters["role_id"])
        if filters.get("status") is not None:
            stmt = stmt.where(User.status == filters["status"])

        stmt = stmt.order_by(User.id.asc())
        return list(session.execute(stmt).all())

    def list_roles(self, session: Session, filters: dict) -> list[Role]:
        stmt = select(Role)

        if filters.get("role_name"):
            stmt = stmt.where(Role.role_name.contains(filters["role_name"]))
        if filters.get("role_code"):
            stmt = stmt.where(Role.role_code.contains(filters["role_code"]))
        if filters.get("status") is not None:
            stmt = stmt.where(Role.status == filters["status"])

        stmt = stmt.order_by(Role.id.asc())
        return list(session.execute(stmt).scalars())

    def count_active_users_by_role(self, session: Session, role_id: int) -> int:
        stmt = select(User).where(User.role_id == role_id, User.status == 1)
        return len(list(session.execute(stmt).scalars()))

    def list_menus(self, session: Session, filters: dict) -> list[Menu]:
        stmt = select(Menu)

        if filters.get("status") is not None:
            stmt = stmt.where(Menu.status == filters["status"])
        if filters.get("menu_type"):
            stmt = stmt.where(Menu.menu_type == filters["menu_type"])

        stmt = stmt.order_by(Menu.sort_no.asc(), Menu.id.asc())
        return list(session.execute(stmt).scalars())