"""Model for vend_contact_role."""

from flask import g
from sqlalchemy import Column, ForeignKey, Integer, orm

from permissions.connectors import mysql

# vendor_role must be imported otherwise sqlalchemy gets mad about not finding that table
from permissions.models import vend_contact as vend_contact_model, vendor_role  # noqa: F401


class VendContactRole(mysql.Base):
    """Model for vend_contact_role."""

    __tablename__ = 'vend_contact_roles'

    id = Column(Integer, primary_key=True)  # noqa: A003
    role_id = Column(Integer, ForeignKey('vendor_roles.id'))
    vend_contact_id = Column(Integer, ForeignKey('vend_contact.id'))
    vend_contact = orm.relationship(vend_contact_model.VendContact)

    @classmethod
    def create_by_role_ids_if_not_exist(
        cls,
        tx: orm.Session,
        vend_contact: vend_contact_model.VendContact,
        role_ids: list[int],
    ) -> list:
        """
        Create any vendor contact roles that don't yet exist.

        Only returns newly created roles, if any.
        """
        existing_roles = (
            tx.query(cls)
            .filter(
                cls.vend_contact_id == vend_contact.id,
                cls.role_id.in_(role_ids),
            )
            .all()
        )
        existing_ids = [r.role_id for r in existing_roles]
        if any(existing_ids):
            g.log.info(
                'Existing vend_contact_roles found for invited user',
                resources={'existing_role_ids': existing_ids},
            )

        if sorted(role_ids) != sorted(existing_ids):
            if any([role_id not in role_ids for role_id in existing_ids]):
                g.log.warn(
                    'Existing vend contact roles found that did not match requested roles',
                    resources={
                        'requested_role_ids': role_ids,
                        'existing_role_ids': existing_ids,
                    },
                )
            if not_existing := [role_id for role_id in role_ids if role_id not in existing_ids]:
                return [cls(role_id=role_id, vend_contact=vend_contact) for role_id in not_existing]
        else:
            return []

    @classmethod
    def get_role_ids_by_vend_contact(
        cls,
        tx: orm.Session,
        vend_contact_id: int,
    ) -> list:
        """Get role_ids by vend_contact."""
        existing_roles = tx.query(cls).filter(cls.vend_contact_id == vend_contact_id).all()
        return [r.role_id for r in existing_roles]

    @classmethod
    def delete_roles_by_ids_and_vend_contact_id(
        cls,
        tx: orm.Session,
        role_ids: list[int],
        vend_contact_id: int,
    ) -> None:
        """Delete vend contact roles by IDs."""
        tx.query(cls).filter(
            cls.role_id.in_(role_ids),
            cls.vend_contact_id == vend_contact_id,
        ).delete(synchronize_session=False)

    @classmethod
    def delete_roles_by_vend_contact_id(cls, session: orm.Session, vend_contact_id: int) -> None:
        """Delete all vend contact roles by vend_contact_id."""
        session.query(cls).filter(cls.vend_contact_id == vend_contact_id).delete(
            synchronize_session=False
        )
        g.log.info(
            'Deleted all vend contact roles for vend_contact',
            resources={'vend_contact_id': vend_contact_id},
        )