# app/core/security.py
import bcrypt


def hash_password(plain_password: str) -> str:
    """
    Хешує пароль за допомогою bcrypt з автоматично згенерованою сіллю.
    Пароль попередньо обрізається до 72 байтів (ліміт алгоритму bcrypt).

    Args:
        plain_password: Пароль у відкритому вигляді.

    Returns:
        Рядок хешу, що містить версію, work factor (rounds), salt та сам хеш.
        Приклад: "$2b$12$..."
    """
    # Обрізаємо пароль до 72 байтів для запобігання ValueError
    pwd_bytes = plain_password.encode("utf-8")[:72]
    
    # Генеруємо сіль із рекомендованим work factor (rounds=12)
    salt = bcrypt.gensalt(rounds=12)
    
    # Хешуємо та декодуємо результат у рядок UTF-8
    return bcrypt.hashpw(pwd_bytes, salt).decode("utf-8")


def verify_password(plain_password: str, hashed_password: str) -> bool:
    """
    Перевіряє відповідність пароля збереженому хешу.

    Args:
        plain_password: Пароль у відкритому вигляді (від користувача).
        hashed_password: Хеш із бази даних.

    Returns:
        True, якщо пароль відповідає хешу. False — інакше.
    """
    pwd_bytes = plain_password.encode("utf-8")[:72]
    hashed_bytes = hashed_password.encode("utf-8")
    
    return bcrypt.checkpw(pwd_bytes, hashed_bytes)

$2b$12$EixZaYVK1fsbw1ZfbX3OXePaWxn96p36WQoeG6Lruj3vjPGga31lW

# Альтернативна реалізація через argon2-cffi
from argon2 import PasswordHasher
from argon2.exceptions import VerifyMismatchError

# PasswordHasher з параметрами за замовчуванням OWASP
ph = PasswordHasher(
    time_cost=2,       # кількість ітерацій
    memory_cost=65536, # 64 MB пам'яті (захист від GPU)
    parallelism=2,     # паралельні потоки
    hash_len=32,       # довжина хешу в байтах
    salt_len=16,       # довжина salt
)

hashed = ph.hash("mysecretpassword")

try:
    ph.verify(hashed, "mysecretpassword")  # True або виняток
    # Перевірка чи потрібне перехешування
    if ph.check_needs_rehash(hashed):
        new_hash = ph.hash("mysecretpassword")
        # Зберегти new_hash у БД
except VerifyMismatchError:
    # Неправильний пароль
    pass

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

HEADER          PAYLOAD              SIGNATURE
eyJhbGci...  .  eyJzdWIiOiIx...  .  SflKxwRJSM...

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9
.eyJzdWIiOiJ1c2VyLTEyMyIsInR5cGUiOiJyZWZyZXNoIiwiZXhwIjoxNzIwMjU5MjAwfQ
.signature

import secrets

# Генерація: 32 байти = 64 символи hex = 256 біт ентропії
refresh_token = secrets.token_urlsafe(32)
# Наприклад: "bX3R9qKm7Vn2pL8sA1jD5cW4uY6oE0tF"

CREATE TABLE refresh_tokens (
    id          UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    token_hash  TEXT NOT NULL UNIQUE,  -- bcrypt або sha256 від токена
    user_id     UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
    expires_at  TIMESTAMPTZ NOT NULL,
    created_at  TIMESTAMPTZ NOT NULL DEFAULT NOW(),
    revoked_at  TIMESTAMPTZ,           -- для м'якого відкликання
    user_agent  TEXT,                  -- для аудиту: який браузер/пристрій
    ip_address  INET                   -- для аудиту
);

# app/core/security.py
import bcrypt
import hashlib
import secrets
from datetime import datetime, timedelta, timezone
from typing import Any

from jose import jwt, JWTError, ExpiredSignatureError

from app.core.config import settings  # pydantic Settings

# ─── Хешування паролів ────────────────────────────────────────────────────────
def hash_password(plain_password: str) -> str:
    pwd_bytes = plain_password.encode("utf-8")[:72]
    salt = bcrypt.gensalt()
    return bcrypt.hashpw(pwd_bytes, salt).decode("utf-8")


def verify_password(plain_password: str, hashed_password: str) -> bool:
    pwd_bytes = plain_password.encode("utf-8")[:72]
    return bcrypt.checkpw(pwd_bytes, hashed_password.encode("utf-8"))


