import src.messages as messages
import src.productors.exceptions as exceptions
from sqlmodel import Session, select
from src import models


def get_all(
    session: Session,
    user: models.User,
    names: list[str],
    types: list[str]
) -> list[models.ProductorPublic]:
    statement = select(models.Productor)\
        .where(models.Productor.type.in_([r.name for r in user.roles]))\
        .distinct()
    if len(names) > 0:
        statement = statement.where(models.Productor.name.in_(names))
    if len(types) > 0:
        statement = statement.where(models.Productor.type.in_(types))
    return session.exec(statement.order_by(models.Productor.name)).all()


def get_one(session: Session, productor_id: int) -> models.ProductorPublic:
    return session.get(models.Productor, productor_id)


def create_one(
        session: Session,
        productor: models.ProductorCreate) -> models.ProductorPublic:
    if not productor:
        raise exceptions.ProductorCreateError(
            messages.Messages.invalid_input(
                'productor', 'input cannot be None'))
    productor_create = productor.model_dump(
        exclude_unset=True, exclude='payment_methods')
    new_productor = models.Productor(**productor_create)

    new_productor.payment_methods = [
        models.PaymentMethod(
            name=pm.name,
            details=pm.details
        ) for pm in productor.payment_methods
    ]

    session.add(new_productor)
    session.commit()
    session.refresh(new_productor)
    return new_productor


def update_one(
        session: Session,
        id: int,
        productor: models.ProductorUpdate) -> models.ProductorPublic:
    statement = select(models.Productor).where(models.Productor.id == id)
    result = session.exec(statement)
    new_productor = result.first()
    if not new_productor:
        raise exceptions.ProductorNotFoundError(
            messages.Messages.not_found('productor'))

    productor_updates = productor.model_dump(exclude_unset=True)
    if 'payment_methods' in productor_updates:
        new_productor.payment_methods.clear()
        for pm in productor_updates['payment_methods']:
            new_productor.payment_methods.append(
                models.PaymentMethod(
                    name=pm['name'],
                    details=pm['details'],
                    productor_id=id,
                    max=pm['max']
                )
            )
        del productor_updates['payment_methods']

    for key, value in productor_updates.items():
        setattr(new_productor, key, value)
    session.add(new_productor)
    session.commit()
    session.refresh(new_productor)
    return new_productor


def delete_one(session: Session, _id: int) -> models.ProductorPublic:
    statement = select(models.Productor).where(models.Productor.id == _id)
    result = session.exec(statement)
    productor = result.first()
    if not productor:
        raise exceptions.ProductorNotFoundError(
            messages.Messages.not_found('productor'))
    result = models.ProductorPublic.model_validate(productor)
    session.delete(productor)
    session.commit()
    return result

def is_allowed(
    session: Session, 
    user: models.User, 
    _id: int, 
    productor: models.ProductorCreate
) -> bool:
    if not _id:
        return productor.type in [r.name for r in user.roles]
    statement = (
        select(models.Productor)
        .where(models.Productor.id == _id)
        .where(models.Productor.type.in_([r.name for r in user.roles]))
        .distinct()
    )
    return len(session.exec(statement).all()) > 0