//
// 1. Create Claimants
//
CREATE (c1:Claimant {name: "John Doe"})
CREATE (c2:Claimant {name: "Jane Smith"})
CREATE (c3:Claimant {name: "Bob Johnson"})


//
// 2. Create Medical Professionals
//
CREATE (m1:MedicalProfessional {name: "Dr. Gregory House"})
CREATE (m2:MedicalProfessional {name: "Dr. John Watson"})


//
// 3. Create Vehicles
//
CREATE (v1:Vehicle {VIN: "VIN-12345"})
CREATE (v2:Vehicle {VIN: "VIN-67890"})
CREATE (v3:Vehicle {VIN: "VIN-111213"})


//
// 4. Create Claims
//
CREATE (cl1:Claim {claimID: "CL100", date: date("2025-01-01"), amountClaimed: 5000})
CREATE (cl2:Claim {claimID: "CL101", date: date("2025-01-05"), amountClaimed: 2000})
CREATE (cl3:Claim {claimID: "CL102", date: date("2025-01-10"), amountClaimed: 10000})
CREATE (cl4:Claim {claimID: "CL103", date: date("2025-01-12"), amountClaimed: 8000})


//
// 5. Establish Relationships
//


// John Doe has claim CL100, treated by Dr. House.
// John Doe owns VIN-12345, which was involved in CL100.
CREATE (c1)-[:HAS_CLAIM]->(cl1)
CREATE (cl1)-[:TREATED_BY]->(m1)
CREATE (c1)-[:OWNS]->(v1)
CREATE (v1)-[:INVOLVED_IN]->(cl1)
CREATE (m1)-[:TREATS]->(c1)


// Jane Smith has claim CL101, treated by Dr. Watson.
// Jane Smith owns VIN-67890, which was involved in CL101.
CREATE (c2)-[:HAS_CLAIM]->(cl2)
CREATE (cl2)-[:TREATED_BY]->(m2)
CREATE (c2)-[:OWNS]->(v2)
CREATE (v2)-[:INVOLVED_IN]->(cl2)
CREATE (m2)-[:TREATS]->(c2)


// Bob Johnson has claim CL102, treated by Dr. Watson.
// Bob Johnson owns VIN-111213, which was involved in CL102.
CREATE (c3)-[:HAS_CLAIM]->(cl3)
CREATE (cl3)-[:TREATED_BY]->(m2)
CREATE (c3)-[:OWNS]->(v3)
CREATE (v3)-[:INVOLVED_IN]->(cl3)
CREATE (m2)-[:TREATS]->(c3)


// Create a second claim for John Doe (CL103),
// which is also treated by Dr. House and involves the same vehicle VIN-12345.
CREATE (c1)-[:HAS_CLAIM]->(cl4)
CREATE (cl4)-[:TREATED_BY]->(m1)
CREATE (v1)-[:INVOLVED_IN]->(cl4)
CREATE (m1)-[:TREATS]->(c1)

// Show neo4j scheme
CALL db.schema.visualization()

MATCH path=(c:Claimant)-[:HAS_CLAIM]->(cl:Claim)
WITH c, count(cl) AS numClaims
WHERE numClaims > 1
RETURN path

MATCH (m:MedicalProfessional)<-[:TREATED_BY]-(cl:Claim)
WITH m, count(cl) AS claimCount, sum(cl.amountClaimed) AS totalAmount
WHERE claimCount > 1 OR totalAmount > 5000
RETURN m.name AS MedicalProfessional, claimCount, totalAmount
ORDER BY totalAmount DESC

MATCH path=(m:MedicalProfessional)<-[:TREATED_BY]-(cl:Claim)
WITH m, count(cl) AS claimCount, sum(cl.amountClaimed) AS totalAmount, path
WHERE claimCount > 1 OR totalAmount > 5000
RETURN path

MATCH (m:MedicalProfessional)<-[:TREATED_BY]-(cl:Claim)
WITH m, count(cl) AS claimCount, sum(cl.amountClaimed) AS totalAmount
WHERE claimCount > 1 OR totalAmount > 5000
RETURN m.name AS MedicalProfessional, claimCount, totalAmount
ORDER BY totalAmount DESC

MATCH (v:Vehicle)-[:INVOLVED_IN]->(cl:Claim)
WITH v, collect(cl) AS allClaims
WHERE size(allClaims) > 1
UNWIND allClaims AS claim
MATCH path=(v)-[:INVOLVED_IN]->(claim)
RETURN path

MATCH (v:Vehicle)-[:INVOLVED_IN]->(cl:Claim)
WITH v, count(cl) AS claimCount
WHERE claimCount > 1
RETURN v.VIN AS Vehicle, claimCount

// First identify the components
CALL gds.wcc.stream('fraud-graph')
YIELD nodeId, componentId
WITH gds.util.asNode(nodeId) as node, componentId
// Group by component and collect node information
WITH componentId,
     collect(DISTINCT labels(node)[0]) as nodeTypes,
     count(*) as componentSize,
     collect(DISTINCT
        CASE labels(node)[0]
            WHEN 'Claimant' THEN node.name
            WHEN 'MedicalProfessional' THEN node.name
            WHEN 'Claim' THEN node.claimID
            WHEN 'Vehicle' THEN node.VIN
            ELSE null
        END
     ) as entities
// Filter out null values and return meaningful information
WITH componentId,
     componentSize,
     nodeTypes,
     [x IN entities WHERE x IS NOT NULL] as connectedEntities
RETURN
    componentId,
    componentSize as size,
    nodeTypes as types,
    connectedEntities as entities
ORDER BY size DESC
LIMIT 10;