# ─── Access JWT-токен ─────────────────────────────────────────────────────────
def create_access_token(
    subject: str | Any,
    extra_claims: dict | None = None,
) -> str:
    """
    Створює короткоживучий Access JWT-токен.

    Args:
        subject: Ідентифікатор суб'єкта (зазвичай user UUID або ID).
                 Буде збережений у claim 'sub'.
        extra_claims: Додаткові claims для вбудовування у payload
                      (наприклад, {'email': '...', 'role': 'admin'}).

    Returns:
        Підписаний JWT-рядок у форматі header.payload.signature.
    """
    now = datetime.now(timezone.utc)
    expire = now + timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)

    payload = {
        "sub": str(subject),
        "iat": now,
        "exp": expire,
        "type": "access",  # захист від підміни: access token ≠ refresh token
    }
    if extra_claims:
        payload.update(extra_claims)

    return jwt.encode(payload, settings.SECRET_KEY, algorithm=settings.ALGORITHM)


def decode_access_token(token: str) -> dict:
    """
    Верифікує підпис Access JWT та повертає розкодований payload.

    Args:
        token: JWT-рядок.

    Returns:
        Словник з claims токена.

    Raises:
        ExpiredSignatureError: Токен протух (exp у минулому).
        JWTError: Невалідний підпис або формат токена.
    """
    return jwt.decode(
        token,
        settings.SECRET_KEY,
        algorithms=[settings.ALGORITHM],
    )


# ─── Opaque Refresh Token ─────────────────────────────────────────────────────
def generate_refresh_token() -> str:
    """
    Генерує криптографічно безпечний opaque refresh token.

    Refresh token — це просто випадковий рядок з 256 бітами ентропії.
    Він НЕ є JWT і не містить жодних вбудованих даних.
    Вся інформація про токен зберігається в таблиці refresh_tokens у БД.

    Returns:
        URL-safe рядок з 43 символів (32 байти → base64url без padding).
        Наприклад: "bX3R9qKm7Vn2pL8sA1jD5cW4uY6oE0tF_kzQwPn1pI"
    """
    return secrets.token_urlsafe(32)


def hash_refresh_token(token: str) -> str:
    """
    Повертає SHA-256 хеш refresh token для зберігання у БД.

    Чому SHA-256, а не bcrypt?
    - Refresh token вже має 256 біт ентропії (випадковий) —
      rainbow table атаки принципово неможливі без знання токена.
    - bcrypt навмисно повільний (~160 мс) — це зайво для lookup-операцій
      у БД при кожному запиті refresh.
    - SHA-256 тут достатньо: він захищає від витоку хешів з БД,
      оскільки зворотно обчислити випадковий 256-бітний рядок — нереально.

    Args:
        token: Оригінальний refresh token у відкритому вигляді.

    Returns:
        HEX-рядок SHA-256 хешу (64 символи).
    """
    return hashlib.sha256(token.encode()).hexdigest()


def verify_refresh_token(plain_token: str, stored_hash: str) -> bool:
    """
    Перевіряє відповідність refresh token збереженому SHA-256 хешу.

    Використовує secrets.compare_digest для захисту від timing attacks
    (атака за часом виконання порівняння рядків).

    Args:
        plain_token: Токен у відкритому вигляді (від клієнта).
        stored_hash: SHA-256 хеш з бази даних.

    Returns:
        True якщо токен відповідає хешу, False — інакше.
    """
    expected_hash = hash_refresh_token(plain_token)
    # secrets.compare_digest — постійний час порівняння, незалежно від відповіді
    return secrets.compare_digest(expected_hash, stored_hash)

# app/core/config.py
from pydantic_settings import BaseSettings


class Settings(BaseSettings):
    # JWT (лише для Access Token)
    SECRET_KEY: str           # мінімум 32 байти, генерується: openssl rand -hex 32
    ALGORITHM: str = "HS256"
    ACCESS_TOKEN_EXPIRE_MINUTES: int = 15

    # Opaque Refresh Token (зберігається у БД)
    REFRESH_TOKEN_EXPIRE_DAYS: int = 30

    class Config:
        env_file = ".env"


settings = Settings()

# app/api/deps.py
from fastapi import Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer
from jose import JWTError, ExpiredSignatureError
from sqlalchemy.ext.asyncio import AsyncSession

from app.core.security import decode_access_token
from app.db.session import get_db
from app.models.user import User
from app.repositories.user import UserRepository

# Один екземпляр на рівні модуля — токен береться з цього URL у Swagger
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/api/v1/auth/login")


async def get_current_user(
    token: str = Depends(oauth2_scheme),
    db: AsyncSession = Depends(get_db),
) -> User:
    """
    Витягує та верифікує поточного користувача з JWT access token.

    Dependency-функція першого рівня: перевіряє підпис токена
    та завантажує User з бази даних.

    Args:
        token: JWT-рядок, автоматично витягнутий OAuth2PasswordBearer
               з заголовка Authorization: Bearer <token>.
        db: Сесія бази даних (async SQLAlchemy).

    Returns:
        Об'єкт User з бази даних.

    Raises:
        401 Unauthorized: Токен невалідний, протух або користувача не знайдено.
    """
    credentials_exception = HTTPException(
        status_code=status.HTTP_401_UNAUTHORIZED,
        detail="Could not validate credentials",
        headers={"WWW-Authenticate": "Bearer"},  # стандарт OAuth2
    )

    try:
        payload = decode_access_token(token)

        # Захист від підміни типу токена
        if payload.get("type") != "access":
            raise credentials_exception

        user_id: str | None = payload.get("sub")
        if user_id is None:
            raise credentials_exception

    except ExpiredSignatureError:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Token has expired",
            headers={"WWW-Authenticate": "Bearer"},
        )
    except JWTError:
        raise credentials_exception

    user_repo = UserRepository(db)
    user = await user_repo.get_by_id(user_id)

    if user is None:
        raise credentials_exception

    return user


