"""Queries for fetching nodes."""

# flake8: noqa

get_label_participant_by_id = """
MATCH (node:LabelParticipant)
    WHERE node.id = $id
    AND
        node.vendorId = $vendor_id
    {subaccount_clause}
RETURN node
LIMIT 1
"""

get_label_participant_by_id_and_resources = """
MATCH (node:LabelParticipant)-[:CREATED_FROM]->(ai:ArtistInfo)
WHERE node.id = $id
AND ai.id IN ($artist_info_resources)
RETURN node
LIMIT 1
"""

get_label_participant_by_id_only = """
MATCH (lp:LabelParticipant)
    WHERE lp.id = $id
RETURN lp as node
LIMIT 1
"""

get_label_participant_by_name = """
MATCH (lp:LabelParticipant)
    WHERE lp.name = $lp_name
    AND lp.vendorId = $vendor_id
RETURN lp as node
LIMIT 1
"""

get_label_participant_related_by_artist_info = """
MATCH (ai:ArtistInfo)-[rel:CREATED_FROM]-(lp:LabelParticipant) 
WHERE lp.vendorId = $vendor_id AND ai.id = $artist_info_id RETURN lp as node
"""

get_label_participant_by_uuid = """
MATCH (lp:LabelParticipant) WHERE lp.uuid = $uuid
RETURN lp as node
"""

subaccount_clause = 'AND node.subaccountId = $subaccount_id'
role_clause = 'WITH node, score MATCH (node)-[r:PARTICIPATED_IN]->(:Product) WHERE r.participated_as = "performer" OR r.participated_as = "featuring"'  # noqa

search_label_participant = """
CALL apoc.cypher.mapParallel('
    CALL db.index.fulltext.queryNodes("participantNames", _)
    YIELD node, score
    WHERE node.vendorId = $vendor_id {subaccount_clause} {role_clause}
    RETURN node, score
    LIMIT 100',
    {{vendor_id: $vendor_id, subaccount_id: $subaccount_id}},
    [$exact_query, $wildcard_query, $fuzzy_query, $default_query]
)
YIELD value
WITH value.node AS node, max(value.score) AS max_score
RETURN node
ORDER BY max_score desc, toLower(node.name)
LIMIT 100
"""

create_label_participant = """
CALL apoc.when(
    $subaccount_id = 0,
    '
        MATCH (vendor:Vendor { id: vendorId })
        RETURN [vendor] as labelNodes
    ',
    '
        MATCH (vendor:Vendor { id: vendorId })-[:OWNS]->(subaccount:SubAccount { id: subaccountId })
        RETURN [vendor, subaccount] as labelNodes
    ',
    {
        vendorId: $vendor_id,
        subaccountId: $subaccount_id
    }
) YIELD value
WHERE size(value.labelNodes) > 0 AND size(value.labelNodes) < 3

WITH *,
CASE WHEN TRIM($spotify_id) = '' THEN NULL ELSE $spotify_id END AS spotifyId,
CASE WHEN TRIM($apple_music_id) = '' THEN NULL ELSE $apple_music_id END AS appleMusicId

MERGE (
    lp:LabelParticipant:Orchard {
        normalizedName: toLower(trim(apoc.text.regreplace($name, '[ ]+', ''))),
        vendorId: $vendor_id,
        subaccountId: $subaccount_id
    }
)
ON CREATE SET
    lp.id = datetime.realtime().epochMillis,
    lp.name = trim(apoc.text.regreplace($name, '[ ]{2,}', ' ')),
    lp.spotifyId = COALESCE(spotifyId, lp.spotifyId),
    lp.appleMusicId = COALESCE(appleMusicId, lp.appleMusicId),
    lp.uuid = randomUUID(),
    lp.createdAt = datetime(),
    lp.createdBy = 'ows-participant/create_label_participant'
ON MATCH SET
    lp.name = trim(apoc.text.regreplace($name, '[ ]{2,}', ' ')),
    lp.spotifyId = COALESCE(spotifyId, lp.spotifyId),
    lp.appleMusicId = COALESCE(appleMusicId, lp.appleMusicId),
    lp.lastModifiedAt = datetime(),
    lp.lastModifiedBy = 'ows-participant/create_label_participant'
WITH *
FOREACH (label IN value.labelNodes |
    MERGE (label)-[:HAS_LABEL_PARTICIPANT]->(lp)
)
WITH *
FOREACH (canLink IN CASE WHEN spotifyId IS NOT NULL THEN [1] ELSE [] END |
    MERGE(gp:GlobalParticipant {spotifyId: spotifyId})
        ON CREATE SET
            gp.id = randomUUID(),
            gp.createdAt = datetime(),
            gp.name = lp.name,
            gp.createdAt = datetime(),
            gp.createdBy = 'ows-participant/create_label_participant'

    MERGE (gp)-[r:REPRESENTS]->(lp)
    ON CREATE SET
        r.createdAt = datetime(),
        r.createdBy = 'ows-participant/create_label_participant'
)
WITH *
OPTIONAL MATCH (oldGp:GlobalParticipant)-[oldRepresents:REPRESENTS]->(lp)
WHERE oldGp.spotifyId <> lp.spotifyId
FOREACH (hasOldGp IN CASE WHEN oldGp IS NOT NULL THEN [1] ELSE [] END |
    DELETE oldRepresents
)
WITH *
OPTIONAL MATCH (lp)<-[:HAS_LABEL_PARTICIPANT]-(v:Vendor)
OPTIONAL MATCH (v)<-[:HAS_LABEL]-(cb:CompanyBrand)-[:BELONGS_TO]->(pc:ParentCompany)
OPTIONAL MATCH (lp)<-[:HAS_LABEL_PARTICIPANT]-(sa:Subaccount)
SET lp.companyBrandUUID = cb.uuid,
    lp.vendorUUID = v.uuid,
    lp.subaccountUUID = sa.uuid,
    lp.parentCompanyUUID = pc.uuid
RETURN lp as node
"""

