"""Deal repository with access-aware CRUD helpers."""
from __future__ import annotations

from collections.abc import Mapping, Sequence
from dataclasses import dataclass
from decimal import Decimal
from typing import Any

from sqlalchemy import Select, asc, desc, select
from sqlalchemy.ext.asyncio import AsyncSession

from app.models.deal import Deal, DealCreate, DealStage, DealStatus
from app.models.organization_member import OrganizationRole


ORDERABLE_COLUMNS: dict[str, Any] = {
	"created_at": Deal.created_at,
	"amount": Deal.amount,
	"title": Deal.title,
}


class DealAccessError(Exception):
	"""Raised when a user attempts an operation without sufficient permissions."""


@dataclass(slots=True)
class DealQueryParams:
	"""Filters supported by list queries."""

	organization_id: int
	page: int = 1
	page_size: int = 20
	statuses: Sequence[DealStatus] | None = None
	stage: DealStage | None = None
	owner_id: int | None = None
	min_amount: Decimal | None = None
	max_amount: Decimal | None = None
	order_by: str | None = None
	order_desc: bool = True


class DealRepository:
	"""Provides CRUD helpers for deals with role-aware filtering."""

	def __init__(self, session: AsyncSession) -> None:
		self._session = session

	@property
	def session(self) -> AsyncSession:
		return self._session

	async def list(
		self,
		*,
		params: DealQueryParams,
		role: OrganizationRole,
		user_id: int,
	) -> Sequence[Deal]:
		stmt = select(Deal).where(Deal.organization_id == params.organization_id)
		stmt = self._apply_filters(stmt, params, role, user_id)
		stmt = self._apply_ordering(stmt, params)

		offset = (max(params.page, 1) - 1) * params.page_size
		stmt = stmt.offset(offset).limit(params.page_size)
		result = await self._session.scalars(stmt)
		return result.all()

	async def get(
		self,
		deal_id: int,
		*,
		organization_id: int,
		role: OrganizationRole,
		user_id: int,
		require_owner: bool = False,
	) -> Deal | None:
		stmt = select(Deal).where(Deal.id == deal_id, Deal.organization_id == organization_id)
		stmt = self._apply_role_clause(stmt, role, user_id, require_owner=require_owner)
		result = await self._session.scalars(stmt)
		return result.first()

	async def create(
		self,
		data: DealCreate,
		*,
		role: OrganizationRole,
		user_id: int,
	) -> Deal:
		if role == OrganizationRole.MEMBER and data.owner_id != user_id:
			raise DealAccessError("Members can only create deals they own")
		deal = Deal(**data.model_dump())
		self._session.add(deal)
		await self._session.flush()
		return deal

	async def update(
		self,
		deal: Deal,
		updates: Mapping[str, Any],
		*,
		role: OrganizationRole,
		user_id: int,
	) -> Deal:
		if role == OrganizationRole.MEMBER and deal.owner_id != user_id:
			raise DealAccessError("Members can only modify their own deals")
		for field, value in updates.items():
			if hasattr(deal, field):
				setattr(deal, field, value)
		await self._session.flush()
		await self._session.refresh(deal)
		return deal

	def _apply_filters(
		self,
		stmt: Select[tuple[Deal]],
		params: DealQueryParams,
		role: OrganizationRole,
		user_id: int,
	) -> Select[tuple[Deal]]:
		if params.statuses:
			stmt = stmt.where(Deal.status.in_(params.statuses))
		if params.stage:
			stmt = stmt.where(Deal.stage == params.stage)
		if params.owner_id is not None:
			if role == OrganizationRole.MEMBER and params.owner_id != user_id:
				raise DealAccessError("Members cannot filter by other owners")
			stmt = stmt.where(Deal.owner_id == params.owner_id)
		if params.min_amount is not None:
			stmt = stmt.where(Deal.amount >= params.min_amount)
		if params.max_amount is not None:
			stmt = stmt.where(Deal.amount <= params.max_amount)

		return self._apply_role_clause(stmt, role, user_id)

	def _apply_role_clause(
		self,
		stmt: Select[tuple[Deal]],
		role: OrganizationRole,
		user_id: int,
		*,
		require_owner: bool = False,
	) -> Select[tuple[Deal]]:
		if role in {OrganizationRole.OWNER, OrganizationRole.ADMIN, OrganizationRole.MANAGER}:
			return stmt
		if require_owner:
			return stmt.where(Deal.owner_id == user_id)
		return stmt

	def _apply_ordering(self, stmt: Select[tuple[Deal]], params: DealQueryParams) -> Select[tuple[Deal]]:
		column = ORDERABLE_COLUMNS.get(params.order_by or "created_at", Deal.created_at)
		order_func = desc if params.order_desc else asc
		return stmt.order_by(order_func(column))