async def get_current_active_user(
    current_user: User = Depends(get_current_user),
) -> User:
    """
    Перевіряє, що поточний користувач є активним (не заблокованим).

    Dependency-функція другого рівня: надбудова над get_current_user.
    Використовуйте цю залежність для більшості захищених ендпоінтів.

    Args:
        current_user: Об'єкт User від залежності get_current_user.

    Returns:
        Той самий User, якщо він активний.

    Raises:
        403 Forbidden: Акаунт деактивований.
    """
    if not current_user.is_active:
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN,
            detail="Inactive user account",
        )
    return current_user

# app/api/v1/projects.py
from fastapi import APIRouter, Depends
from app.api.deps import get_current_active_user
from app.models.user import User

router = APIRouter()


@router.get("/projects")
async def list_projects(
    current_user: User = Depends(get_current_active_user),
    # ...
):
    """Повертає список проєктів поточного користувача."""
    ...


@router.post("/projects")
async def create_project(
    current_user: User = Depends(get_current_active_user),
    # ...
):
    ...

# app/api/v1/auth.py
import secrets
from datetime import datetime, timezone, timedelta

from fastapi import APIRouter, Depends, HTTPException, status
from fastapi.security import OAuth2PasswordRequestForm
from sqlalchemy.ext.asyncio import AsyncSession

from app.core.security import (
    hash_password,
    verify_password,
    create_access_token,
    generate_refresh_token,
    hash_refresh_token,
    verify_refresh_token,
)
from app.core.config import settings
from app.db.session import get_db
from app.models.user import User
from app.models.refresh_token import RefreshToken
from app.repositories.user import UserRepository
from app.repositories.refresh_token import RefreshTokenRepository
from app.schemas.auth import (
    UserRegisterRequest,
    TokenResponse,
    RefreshRequest,
)

router = APIRouter(prefix="/auth", tags=["auth"])


@router.post("/register", response_model=TokenResponse, status_code=status.HTTP_201_CREATED)
async def register(
    data: UserRegisterRequest,
    db: AsyncSession = Depends(get_db),
) -> TokenResponse:
    """
    Реєстрація нового користувача.

    Хешує пароль, створює User у БД, одразу видає токени
    (без окремого кроку логіну після реєстрації).
    """
    user_repo = UserRepository(db)
    token_repo = RefreshTokenRepository(db)

    # Перевірка унікальності email
    if await user_repo.get_by_email(data.email):
        raise HTTPException(
            status_code=status.HTTP_409_CONFLICT,
            detail="User with this email already exists",
        )

    # Створення користувача
    user = User(
        email=data.email,
        display_name=data.display_name,
        hashed_password=hash_password(data.password),
    )
    await user_repo.create(user)

    # Видача токенів
    access_token = create_access_token(subject=str(user.id))
    plain_refresh_token = generate_refresh_token()

    await token_repo.create(RefreshToken(
        token_hash=hash_refresh_token(plain_refresh_token),
        user_id=user.id,
        expires_at=datetime.now(timezone.utc) + timedelta(days=settings.REFRESH_TOKEN_EXPIRE_DAYS),
    ))

    return TokenResponse(
        access_token=access_token,
        refresh_token=plain_refresh_token,
        token_type="bearer",
    )


@router.post("/login", response_model=TokenResponse)
async def login(
    form_data: OAuth2PasswordRequestForm = Depends(),
    db: AsyncSession = Depends(get_db),
) -> TokenResponse:
    """
    Логін через OAuth2 Password Flow.

    Приймає form-data (application/x-www-form-urlencoded),
    а не JSON — це вимога OAuth2 специфікації.
    Поле 'username' тут використовується як email.
    """
    user_repo = UserRepository(db)
    token_repo = RefreshTokenRepository(db)

    # Знаходимо користувача (form_data.username — це email)
    user = await user_repo.get_by_email(form_data.username)

    # Перевіряємо credentials. Завжди виконуємо verify_password,
    # навіть якщо user == None, щоб уникнути timing attack
    # (різний час відповіді міг би видати факт існування акаунта)
    if not user or not verify_password(form_data.password, user.hashed_password):
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Incorrect email or password",
            headers={"WWW-Authenticate": "Bearer"},
        )

    if not user.is_active:
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN,
            detail="Account is deactivated",
        )

    # Видача токенів
    access_token = create_access_token(subject=str(user.id))
    plain_refresh_token = generate_refresh_token()

    await token_repo.create(RefreshToken(
        token_hash=hash_refresh_token(plain_refresh_token),
        user_id=user.id,
        expires_at=datetime.now(timezone.utc) + timedelta(days=settings.REFRESH_TOKEN_EXPIRE_DAYS),
    ))

    return TokenResponse(
        access_token=access_token,
        refresh_token=plain_refresh_token,
        token_type="bearer",
    )