get_label_participants_by_related_product_id = """
MATCH (lp:LabelParticipant)-[r:PARTICIPATED_IN]->(p:Product)
WHERE p.id = $product_id AND lp.vendorId = $vendor_id AND lp.subaccountId = $subaccount_id
MATCH (lp)-[:CREATED_FROM]-(ra:ReleaseArtist)-[:HAS_SOURCE_ARTIST]-(p)
WITH lp AS node, r, MIN(ra.id) as orderValue
RETURN node, r
ORDER BY orderValue
"""

merge_artist_nodes = """
MATCH (masterNode:LabelParticipant {id: $master_lp_id})
MATCH (dupNode:LabelParticipant {id: $current_lp_id})
CALL apoc.refactor.mergeNodes(
    [masterNode, dupNode],
    {
        properties: "discard",
        mergeRels: true
    }
) YIELD node
RETURN masterNode as node
"""

get_label_participants_by_related_track_id = """
MATCH (t:Track)-[:HAS_PARTICIPANT]->(lp:LabelParticipant)
    WHERE t.id = {id}
return DISTINCT lp as node
"""

create_relationship = """
MATCH (fromNode:{from_node_label}:Orchard {{id: $from_node_id}}),(toNode:{to_node_label}:Orchard {{id: $to_node_id}})
WHERE fromNode.vendorId = $vendor_id AND fromNode.subaccountId = $subaccount_id
MERGE (fromNode)-[r:{relationship_name} {{{relationship_property}: $relationship_value}}]->(toNode)
RETURN r
"""

update_relationship = """
MATCH (fromNode:{from_node_label}:Orchard {{id: $from_node_id}})-[r:{relationship_name} {{{relationship_property}: $relationship_value}}]->(toNode:{to_node_label}:Orchard {{id: $to_node_id}})
WHERE fromNode.vendorId = $vendor_id AND fromNode.subaccountId = $subaccount_id
SET r.{relationship_property} = $relationship_new_value
RETURN r
"""

delete_relationship = """
MATCH (fromNode:{from_node_label}:Orchard {{id: $from_node_id}})-[r:{relationship_name} {{{relationship_property}: $relationship_value}}]->(toNode:{to_node_label}:Orchard {{id: $to_node_id}})
WHERE fromNode.vendorId = $vendor_id AND fromNode.subaccountId = $subaccount_id
DELETE r
"""

update_label_participant_name = """
MATCH(lp:LabelParticipant {uuid: $uuid})
SET lp.name = $name, lp.lastModifiedBy = $modified_by,
lp.normalizedName = $normalized_name,
lp.lastModifiedAt = $modified_at
RETURN lp as node
"""

lookup_label_participants_hierarchy_by_uuid = """
MATCH (lp:LabelParticipant)
WHERE lp.uuid IN $uuids
OPTIONAL MATCH (lp)<-[:HAS_LABEL_PARTICIPANT]-(v:Vendor)
OPTIONAL MATCH (lp)<-[:HAS_LABEL_PARTICIPANT]-(s:Subaccount)
OPTIONAL MATCH (v)<-[:HAS_LABEL]-(cb:CompanyBrand)-[:BELONGS_TO]->(pc:ParentCompany)
RETURN lp.uuid as uuid, v.uuid as vendor_uuid, s.uuid as subaccount_uuid,
cb.uuid as company_brand_uuid, pc.uuid as parent_company_uuid
"""