from uuid import UUID
from typing import Optional
from app.modules.auth.domain.entities import User

class UserRepository:
    def __init__(self, conn):
        self._conn = conn

    def ensure_schema(self):
        with self._conn.cursor() as cur:
            cur.execute("""
                CREATE SCHEMA IF NOT EXISTS auth;
                CREATE TABLE IF NOT EXISTS auth.users (
                    id UUID PRIMARY KEY,
                    username TEXT NOT NULL UNIQUE,
                    email TEXT NOT NULL UNIQUE,
                    hashed_password TEXT NOT NULL,
                    is_active BOOLEAN DEFAULT TRUE,
                    role TEXT NOT NULL,
                    created_at TIMESTAMP WITH TIME ZONE
                );
            """)

    def save(self, user: User) -> None:
        self.ensure_schema()
        with self._conn.cursor() as cur:
            cur.execute("""
                INSERT INTO auth.users 
                (id, username, email, hashed_password, is_active, role, created_at)
                VALUES (%s, %s, %s, %s, %s, %s, %s)
                ON CONFLICT (id) DO UPDATE SET
                    username = EXCLUDED.username,
                    email = EXCLUDED.email,
                    hashed_password = EXCLUDED.hashed_password,
                    is_active = EXCLUDED.is_active,
                    role = EXCLUDED.role;
            """, (
                str(user.id),
                user.username,
                user.email,
                user.hashed_password,
                user.is_active,
                user.role,
                user.created_at
            ))

    def get_by_username(self, username: str) -> Optional[User]:
        with self._conn.cursor() as cur:
            cur.execute("SELECT * FROM auth.users WHERE username = %s", (username,))
            row = cur.fetchone()
            if row:
                return User(**row)
        return None