@router.post("/refresh", response_model=TokenResponse)
async def refresh_tokens(
    body: RefreshRequest,
    db: AsyncSession = Depends(get_db),
) -> TokenResponse:
    """
    Оновлення пари токенів через opaque refresh token.

    Реалізує ротацію: старий refresh token знищується,
    видається новий. Якщо token вже використаний (не знайдений у БД) —
    це сигнал крадіжки: відкликаємо ВСІ сесії користувача.
    """
    token_repo = RefreshTokenRepository(db)

    # Шукаємо токен у БД за SHA-256 хешем
    stored_token = await token_repo.get_by_hash(hash_refresh_token(body.refresh_token))

    if not stored_token or stored_token.expires_at < datetime.now(timezone.utc):
        # Токен не знайдений або протух
        # Якщо не знайдений — можлива ротаційна атака.
        # Для простоти тут повертаємо 401; у production — додаткова логіка.
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Invalid or expired refresh token",
        )

    user_id = stored_token.user_id

    # Ротація: видаляємо старий токен
    await token_repo.delete(stored_token.id)

    # Видаємо нові токени
    access_token = create_access_token(subject=str(user_id))
    plain_refresh_token = generate_refresh_token()

    await token_repo.create(RefreshToken(
        token_hash=hash_refresh_token(plain_refresh_token),
        user_id=user_id,
        expires_at=datetime.now(timezone.utc) + timedelta(days=settings.REFRESH_TOKEN_EXPIRE_DAYS),
    ))

    return TokenResponse(
        access_token=access_token,
        refresh_token=plain_refresh_token,
        token_type="bearer",
    )


@router.post("/logout", status_code=status.HTTP_204_NO_CONTENT)
async def logout(
    body: RefreshRequest,
    db: AsyncSession = Depends(get_db),
) -> None:
    """
    Логаут: відкликає refresh token.

    Access token залишається дійсним до закінчення exp (15 хв).
    Це прийнятний trade-off для stateless JWT.
    """
    token_repo = RefreshTokenRepository(db)
    stored_token = await token_repo.get_by_hash(hash_refresh_token(body.refresh_token))
    if stored_token:
        await token_repo.delete(stored_token.id)

taskforge/
├── .env
├── create_tables.py
└── app/
    ├── main.py
    ├── core/
    │   ├── config.py
    │   └── security.py
    ├── db/
    │   └── session.py
    ├── models/
    │   ├── base.py
    │   ├── user.py
    │   └── refresh_token.py
    ├── schemas/
    │   └── auth.py
    ├── repositories/
    │   ├── user.py
    │   └── refresh_token.py
    └── api/
        ├── deps.py
        └── v1/
            └── auth.py

# app/models/role.py
from enum import Enum


class UserRole(str, Enum):
    """
    Ролі користувачів TaskForge.

    Успадкування від str критично важливе:
    - SQLAlchemy зберігає рядок ("user", "admin"), а не "UserRole.ADMIN"
    - Pydantic коректно серіалізує у JSON без додаткових налаштувань
    - Порівняння UserRole.ADMIN == "admin" -> True (завдяки str-наслідуванню)
    """
    USER = "user"         # звичайний користувач: власні проєкти та задачі
    MANAGER = "manager"   # менеджер: управління командою, перегляд звітів
    ADMIN = "admin"       # адміністратор: повний доступ, управління акаунтами

# app/models/user.py
import uuid

from sqlalchemy import Boolean, String
from sqlalchemy.dialects.postgresql import UUID
from sqlalchemy.orm import Mapped, mapped_column, relationship

from app.models.base import Base
from app.models.role import UserRole


class User(Base):
    __tablename__ = "users"

    id: Mapped[uuid.UUID] = mapped_column(
        UUID(as_uuid=True), primary_key=True, default=uuid.uuid4
    )
    email: Mapped[str] = mapped_column(String(255), unique=True, nullable=False, index=True)
    display_name: Mapped[str] = mapped_column(String(100), nullable=False)
    hashed_password: Mapped[str] = mapped_column(String(60), nullable=False)
    is_active: Mapped[bool] = mapped_column(Boolean, default=True, nullable=False)

    # Роль зберігається як VARCHAR — str-значення enum ("user", "manager", "admin")
    role: Mapped[UserRole] = mapped_column(
        String(20),
        default=UserRole.USER,
        nullable=False,
    )

    refresh_tokens: Mapped[list["RefreshToken"]] = relationship(  # type: ignore[name-defined]
        "RefreshToken", back_populates="user", cascade="all, delete-orphan"
    )

