"""Neo4j queries for contributor projects."""

from typing import Any
from ddtrace import tracer
from neo4j import Session

from contributor.queries.neo4j.contributors import _node_to_dict

get_projects_by_label_participant_uuid = """
MATCH (lp:LabelParticipant {uuid: $uuid})
WHERE $is_admin OR EXISTS {
  MATCH (p:Profile {profileType: 'LabelProfile'})
  -[:HAS_ACCESS_TO|HAS_ADMIN_ACCESS_TO]->()
  -[:HAS_LABEL_PARTICIPANT]->(lp)
  WHERE p.profileId IN $profile_ids
}
WITH DISTINCT lp
OPTIONAL MATCH (project:Project)-[:CREATED_FOR_PARTICIPANT]->(lp)
RETURN {uuid: lp.uuid} AS contributor,
       collect({
           project_id: coalesce(project.projectId, project.id)
       }) AS projects
"""


get_label_participants_by_project_ids = """
UNWIND $project_ids AS project_id
MATCH (project:Project)
WHERE project.id = project_id
OPTIONAL MATCH (project)-[:CREATED_FOR_PARTICIPANT]->(lp:LabelParticipant)
WHERE lp IS NULL OR $is_admin OR EXISTS {
    MATCH (p:Profile {profileType: 'LabelProfile'})
    -[:HAS_ACCESS_TO|HAS_ADMIN_ACCESS_TO]->()
    -[:HAS_LABEL_PARTICIPANT]->(lp)
    WHERE p.profileId IN $profile_ids
}
WITH DISTINCT project, lp
OPTIONAL MATCH (lp)<-[:HAS_LABEL_PARTICIPANT]-(:Vendor)-[:HAS_ARTIST]->(ai:ArtistInfo)
WHERE lp IS NOT NULL
  AND lp.normalizedName = toLower(trim(apoc.text.regreplace(ai.name, '[ ]+', '')))
WITH project, lp, collect(DISTINCT ai.id) AS artist_info_ids
OPTIONAL MATCH (lp)<-[:REPRESENTS]-(gp:GlobalParticipant)
OPTIONAL MATCH (lp)<-[:HAS_LABEL_PARTICIPANT]-(vendor:Vendor)
OPTIONAL MATCH (lp)<-[:HAS_LABEL_PARTICIPANT]-(subaccount:Subaccount)
WITH project, lp, artist_info_ids, gp, vendor, subaccount,
     CASE WHEN lp IS NULL THEN NULL
          WHEN subaccount IS NOT NULL THEN {
            uuid: subaccount.uuid,
            vendorId: coalesce(vendor.vendorId, lp.vendorId),
            ownerVendorId: coalesce(vendor.vendorId, lp.vendorId),
            subaccountId: subaccount.subaccountId
          } ELSE {
            uuid: vendor.uuid,
            vendorId: coalesce(vendor.vendorId, lp.vendorId),
            ownerVendorId: coalesce(vendor.vendorId, lp.vendorId),
            subaccountId: coalesce(lp.subaccountId, 0)
          } END AS label
RETURN project.id AS project_id,
       collect(
           CASE WHEN lp IS NOT NULL THEN {
               lp: lp,
               artist_info_ids: artist_info_ids,
               gp: gp,
               label: label
           } END
       ) AS contributors
"""


@tracer.wrap()
def get_by_label_participant_uuid(
    session: Session,
    uuid: str,
    profile_ids: list[int],
    is_admin: bool = False,
) -> dict[str, Any] | None:
    result = session.run(
        get_projects_by_label_participant_uuid,
        uuid=uuid,
        profile_ids=profile_ids,
        is_admin=is_admin,
    )
    record = result.single()
    if record is None:
        return None
    projects = [
        {
            "project_id": p["project_id"],
        }
        for p in record["projects"]
        if p.get("project_id") is not None
    ]
    return {
        "contributor": record["contributor"],
        "projects": projects,
    }


@tracer.wrap()
def get_contributors_by_project_ids(
    session: Session,
    project_ids: list[int],
    profile_ids: list[int],
    is_admin: bool = False,
) -> list[dict[str, Any]]:
    result = session.run(
        query=get_label_participants_by_project_ids,
        project_ids=project_ids,
        profile_ids=profile_ids,
        is_admin=is_admin,
    )
    projects_data = []
    for record in result:
        contributors = [
            _node_to_dict(
                c["lp"],
                artist_info_ids=c["artist_info_ids"],
                gp=c["gp"],
                label=c.get("label"),
            )
            for c in record["contributors"]
            if c is not None and c.get("lp") is not None
        ]
        projects_data.append(
            {
                "project": {"project_id": record["project_id"]},
                "contributors": contributors,
            }
        )
    return projects_data