"""Company Brand model."""

from uuid import UUID

from ddtrace import tracer
from owsresponse import response
from sqlalchemy import Column, ForeignKey, Integer, String
from sqlalchemy.orm import relationship

from account.connectors import mysql
from account.models.parent_company import ParentCompany


class CompanyBrand(mysql.BaseModel):
    """CompanyBrand DB Model."""

    __tablename__ = 'company_brand'

    id = Column(Integer, primary_key=True)
    name = Column(String)
    uuid = Column(String)
    display_name = Column(String)
    parent_company_id = Column(Integer, ForeignKey('parent_company.id'), default=None)
    logo_url = Column(String)
    parent_company = relationship(
        'ParentCompany',
        primaryjoin='CompanyBrand.parent_company_id == ParentCompany.id',
        back_populates='company_brands',
        lazy='joined',
    )

    def to_dict(self):
        """Get a dict representation of CompanyBrand."""
        return {
            'id': self.id,
            'name': self.name,
            'uuid': self.uuid,
            'display_name': self.display_name,
            'logo_url': self.logo_url,
            'parent_company_id': self.parent_company_id,
            'parent_company_uuid': self.parent_company.uuid,
        }


def get_company_brands() -> list['CompanyBrand']:
    """Get all company brands."""
    with mysql.session_scope(read_only=True) as session:
        return session.query(CompanyBrand).all()


def get_company_brand(uuid: str) -> 'CompanyBrand | None':
    """Get a single company brand by UUID."""
    with mysql.session_scope(read_only=True) as session:
        return session.query(CompanyBrand).filter(CompanyBrand.uuid == uuid).first()


@tracer.wrap()
def lookup_company_brands_by_names(
    names: list[str],
) -> response.Response:
    """Lookup company brands by names."""
    if not names:
        return response.Response([])

    select_entities = [
        CompanyBrand.id,
        CompanyBrand.uuid.label('uuid'),
        ParentCompany.uuid.label('parent_company_uuid'),
    ]
    join_entities = [CompanyBrand.parent_company]

    with mysql.session_scope(read_only=True) as session:
        query = session.query(*select_entities)
        query = query.join(*join_entities)
        result = query.filter(CompanyBrand.name.in_(names))
        if not result:
            return response.create_not_found_response(message='vendor_uuids not found.')
        return response.Response([row._asdict() for row in result])


def lookup_company_brands_by_uuids(
    company_brands_uuids: list[UUID],
) -> response.Response:
    """Lookup company brands by uuids.

    Args:
        company_brands_uuids: list of company brands uuids

    Return:
        response.Response.message: list(obj).
        obj shape:
            {
                company_brand_id: number
                uuid: str
                parent_company_uuid: str
            }
    """
    if not company_brands_uuids:
        return response.Response([])

    uuids = [str(uuid) for uuid in company_brands_uuids]

    select_entities = [
        CompanyBrand.id.label('company_brand_id'),
        CompanyBrand.uuid.label('uuid'),
        ParentCompany.uuid.label('parent_company_uuid'),
    ]
    join_entities = [CompanyBrand.parent_company]

    with mysql.session_scope(read_only=True) as session:
        query = session.query(*select_entities)
        query = query.join(*join_entities)
        result = query.filter(CompanyBrand.uuid.in_(uuids))
        if not result:
            return response.create_not_found_response(message='company_brand_uuids not found.')
        return response.Response([row._asdict() for row in result])


def lookup_company_brands_by_ids(
    company_brand_ids: list[int],
) -> response.Response:
    """Lookup company brands by ids.

    Args:
        company_brand_ids: list of company brand ids

    Return:
        response.Response.message: list(obj).
        obj shape:
            {
                company_brand_id: number
                uuid: str
                parent_company_uuid: str
            }
    """
    if not company_brand_ids:
        return response.Response([])

    select_entities = [
        CompanyBrand.id.label('company_brand_id'),
        CompanyBrand.uuid.label('uuid'),
        ParentCompany.uuid.label('parent_company_uuid'),
    ]
    join_entities = [CompanyBrand.parent_company]

    with mysql.session_scope(read_only=True) as session:
        query = session.query(*select_entities)
        query = query.join(*join_entities)
        result = query.filter(CompanyBrand.id.in_(company_brand_ids))
        if not result:
            return response.create_not_found_response(message='company_brand_ids not found.')
        return response.Response([row._asdict() for row in result])