# app/api/deps.py — повна версія з підтримкою ролей
from collections.abc import Callable

from fastapi import Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer
from jose import ExpiredSignatureError, JWTError
from sqlalchemy.ext.asyncio import AsyncSession

from app.core.security import decode_access_token
from app.db.session import get_db
from app.models.role import UserRole
from app.models.user import User
from app.repositories.user import UserRepository

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/api/v1/auth/login")


async def get_current_user(
    token: str = Depends(oauth2_scheme),
    db: AsyncSession = Depends(get_db),
) -> User:
    """Dependency (рівень 1): перевіряє JWT та завантажує User з БД."""
    unauthorized = HTTPException(
        status_code=status.HTTP_401_UNAUTHORIZED,
        detail="Could not validate credentials",
        headers={"WWW-Authenticate": "Bearer"},
    )
    try:
        payload = decode_access_token(token)
        if payload.get("type") != "access":
            raise unauthorized
        user_id: str | None = payload.get("sub")
        if user_id is None:
            raise unauthorized
    except ExpiredSignatureError:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Token has expired",
            headers={"WWW-Authenticate": "Bearer"},
        )
    except JWTError:
        raise unauthorized

    user = await UserRepository(db).get_by_id(user_id)
    if user is None:
        raise unauthorized
    return user


async def get_current_active_user(
    current_user: User = Depends(get_current_user),
) -> User:
    """Dependency (рівень 2): перевіряє is_active."""
    if not current_user.is_active:
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN,
            detail="Inactive user account",
        )
    return current_user


def require_roles(*roles: UserRole) -> Callable:
    """
    Dependency-фабрика для перевірки ролей.

    Приймає одну або кілька дозволених ролей та повертає
    dependency-функцію, яку FastAPI вбудовує у граф залежностей.

    Args:
        *roles: Перелік дозволених UserRole значень.

    Returns:
        Async dependency-функція -> User або 403 Forbidden.

    Використання:
        # Лише адміністратор:
        Depends(require_roles(UserRole.ADMIN))

        # Адміністратор або менеджер:
        Depends(require_roles(UserRole.ADMIN, UserRole.MANAGER))
    """
    allowed = set(roles)

    async def role_checker(
        current_user: User = Depends(get_current_active_user),
    ) -> User:
        if current_user.role not in allowed:
            raise HTTPException(
                status_code=status.HTTP_403_FORBIDDEN,
                detail=f"Access denied. Required roles: {[r.value for r in allowed]}",
            )
        return current_user

    return role_checker

# app/api/v1/admin.py
import uuid

from fastapi import APIRouter, Depends, HTTPException, status
from pydantic import BaseModel, EmailStr
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession

from app.api.deps import require_roles
from app.db.session import get_db
from app.models.role import UserRole
from app.models.user import User

router = APIRouter(prefix="/admin", tags=["Administration"])

# Alias для зручності — щоб не дублювати require_roles(UserRole.ADMIN) скрізь
AdminOnly = Depends(require_roles(UserRole.ADMIN))


# ─── Pydantic схеми ───────────────────────────────────────────────────────────
class UserListResponse(BaseModel):
    id: uuid.UUID
    email: EmailStr
    display_name: str
    role: UserRole
    is_active: bool

    model_config = {"from_attributes": True}


class UserRoleUpdateRequest(BaseModel):
    role: UserRole


# ─── Ендпоінти ────────────────────────────────────────────────────────────────
@router.get("/users", response_model=list[UserListResponse])
async def list_all_users(
    current_user: User = AdminOnly,
    db: AsyncSession = Depends(get_db),
) -> list[User]:
    """Повертає список усіх користувачів. Тільки для адміністраторів."""
    result = await db.execute(select(User).order_by(User.email))
    return list(result.scalars().all())


@router.patch("/users/{user_id}/role", response_model=UserListResponse)
async def update_user_role(
    user_id: uuid.UUID,
    body: UserRoleUpdateRequest,
    current_user: User = AdminOnly,
    db: AsyncSession = Depends(get_db),
) -> User:
    """Змінює роль. Адмін не може змінити власну роль."""
    target = await db.get(User, user_id)
    if target is None:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="User not found")
    if target.id == current_user.id:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail="Cannot change your own role",
        )
    target.role = body.role
    await db.commit()
    await db.refresh(target)
    return target


@router.patch("/users/{user_id}/deactivate", status_code=status.HTTP_204_NO_CONTENT)
async def deactivate_user(
    user_id: uuid.UUID,
    current_user: User = AdminOnly,
    db: AsyncSession = Depends(get_db),
) -> None:
    """Деактивує акаунт. Адмін не може деактивувати себе."""
    target = await db.get(User, user_id)
    if target is None:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="User not found")
    if target.id == current_user.id:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail="Cannot deactivate your own account",
        )
    target.is_active = False
    await db.commit()


@router.get("/reports/summary")
async def reports_summary(
    # Менеджери та адміністратори мають доступ до звітів
    current_user: User = Depends(require_roles(UserRole.ADMIN, UserRole.MANAGER)),
    db: AsyncSession = Depends(get_db),
) -> dict:
    """Зведений звіт. Доступний менеджерам та адміністраторам."""
    result = await db.execute(select(User))
    users = result.scalars().all()
    return {
        "total_users": len(users),
        "active_users": sum(1 for u in users if u.is_active),
        "admins": sum(1 for u in users if u.role == UserRole.ADMIN),
        "managers": sum(1 for u in users if u.role == UserRole.MANAGER),
        "requested_by": current_user.email,
    }

# app/main.py
from fastapi import FastAPI

from app.api.v1 import admin, auth

app = FastAPI(
    title="TaskForge API",
    description="Project management API — JWT + Opaque Refresh Token + RBAC",
    version="0.1.0",
)

app.include_router(auth.router, prefix="/api/v1")
app.include_router(admin.router, prefix="/api/v1")


@app.get("/health", tags=["System"])
async def health_check() -> dict:
    return {"status": "ok"}

# У register() та login() — додаємо роль у extra_claims:
access_token = create_access_token(
    subject=str(user.id),
    extra_claims={"role": user.role.value},  # "user" / "manager" / "admin"
)

# app/models/api_key.py
import uuid
from datetime import datetime

from sqlalchemy import Boolean, DateTime, ForeignKey, String, Text
from sqlalchemy.dialects.postgresql import UUID
from sqlalchemy.orm import Mapped, mapped_column, relationship

from app.models.base import Base


class ApiKey(Base):
    __tablename__ = "api_keys"

    id: Mapped[uuid.UUID] = mapped_column(
        UUID(as_uuid=True), primary_key=True, default=uuid.uuid4
    )
    # SHA-256 хеш API Key — лише для lookup, не зберігаємо відкрито
    key_hash: Mapped[str] = mapped_column(String(64), unique=True, nullable=False, index=True)
    # Prefix для ідентифікації у логах (перші 8 символів ключа): "tf_live_bX3R9qKm..."
    key_prefix: Mapped[str] = mapped_column(String(16), nullable=False)

    name: Mapped[str] = mapped_column(String(100), nullable=False)  # опис: "CI/CD pipeline"
    user_id: Mapped[uuid.UUID] = mapped_column(
        UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), nullable=False
    )
    is_active: Mapped[bool] = mapped_column(Boolean, default=True, nullable=False)
    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
    last_used_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)

    user: Mapped["User"] = relationship("User")  # type: ignore[name-defined]

# app/repositories/api_key.py
import hashlib
import secrets
import uuid
from datetime import datetime, timezone

from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession

from app.models.api_key import ApiKey


def generate_api_key(prefix: str = "tf_live") -> tuple[str, str]:
    """
    Генерує API Key та повертає (plain_key, key_hash).

    Формат: {prefix}_{random_urlsafe_32_bytes}
    Наприклад: tf_live_bX3R9qKm7Vn2pL8sA1jD5cW4uY6oE0tF

    Returns:
        Кортеж (відкритий ключ для відправки клієнту, SHA-256 хеш для БД).
    """
    raw = secrets.token_urlsafe(32)
    plain_key = f"{prefix}_{raw}"
    key_hash = hashlib.sha256(plain_key.encode()).hexdigest()
    return plain_key, key_hash


class ApiKeyRepository:
    def __init__(self, db: AsyncSession) -> None:
        self._db = db

    async def get_by_hash(self, key_hash: str) -> ApiKey | None:
        result = await self._db.execute(
            select(ApiKey).where(ApiKey.key_hash == key_hash, ApiKey.is_active == True)
        )
        return result.scalar_one_or_none()

    async def create(
        self,
        user_id: uuid.UUID,
        name: str,
        plain_key: str,
        key_hash: str,
    ) -> ApiKey:
        api_key = ApiKey(
            key_hash=key_hash,
            key_prefix=plain_key[:16],
            name=name,
            user_id=user_id,
            is_active=True,
            created_at=datetime.now(timezone.utc),
        )
        self._db.add(api_key)
        await self._db.commit()
        await self._db.refresh(api_key)
        return api_key

    async def update_last_used(self, api_key: ApiKey) -> None:
        api_key.last_used_at = datetime.now(timezone.utc)
        await self._db.commit()

    async def revoke(self, api_key_id: uuid.UUID) -> None:
        key = await self._db.get(ApiKey, api_key_id)
        if key:
            key.is_active = False
            await self._db.commit()

# app/api/deps.py — додаємо нову dependency
import hashlib

from fastapi import Header, HTTPException, status

from app.db.session import get_db
from app.models.user import User
from app.repositories.api_key import ApiKeyRepository


async def get_user_from_api_key(
    x_api_key: str | None = Header(default=None, alias="X-API-Key"),
    db: AsyncSession = Depends(get_db),
) -> User:
    """
    Dependency: автентифікує через API Key з заголовка X-API-Key.

    Алгоритм:
    1. Витягує X-API-Key з заголовка запиту.
    2. Обчислює SHA-256 хеш ключа.
    3. Шукає ключ у БД за хешем.
    4. Повертає пов'язаного User або 401.
    """
    if x_api_key is None:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="X-API-Key header is required",
        )

    key_hash = hashlib.sha256(x_api_key.encode()).hexdigest()
    api_key_repo = ApiKeyRepository(db)
    api_key = await api_key_repo.get_by_hash(key_hash)

    if api_key is None:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Invalid or revoked API key",
        )

    # Оновлюємо last_used_at (у фоні, без блокування відповіді)
    await api_key_repo.update_last_used(api_key)

    return api_key.user

# app/api/v1/api_keys.py
import uuid

from fastapi import APIRouter, Depends, HTTPException, status
from pydantic import BaseModel
from sqlalchemy.ext.asyncio import AsyncSession

from app.api.deps import get_current_active_user
from app.db.session import get_db
from app.models.user import User
from app.repositories.api_key import ApiKeyRepository, generate_api_key

router = APIRouter(prefix="/api-keys", tags=["API Keys"])


class ApiKeyCreateRequest(BaseModel):
    name: str  # Опис: "GitHub Actions CI", "Monitoring script"


class ApiKeyCreateResponse(BaseModel):
    id: uuid.UUID
    name: str
    key_prefix: str
    # plain_key показується ОДИН РАЗ — після цього відновити неможливо
    plain_key: str


class ApiKeyListResponse(BaseModel):
    id: uuid.UUID
    name: str
    key_prefix: str
    is_active: bool

    model_config = {"from_attributes": True}


@router.post("/", response_model=ApiKeyCreateResponse, status_code=status.HTTP_201_CREATED)
async def create_api_key(
    body: ApiKeyCreateRequest,
    current_user: User = Depends(get_current_active_user),
    db: AsyncSession = Depends(get_db),
) -> ApiKeyCreateResponse:
    """
    Створює новий API Key для поточного користувача.
    ВАЖЛИВО: plain_key показується лише один раз у відповіді.
    Збережіть його — відновити буде неможливо.
    """
    plain_key, key_hash = generate_api_key(prefix="tf_live")
    api_key = await ApiKeyRepository(db).create(
        user_id=current_user.id,
        name=body.name,
        plain_key=plain_key,
        key_hash=key_hash,
    )
    return ApiKeyCreateResponse(
        id=api_key.id,
        name=api_key.name,
        key_prefix=api_key.key_prefix,
        plain_key=plain_key,  # єдиний раз — у відповіді на створення
    )


@router.delete("/{api_key_id}", status_code=status.HTTP_204_NO_CONTENT)
async def revoke_api_key(
    api_key_id: uuid.UUID,
    current_user: User = Depends(get_current_active_user),
    db: AsyncSession = Depends(get_db),
) -> None:
    """Відкликає (деактивує) API Key."""
    await ApiKeyRepository(db).revoke(api_key_id)

# app/middleware/security_headers.py
from starlette.middleware.base import BaseHTTPMiddleware
from starlette.requests import Request
from starlette.responses import Response


class SecurityHeadersMiddleware(BaseHTTPMiddleware):
    """
    Middleware для додавання HTTP Security Headers до кожної відповіді.

    Захищає від:
    - XSS (Content-Security-Policy)
    - Clickjacking (X-Frame-Options)
    - MIME sniffing (X-Content-Type-Options)
    - Protocol downgrade (Strict-Transport-Security)
    - Витоку даних через Referer (Referrer-Policy)
    """

    async def dispatch(self, request: Request, call_next) -> Response:
        response = await call_next(request)

        # Примушує браузер завжди використовувати HTTPS протягом 1 року.
        # includeSubDomains поширює правило на всі піддомени.
        # preload — дозволяє включення до HSTS preload list браузерів.
        response.headers["Strict-Transport-Security"] = (
            "max-age=31536000; includeSubDomains; preload"
        )

        # Забороняє браузеру «вгадувати» MIME тип файлу.
        # Без цього браузер міг би виконати JS замаскований под text/plain.
        response.headers["X-Content-Type-Options"] = "nosniff"

        # Забороняє відображення сторінки в iframe (захист від clickjacking).
        # SAMEORIGIN дозволяє лише iframe з того ж домену.
        response.headers["X-Frame-Options"] = "DENY"

        # Базова CSP: дозволяє ресурси лише з власного домену.
        # Для API (без HTML) достатньо мінімальної CSP.
        response.headers["Content-Security-Policy"] = (
            "default-src 'self'; "
            "frame-ancestors 'none'"  # еквівалент X-Frame-Options DENY для CSP Level 3
        )

        # Обмежує витік URL у заголовку Referer.
        # strict-origin-when-cross-origin: надсилає тільки origin (без path) для cross-origin.
        response.headers["Referrer-Policy"] = "strict-origin-when-cross-origin"

        # Вимикає доступ до браузерних API, що можуть бути зловживані.
        response.headers["Permissions-Policy"] = (
            "camera=(), microphone=(), geolocation=(), payment=()"
        )

        # Забороняє Internet Explorer переходити в режим сумісності.
        # Застарілий, але не шкодить.
        response.headers["X-UA-Compatible"] = "IE=edge"

        return response

# app/middleware/cors.py
from fastapi.middleware.cors import CORSMiddleware

# Налаштування для додавання у main.py
CORS_SETTINGS = {
    "allow_origins": [
        "https://taskforge.app",        # production frontend
        "https://staging.taskforge.app", # staging
        "http://localhost:3000",         # локальна розробка
        "http://localhost:5173",         # Vite dev server
    ],
    "allow_credentials": True,   # дозволяє передачу cookie та Authorization header
    "allow_methods": ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"],
    "allow_headers": [
        "Authorization",
        "Content-Type",
        "X-API-Key",
        "X-Request-ID",
    ],
    "expose_headers": [
        "X-Request-ID",              # клієнт бачить ID запиту для дебагу
    ],
    "max_age": 600,                  # браузер кешує preflight відповідь на 10 хвилин
}

# app/middleware/rate_limit.py
from slowapi import Limiter, _rate_limit_exceeded_handler
from slowapi.errors import RateLimitExceeded
from slowapi.util import get_remote_address

# Використовуємо IP-адресу клієнта як ключ для лімітування
limiter = Limiter(key_func=get_remote_address)

# app/main.py — повна фінальна версія з усіма middleware
from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware
from slowapi import _rate_limit_exceeded_handler
from slowapi.errors import RateLimitExceeded

from app.api.v1 import admin, api_keys, auth
from app.middleware.rate_limit import limiter
from app.middleware.security_headers import SecurityHeadersMiddleware

app = FastAPI(
    title="TaskForge API",
    description="Project management API — JWT + Opaque Refresh Token + RBAC",
    version="0.1.0",
)

# ─── State (для slowapi) ──────────────────────────────────────────────────────
app.state.limiter = limiter
app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)

# ─── Middleware (порядок важливий: виконуються у зворотному порядку) ──────────
app.add_middleware(SecurityHeadersMiddleware)

app.add_middleware(
    CORSMiddleware,
    allow_origins=[
        "https://taskforge.app",
        "http://localhost:3000",
        "http://localhost:5173",
    ],
    allow_credentials=True,
    allow_methods=["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"],
    allow_headers=["Authorization", "Content-Type", "X-API-Key"],
    max_age=600,
)

# ─── Роутери ──────────────────────────────────────────────────────────────────
app.include_router(auth.router, prefix="/api/v1")
app.include_router(admin.router, prefix="/api/v1")
app.include_router(api_keys.router, prefix="/api/v1")


@app.get("/health", tags=["System"])
async def health_check() -> dict:
    return {"status": "ok"}

# app/api/v1/auth.py — додаємо @limiter.limit до login та register
from app.middleware.rate_limit import limiter


@router.post("/login", response_model=TokenResponse)
@limiter.limit("5/minute")   # не більше 5 спроб логіну з одного IP за хвилину
async def login(
    request: Request,
    form_data: OAuth2PasswordRequestForm = Depends(),
    db: AsyncSession = Depends(get_db),
) -> TokenResponse:
    # ... (повна реалізація вже у Частині 3) ...
    pass


@router.post("/register", response_model=TokenResponse, status_code=status.HTTP_201_CREATED)
@limiter.limit("3/hour")     # не більше 3 реєстрацій з одного IP за годину
async def register(
    request: Request,
    data: UserRegisterRequest,
    db: AsyncSession = Depends(get_db),
) -> TokenResponse:
    # ... (повна реалізація вже у Частині 3) ...
    pass

SELECT token_hash, user_id, expires_at, created_at FROM refresh_tokens;

UPDATE users SET role = 'admin' WHERE email = 'your@email.com';